rvlib-shipkit 1.2.0 → 1.4.0

package/src/core/run-fix.ts

@@ -17,6 +17,9 @@ export type FixOpts = {
      *  not wire-shaped, which the frozen output contract forbids */
     quiet?: boolean
     print?: (line: string) => void
+    /** where a fix that changed nothing reports, since the run after it says
+     *  the same about that check. Default: print */
+    detail?: (line: string) => void
     /** the config as it stands on disk now, when the caller holds one: a
      *  second load of a rewritten repo.config.ts can hit the module cache */
     config?: RepoConfig
@@ -75,7 +78,8 @@ export async function runFix(root: string, o: FixOpts = {}): Promise<number> {
         // it is an ok, not a warning. It carries a frozen wire prefix like
         // every other line the fix pass emits: `shipkit ci` promises its whole
         // output is parseable, and a bare line breaks that for every reader.
-        print(f.changed ? `ok: [${rule.id}] fixed: ${f.summary}` : `ok: [${rule.id}] fix changed nothing — ${f.summary}`)
+        const say = f.changed ? print : o.detail ?? print
+        say(f.changed ? `ok: [${rule.id}] fixed: ${f.summary}` : `ok: [${rule.id}] fix changed nothing — ${f.summary}`)
         // a fixer may rewrite repo.config.ts, and the re-run below and every
         // fixer after it must read what is on disk now, never the config this
         // pass loaded before the rewrite
@@ -89,7 +93,8 @@ export async function runFix(root: string, o: FixOpts = {}): Promise<number> {
         await runCheckBody(rule, after)
         // the fix already ran: advertising it again on surviving findings
         // would send an agent in a loop
-        for (const l of after.lines) print(formatLine({ ...l, text: l.text.replace(/ · autofix: shipkit check --fix \S+$/, '') }, color))
+        // inside the ci fix pass the run below reports this check's end state
+        for (const l of after.lines) (o.quiet === true ? o.detail ?? print : say)(formatLine({ ...l, text: l.text.replace(/ · autofix: shipkit check --fix \S+$/, '') }, color))
         if (after.failed) exit = 1
     }
     const unfixable = all.filter((r) => r.fix == null).length

package/src/core/run-fixers.ts

@@ -140,6 +140,9 @@ export type FixPassOpts = {
      *  mutate the tree they are about to ship) */
     armHooks?: boolean
     print: (line: string) => void
+    /** where the lines nobody acts on go (a clean pass, an unfilled slot).
+     *  Default: print. `shipkit ci` shows them only under --verbose */
+    detail?: (line: string) => void
 }
 
 export type FixPassResult = {
@@ -220,12 +223,13 @@ async function fixPassBody(root: string, loaded: RepoConfig, o: FixPassOpts, ver
     if (o.armHooks === true && !verify) {
         const armed = armHooks(root, config)
         if (armed.state === 'armed') o.print(`ok: hooks armed (${armed.detail}), commit the .shipkit/hooks/ dir`)
-        else if (armed.state === 'foreign' || armed.state === 'not-root') o.print(`skip: hooks (${armed.detail})`)
+        else if (armed.state === 'foreign' || armed.state === 'not-root') (o.detail ?? o.print)(`skip: hooks (${armed.detail})`)
         else if (armed.state === 'failed') o.print(`WARN hooks could not arm: ${armed.detail}`)
     }
+    const detail = o.detail ?? o.print
     const { slots, unfilled, disabled } = resolveFixers(root, config)
-    for (const u of unfilled) o.print(`skip: ${u.id} (${u.reason})`)
-    for (const d of disabled) o.print(`skip: ${d.id} (${d.reason})`)
+    for (const u of unfilled) detail(`skip: ${u.id} (${u.reason})`)
+    for (const d of disabled) detail(`skip: ${d.id} (${d.reason})`)
     const before = treeState(root)
 
     for (const s of slots) {
@@ -236,7 +240,7 @@ async function fixPassBody(root: string, loaded: RepoConfig, o: FixPassOpts, ver
             o.print(`WARN fix ${s.id} failed (exit ${r.code}) — ${r.out.trim().split('\n').at(-1)?.slice(0, 160) ?? ''}; the gate below still ran`)
     }
     // structural repo-config repair is never implicit, and never in verify mode
-    if (o.rules === true && !verify) await runFix(root, { quiet: true, print: o.print, config })
+    if (o.rules === true && !verify) await runFix(root, { quiet: true, print: o.print, detail: o.detail, config })
 
     const after = treeState(root)
     const reshaped = shapeStamp(root) !== shapeBefore
@@ -257,11 +261,11 @@ async function fixPassBody(root: string, loaded: RepoConfig, o: FixPassOpts, ver
     }
     const list = `${touched.slice(0, 8).join(' ')}${touched.length > 8 ? ` … +${touched.length - 8}` : ''}`
     if (before == null) {
-        o.print(`ok: fix pass ran, ${slots.length} fixer(s) (not a git repo — rewritten files cannot be listed)`)
+        detail(`ok: fix pass ran, ${slots.length} fixer(s) (not a git repo — rewritten files cannot be listed)`)
         return { ran: true, touched, failed: false, reshaped }
     }
     if (touched.length === 0) {
-        o.print(`ok: ${verify ? 'fixers verified' : 'fix pass'} clean (${slots.length} fixer(s), nothing to rewrite)`)
+        detail(`ok: ${verify ? 'fixers verified' : 'fix pass'} clean (${slots.length} fixer(s), nothing to rewrite)`)
         return { ran: true, touched, failed: false, reshaped }
     }
     if (verify) {

package/src/core/wire.ts

@@ -3,22 +3,51 @@
 // exit 0/1. FROZEN: consumers grep startsWith('FAIL'/'WARN'/'skip:') — a
 // prefix change is a breaking change of the whole toolkit.
 
-export type Line = { kind: 'ok' | 'warn' | 'fail' | 'note' | 'fix-warn' | 'fix-fail' | 'skip'; text: string }
+import { CACHED, RAN } from './outcome-words.ts'
+
+/** when a remembered world answer was measured, and until when it keeps
+ *  (null: until its declaration changes). Kept as data, never as text, and
+ *  rendered against the reader's clock: a time frozen into the line reads
+ *  as a future expiry long after it passed */
+export type Stamp = { at: number; until: number | null; cached?: boolean }
+
+export type Line = { kind: 'ok' | 'warn' | 'fail' | 'note' | 'fix-warn' | 'fix-fail' | 'skip'; text: string; stamp?: Stamp }
+
+/** a span in its one biggest unit: `45s`, `12m`, `3h`, `2d` */
+export function spanShort(ms: number): string {
+    const s = Math.max(0, Math.round(ms / 1000))
+    if (s < 60) return `${s}s`
+    if (s < 3600) return `${Math.floor(s / 60)}m`
+    if (s < 86400) return `${Math.floor(s / 3600)}h`
+    return `${Math.floor(s / 86400)}d`
+}
+
+/** `cached, ran 3h ago, kept 57m more`, `ran 1d ago, expired 1d ago` */
+export function stampWords(s: Stamp, now: number): string {
+    const age = now - s.at
+    const ran = age < 1000 ? `${RAN} just now` : `${RAN} ${spanShort(age)} ago`
+    const keeps = s.until == null ? 'kept until its declaration changes' : s.until > now ? `kept ${spanShort(s.until - now)} more` : `expired ${spanShort(now - s.until)} ago`
+    return `${s.cached === true ? `${CACHED}, ` : ''}${ran}, ${keeps}`
+}
+
+/** a line's text as a reader sees it now, its stamp rendered */
+export const lineText = (l: Line, now: number = Date.now()): string => (l.stamp == null ? l.text : `${l.text} (${stampWords(l.stamp, now)})`)
 
 const green = (s: string): string => `\x1b[32m${s}\x1b[0m`
 const red = (s: string): string => `\x1b[31m${s}\x1b[0m`
 const yellow = (s: string): string => `\x1b[33m${s}\x1b[0m`
 
-export function formatLine(l: Line, color: boolean): string {
+export function formatLine(l: Line, color: boolean, now: number = Date.now()): string {
     const c = (f: (s: string) => string, s: string) => (color ? f(s) : s)
+    const text = lineText(l, now)
     switch (l.kind) {
-        case 'ok': return `${c(green, 'ok:')} ${l.text}`
-        case 'warn': return c(yellow, `WARN ${l.text}`)
-        case 'fail': return c(red, `FAIL: ${l.text}`)
-        case 'fix-warn': return `      ${c(yellow, `fix: ${l.text}`)}`
-        case 'fix-fail': return `      ${c(red, `fix: ${l.text}`)}`
-        case 'skip': return `skip: ${l.text}`
-        case 'note': return l.text
+        case 'ok': return `${c(green, 'ok:')} ${text}`
+        case 'warn': return c(yellow, `WARN ${text}`)
+        case 'fail': return c(red, `FAIL: ${text}`)
+        case 'fix-warn': return `      ${c(yellow, `fix: ${text}`)}`
+        case 'fix-fail': return `      ${c(red, `fix: ${text}`)}`
+        case 'skip': return `skip: ${text}`
+        case 'note': return text
     }
 }
 
@@ -49,6 +78,17 @@ export function parseDuration(d: string | number): number {
     return Number(m[1]) * { ms: 1, s: 1000, m: 60_000, h: 3600_000, d: 86400_000 }[m[2] as 'ms' | 's' | 'm' | 'h' | 'd']
 }
 
+/** `ttl: 'forever'`: a DECIDED fact (a repo's visibility, an account that
+ *  exists). It moves only when someone decides to move it, and that decision
+ *  is the declared value in its key, so a clean answer never expires */
+export const FOREVER = 'forever'
+
+/** what a forever answer keeps for: no clock ends it, no sweep drops it */
+export const FOREVER_MS = Number.MAX_SAFE_INTEGER
+
+/** how long a clean answer keeps, from a declared ttl. 0 = none declared */
+export const ttlMsOf = (ttl: string | undefined): number => (ttl == null || ttl === '' ? 0 : ttl === FOREVER ? FOREVER_MS : parseDuration(ttl))
+
 /** absolute local stamp (2026-08-05 09:12:34), never a relative age: a
  *  relative render changes every run and turns committed STATUS.md
  *  checkpoints into noise diffs */

package/src/fleet/scan-fleet.ts

@@ -12,6 +12,7 @@
 // `shipkit check`, so the fix travels through that one code path.
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
 import { join } from 'path'
+import { isArchived } from '../core/archived.ts'
 import { detectPackageManager, isRefusal } from '../core/package-manager.ts'
 import { isBreaking } from '../core/update-policy.ts'
 
@@ -84,7 +85,7 @@ export function scanFleet(root: string, o: { prefix?: string } = {}): FleetRepo[
             continue
         }
         const pkg = readPkg(dir)
-        if (pkg == null) continue
+        if (pkg == null || isArchived(dir)) continue
         const all = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) }
         const names = Object.keys(all).filter((n) => n.startsWith(prefix))
         if (names.length === 0) continue

package/src/home/activity-shape.ts

@@ -0,0 +1,138 @@
+// the activity page's shapes and its few pure rules, apart from the git
+// reader so the page bundle takes them without node's modules. The words
+// here are what the page and `shipkit cross-repo-activity` both print.
+import type { CheckState } from '../serve/project-gutter.ts'
+
+/** the windows the page offers, in minutes */
+export const WINDOW_MINUTES = [10, 30, 60, 180, 720, 1440, 4320, 10080] as const
+export const DEFAULT_MINUTES = 30
+/** the most commits the daemon lists per repo, and the most uncommitted paths it names */
+export const MAX_COMMITS = 100
+export const MAX_FILES = 80
+
+export type FileKind = 'staged' | 'modified' | 'untracked'
+
+export type ActivityCommit = {
+    sha: string
+    /** committer time, epoch ms */
+    at: number
+    title: string
+    author: string
+    /** the branch it sits on when it is not on the checked out one, else null */
+    branch: string | null
+    /** a remote holds it; false on a branch with no upstream */
+    pushed: boolean
+}
+
+export type ActivityRow = {
+    name: string
+    /** the checked out branch; null when detached (see `detached`) */
+    branch: string | null
+    /** the short sha HEAD sits on when detached */
+    detached: string | null
+    /** the upstream as configured, null when the branch has none */
+    upstream: string | null
+    /** the upstream is configured but no longer exists */
+    gone: boolean
+    /** commits ahead of and behind the upstream, null without one */
+    ahead: number | null
+    behind: number | null
+    counts: Record<FileKind, number>
+    /** the uncommitted paths, at most MAX_FILES; a path both staged and
+     *  modified is listed once, as modified */
+    files: { kind: FileKind; path: string }[]
+    /** in the window, newest first */
+    commits: ActivityCommit[]
+    /** HEAD's latest commit when nothing was committed in the window, shown
+     *  grey; null when the window holds a commit, or the repo has none */
+    last: ActivityCommit | null
+    /** its checks as its run record last saw them, only the ids it declares
+     *  today when that is known; null when shipkit never ran there */
+    status: CheckState
+    /** the checks behind a red or orange status, failing first: what the
+     *  status column lists on hover and on click */
+    failing?: StatusCheck[]
+    /** why git could not answer, else null */
+    error: string | null
+}
+
+/** one failing or warning check as the run record last saw it */
+export type StatusCheck = {
+    id: string
+    /** its title as the repo declares it, else its id */
+    title: string
+    status: 'fail' | 'warn'
+    /** when that outcome was recorded, epoch ms */
+    at: number | null
+    /** the worst line it printed about the problem, '' when it printed none */
+    line: string
+    /** every fail and warn line it printed, the worst weight first: a check
+     *  reporting three findings lists three */
+    lines: string[]
+}
+
+export type ActivityAnswer = { now: number; minutes: number; rows: ActivityRow[]; ms: number }
+
+export type ActivityRepo = { name: string; path: string }
+
+/** the window a request names, when it is one the page offers */
+export function windowMinutes(v: string | null): number {
+    const n = Number(v)
+    return (WINDOW_MINUTES as readonly number[]).includes(n) ? n : DEFAULT_MINUTES
+}
+
+/** every house repo ships from main: shown green, any other orange, a
+ *  leftover master included so the repo still to rename stands out */
+export const isMainBranch = (b: string | null): boolean => b === 'main'
+
+/** nothing committed in the window and nothing uncommitted: it sits below the busy repos */
+export const idleRow = (r: ActivityRow): boolean =>
+    r.error == null && r.commits.length === 0 && r.counts.staged + r.counts.modified + r.counts.untracked === 0
+
+/** the most commits a repo shows: a number from CAP_MIN to CAP_MAX */
+export const CAP_MIN = 1
+export const CAP_MAX = 15
+export const DEFAULT_CAP = 3
+
+/** a window's label on the toggle: `10m`, `3h`, `3d` */
+export const windowWords = (m: number): string => (m < 60 ? `${m}m` : m < 4320 ? `${m / 60}h` : `${m / 1440}d`)
+
+/** a typed cap, as a whole number in CAP_MIN..CAP_MAX; the default when it is no number */
+export function clampCap(v: unknown): number {
+    const n = Math.round(Number(v))
+    return Number.isFinite(n) && String(v).trim() !== '' ? Math.min(CAP_MAX, Math.max(CAP_MIN, n)) : DEFAULT_CAP
+}
+
+/** an age in one short unit: `now`, `4m`, `2h`, `3d` */
+export function ageShort(at: number, now: number): string {
+    const s = Math.max(0, Math.round((now - at) / 1000))
+    if (s < 60) return 'now'
+    if (s < 3600) return `${Math.floor(s / 60)}m`
+    if (s < 86400) return `${Math.floor(s / 3600)}h`
+    return `${Math.floor(s / 86400)}d`
+}
+
+/** the uncommitted work in one line: `3 modified, 1 untracked`; '' when clean */
+export function dirtWords(r: ActivityRow): string {
+    const c = r.counts
+    return [c.staged > 0 ? `${c.staged} staged` : '', c.modified > 0 ? `${c.modified} modified` : '', c.untracked > 0 ? `${c.untracked} untracked` : '']
+        .filter((x) => x !== '')
+        .join(', ')
+}
+
+/** where the branch stands against its upstream, for the branch's hover */
+export function upstreamWords(r: ActivityRow): string {
+    if (r.upstream == null) return 'no upstream: nothing on this branch is pushed'
+    if (r.gone) return `${r.upstream} is gone`
+    const a = r.ahead ?? 0
+    const b = r.behind ?? 0
+    if (a === 0 && b === 0) return `even with ${r.upstream}`
+    return [a > 0 ? `${a} unpushed` : '', b > 0 ? `${b} behind` : ''].filter((x) => x !== '').join(', ') + ` against ${r.upstream}`
+}
+
+/** the uncommitted paths, one per line, for the hover */
+export const filesWords = (r: ActivityRow): string => {
+    const mark = { staged: 'S', modified: 'M', untracked: '?' } as const
+    const shown = r.files.map((f) => `${mark[f.kind]} ${f.path}`)
+    return (r.files.length >= MAX_FILES ? [...shown, '…'] : shown).join('\n')
+}

package/src/home/activity.ts

@@ -0,0 +1,256 @@
+// the activity page's data: for every house repo, its branch, how far it is
+// from its upstream, what it holds uncommitted and what it committed in a
+// window. Plain local git, never a fetch, so "ahead" is against the upstream
+// as this disk last saw it.
+//
+// the one constraint a reader breaks first: this runs only when the page asks
+// (no tick). A pass reads ACTIVITY_CONCURRENCY repos at once, and an answer is
+// shared for ACTIVITY_TTL_MS per window, never served past it, so a page left
+// open costs about one pass a minute however many tabs show it, and a closed
+// one costs nothing.
+import { gitBin } from '../core/git-bin.ts'
+import { readLastStatusReadonly } from '../ledger/run-log.ts'
+import { checkStateOf, recordOf } from '../serve/project-gutter.ts'
+import { lineText, type Line } from '../core/wire.ts'
+import { MAX_COMMITS, MAX_FILES, type ActivityAnswer, type ActivityCommit, type ActivityRepo, type ActivityRow, type FileKind, type StatusCheck } from './activity-shape.ts'
+
+export * from './activity-shape.ts'
+
+/** how long one window's answer is shared between readers: half the page's
+ *  60s cadence, so tabs a few seconds apart share a pass and none is shown
+ *  an answer older than this */
+export const ACTIVITY_TTL_MS = 30_000
+
+export type ParsedStatus = Pick<ActivityRow, 'branch' | 'detached' | 'upstream' | 'gone' | 'ahead' | 'behind' | 'counts' | 'files'>
+
+/** `git status --porcelain=v2 --branch`, read */
+export function parseStatus(text: string): ParsedStatus {
+    const out: ParsedStatus = { branch: null, detached: null, upstream: null, gone: false, ahead: null, behind: null, counts: { staged: 0, modified: 0, untracked: 0 }, files: [] }
+    let oid = ''
+    const add = (kind: FileKind, path: string): void => {
+        if (out.files.length < MAX_FILES) out.files.push({ kind, path })
+    }
+    for (const line of text.split('\n')) {
+        if (line.startsWith('# branch.oid ')) oid = line.slice(13)
+        else if (line.startsWith('# branch.head ')) {
+            const h = line.slice(14)
+            if (h !== '(detached)') out.branch = h
+        } else if (line.startsWith('# branch.upstream ')) out.upstream = line.slice(18)
+        else if (line.startsWith('# branch.ab ')) {
+            const m = /^\+(\d+) -(\d+)$/.exec(line.slice(12))
+            if (m != null) {
+                out.ahead = Number(m[1])
+                out.behind = Number(m[2])
+            }
+        } else if (line.startsWith('1 ') || line.startsWith('2 ')) {
+            // `1 XY sub mH mI mW hH hI path`, `2 … Xscore path<TAB>orig`
+            const f = line.split(' ')
+            const xy = f[1] ?? '..'
+            const path = f.slice(line.startsWith('1 ') ? 8 : 9).join(' ').split('\t')[0]!
+            if (xy[0] !== '.') out.counts.staged++
+            if (xy[1] !== '.') out.counts.modified++
+            add(xy[1] !== '.' ? 'modified' : 'staged', path)
+        } else if (line.startsWith('u ')) {
+            out.counts.modified++
+            add('modified', line.split(' ').slice(10).join(' '))
+        } else if (line.startsWith('? ')) {
+            out.counts.untracked++
+            add('untracked', line.slice(2))
+        }
+    }
+    if (out.branch == null && oid !== '' && oid !== '(initial)') out.detached = oid.slice(0, 7)
+    if (out.upstream != null && out.ahead == null) out.gone = true
+    return out
+}
+
+const SEP = '\x1f'
+const END = '\x1e'
+const FORMAT = `--format=%h${SEP}%ct${SEP}%an${SEP}%S${SEP}%s${SEP}%H${END}`
+
+/** `git log` in FORMAT, read; `unpushed` holds the full shas no remote has */
+export function parseLog(text: string, onHead: boolean, unpushed: (full: string) => boolean = () => false): ActivityCommit[] {
+    const out: ActivityCommit[] = []
+    for (const rec of text.split(END)) {
+        const f = rec.replace(/^\n/, '').split(SEP)
+        if (f.length < 6) continue
+        const src = f[3]!.replace(/^refs\/heads\//, '')
+        out.push({ sha: f[0]!, at: Number(f[1]) * 1000, author: f[2]!, branch: onHead || src === '' ? null : src, title: f[4]!, pushed: !unpushed(f[5]!) })
+    }
+    return out
+}
+
+async function git(cwd: string, args: string[]): Promise<{ code: number; out: string; err: string }> {
+    // no optional locks: a look never takes the index lock an agent's commit needs
+    const p = Bun.spawn([gitBin(), ...args], { cwd, stdout: 'pipe', stderr: 'pipe', env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' } })
+    const [out, err, code] = await Promise.all([new Response(p.stdout).text(), new Response(p.stderr).text(), p.exited])
+    return { code, out, err: err.trim() }
+}
+
+/** which check ids a repo declares today: the daemon's plan; null = not
+ *  known, every recorded check counts */
+export type Declared = (name: string) => ReadonlySet<string> | null
+
+/** each declared check's title by id; null = not known, the id stands in */
+export type Titles = (name: string) => ReadonlyMap<string, string> | null
+
+/** every line a check printed about its problems: its fail and warn lines,
+ *  those of its own weight first (a fail for a failure, a warning for a
+ *  warning), else its first line that is not a pass, each without the id it
+ *  leads with */
+export function findingsOf(lines: string, status: 'fail' | 'warn', id: string): string[] {
+    let parsed: Line[]
+    try {
+        parsed = JSON.parse(lines) as Line[]
+    } catch {
+        return []
+    }
+    if (!Array.isArray(parsed)) return []
+    const of = (k: Line['kind']): Line[] => parsed.filter((l) => l.kind === k)
+    let hits = status === 'fail' ? [...of('fail'), ...of('warn')] : [...of('warn'), ...of('fail')]
+    if (hits.length === 0) hits = parsed.filter((l) => l.kind !== 'ok' && l.kind !== 'skip').slice(0, 1)
+    return hits.map((l) => {
+        const t = lineText(l).trim()
+        // `[ID] text`, and a runner line's `ID — text`: the list names the id already
+        for (const lead of [`[${id}]`, `${id} —`]) if (t.startsWith(lead)) return t.slice(lead.length).trim()
+        return t
+    })
+}
+
+/** the worst of them, '' when it printed none */
+export const findingOf = (lines: string, status: 'fail' | 'warn', id: string): string => findingsOf(lines, status, id)[0] ?? ''
+
+/** a repo's checks as its run record last saw them, counted over what it
+ *  declares, and the failing and warning ones with what each said */
+export function statusOf(repo: ActivityRepo, declared: Declared | null = null, titles: Titles | null = null): Pick<ActivityRow, 'status' | 'failing'> {
+    const record = recordOf(repo.path)
+    if (record == null) return { status: null, failing: [] }
+    const rows = readLastStatusReadonly(record, { lines: true })
+    const status = checkStateOf(rows, declared?.(repo.name) ?? null)
+    if (status == null) return { status, failing: [] }
+    const byId = new Map(rows.map((r) => [r.id, r]))
+    const named = titles?.(repo.name) ?? null
+    const one = (id: string, st: 'fail' | 'warn'): StatusCheck => {
+        const r = byId.get(id)
+        const lines = r == null ? [] : findingsOf(r.lines, st, id)
+        return { id, title: named?.get(id) ?? id, status: st, at: status.since[id] ?? null, line: lines[0] ?? '', lines }
+    }
+    return { status, failing: [...status.reds.map((id) => one(id, 'fail')), ...status.warns.map((id) => one(id, 'warn'))] }
+}
+
+/** one repo, from `since` (epoch ms) to now */
+export async function repoActivity(repo: ActivityRepo, since: number, declared: Declared | null = null, titles: Titles | null = null): Promise<ActivityRow> {
+    const empty = parseStatus('')
+    const row: ActivityRow = { name: repo.name, ...empty, commits: [], last: null, ...statusOf(repo, declared, titles), error: null }
+    try {
+        const iso = new Date(since).toISOString()
+        const range = [`--since=${iso}`, `--max-count=${MAX_COMMITS}`, '--no-show-signature', FORMAT]
+        // every ask that needs no other answer goes at once: git calls are
+        // ~5ms each but queue behind a busy daemon, so waiting for them one
+        // by one multiplies the wait. The upstream diff and the last commit
+        // are cheap enough to ask even when the answer goes unused
+        const [st, up, head, refs, one] = await Promise.all([
+            git(repo.path, ['status', '--porcelain=v2', '--branch']),
+            git(repo.path, ['rev-list', `--max-count=${MAX_COMMITS}`, '@{upstream}..HEAD']),
+            // a repo with no commit yet has no HEAD to walk: nothing committed
+            git(repo.path, ['log', ...range, 'HEAD']),
+            // the other local branches (an agent's worktree) whose tip moved in
+            // the window, minus what HEAD has: a repo with hundreds of branches
+            // walks only the few that moved
+            git(repo.path, ['for-each-ref', '--format=%(refname:short)%09%(committerdate:unix)%09%(upstream:short)%09%(upstream:track)', 'refs/heads']),
+            git(repo.path, ['log', '-1', '--no-show-signature', FORMAT, 'HEAD']),
+        ])
+        if (st.code !== 0) return { ...row, error: st.err || `git status exited ${st.code}` }
+        Object.assign(row, parseStatus(st.out))
+        // HEAD's unpushed commits: all of them without an upstream, else the
+        // `ahead` ones
+        const headAway = row.upstream == null || row.gone
+        const away = !headAway && (row.ahead ?? 0) > 0 && up.code === 0 ? new Set(up.out.split('\n').filter((l) => l !== '')) : new Set<string>()
+        const own = head.code === 0 ? parseLog(head.out, true, (h) => headAway || away.has(h)) : []
+        const moved = (refs.code === 0 ? refs.out.split('\n') : [])
+            .map((l) => l.split('\t'))
+            .filter((f) => f.length >= 2 && f[0] !== row.branch && Number(f[1]) * 1000 >= since)
+            // an upstream that is gone holds nothing
+            .map((f) => (f[3] === '[gone]' ? [f[0]!, f[1]!, ''] : f))
+        let other: ActivityCommit[] = []
+        if (moved.length > 0) {
+            const side = await git(repo.path, ['log', ...range, '--source', ...moved.map((f) => `refs/heads/${f[0]}`), '--not', 'HEAD', '--'])
+            // a side branch's commit is pushed once its own upstream holds it;
+            // on a failed ask every one reads unpushed, never pushed
+            const tracked = moved.filter((f) => (f[2] ?? '') !== '')
+            let sideAway = new Set<string>()
+            if (tracked.length > 0) {
+                const r = await git(repo.path, ['rev-list', `--since=${iso}`, ...tracked.map((f) => `refs/heads/${f[0]}`), '--not', ...tracked.map((f) => f[2]!), '--'])
+                if (r.code === 0) sideAway = new Set(r.out.split('\n').filter((l) => l !== ''))
+                else sideAway = new Set(['*'])
+            }
+            const untracked = new Set(moved.filter((f) => (f[2] ?? '') === '').map((f) => f[0]!))
+            other = side.code === 0 ? parseLog(side.out, false, (h) => sideAway.has('*') || sideAway.has(h)).map((c) => (c.branch != null && untracked.has(c.branch) ? { ...c, pushed: false } : c)) : []
+        }
+        row.commits = [...own, ...other].sort((a, b) => b.at - a.at).slice(0, MAX_COMMITS)
+        // an empty window still says what came last on HEAD
+        if (row.commits.length === 0) {
+            row.last = one.code === 0 ? parseLog(one.out, true, (h) => headAway || away.has(h))[0] ?? null : null
+        }
+        return row
+    } catch (e) {
+        return { ...row, error: (e as Error).message }
+    }
+}
+
+/** how many repos a pass reads at once: five git calls each, so a pass
+ *  never has more than 30 git processes alive */
+export const ACTIVITY_CONCURRENCY = 6
+
+/** every repo, ACTIVITY_CONCURRENCY at a time, rows in the order given.
+ *  THE computation: the daemon's route and `shipkit cross-repo-activity`
+ *  both call it, and only render it differently */
+export async function activityOf(repos: ActivityRepo[], minutes: number, now = Date.now(), declared: Declared | null = null, titles: Titles | null = null): Promise<ActivityAnswer> {
+    const t0 = performance.now()
+    const rows: ActivityRow[] = new Array(repos.length)
+    let next = 0
+    const worker = async (): Promise<void> => {
+        while (next < repos.length) {
+            const i = next++
+            rows[i] = await repoActivity(repos[i]!, now - minutes * 60_000, declared, titles)
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(ACTIVITY_CONCURRENCY, repos.length) }, worker))
+    return { now, minutes, rows, ms: Math.round(performance.now() - t0) }
+}
+
+/** one answer per window, shared for ttlMs. Past it a read waits for a new
+ *  pass: an old answer is never served as current. Callers during a pass
+ *  share it. */
+export class ActivityCache {
+    private kept = new Map<number, ActivityAnswer>()
+    private running = new Map<number, Promise<ActivityAnswer>>()
+    private ttlMs: number
+    private now: () => number
+    private declared: Declared | null
+    private titles: Titles | null
+
+    constructor(o: { ttlMs?: number; now?: () => number; declared?: Declared; titles?: Titles } = {}) {
+        this.ttlMs = o.ttlMs ?? ACTIVITY_TTL_MS
+        this.now = o.now ?? Date.now
+        this.declared = o.declared ?? null
+        this.titles = o.titles ?? null
+    }
+
+    private pass(repos: ActivityRepo[], minutes: number): Promise<ActivityAnswer> {
+        const going = this.running.get(minutes)
+        if (going != null) return going
+        const p = activityOf(repos, minutes, this.now(), this.declared, this.titles)
+            .then((a) => { this.kept.set(minutes, a); return a })
+            .finally(() => this.running.delete(minutes))
+        this.running.set(minutes, p)
+        return p
+    }
+
+    /** the kept answer while it is younger than the ttl, else a new pass.
+     *  `fresh` always waits for a pass: the page's refresh button */
+    get(repos: ActivityRepo[], minutes: number, o: { fresh?: boolean } = {}): Promise<ActivityAnswer> {
+        const k = this.kept.get(minutes)
+        if (k == null || o.fresh === true || this.now() - k.now >= this.ttlMs) return this.pass(repos, minutes)
+        return Promise.resolve(k)
+    }
+}

package/src/home/global-units.ts

@@ -21,7 +21,8 @@ export type GlobalProcessDecl = {
     cwd: string
     url: string | null
     probe: string | null
-    app: boolean
+    /** as declared: an emoji, or an image path relative to root */
+    icon: string | null
     actions: ActionDecl[]
     /** the repo that declares it, and the file, repo-relative */
     repo: string
@@ -51,7 +52,7 @@ export function toDecl(u: GlobalProcessUnit, repo: RepoRef, file: string): Globa
         cwd: resolve(repo.path, u.cwd ?? '.'),
         url: u.url ?? null,
         probe: u.probe ?? u.url ?? null,
-        app: u.app === true,
+        icon: u.icon ?? null,
         actions: Object.entries(u.actions ?? {}).map(([id, a]) => ({ id, label: a.label, cmd: a.cmd ?? null })),
         repo: repo.name,
         root: repo.path,