rvlib-shipkit 1.1.1 → 1.3.0

package/src/core/run-ci.ts

@@ -12,6 +12,7 @@ import { passScope, runCheckPass, type CheckOpts } from './run-check.ts'
 import { poolLines } from './slots.ts'
 import { runFixPass } from './run-fixers.ts'
 import { formatLine } from './wire.ts'
+import { outcomeCounts } from './outcome-words.ts'
 import { writeStatus } from './write-status.ts'
 import { allTasks, composeChecks, envTier, FULL_TESTS_ENV, type TestTier } from '../ledger/gate-checks.ts'
 import { CHECK_TABLE_FILE, writeCheckTable } from '../ledger/check-table.ts'
@@ -53,6 +54,8 @@ export type CiOpts = {
      *  own panel, and running them twice per refresh proves the same thing
      *  twice. */
     buildOnly?: boolean
+    /** colour the wire lines (run-check.ts CheckOpts.color) */
+    color?: boolean
     /** line sink — commands pass their context stream; defaults to console */
     print?: (line: string) => void
     /** per-CHECK completion tap, handed straight to the runner. The hub passes
@@ -83,6 +86,10 @@ export type CiOpts = {
     tests?: TestTier
     /** who started this run, as the run record files it */
     invokedBy?: InvokedBy
+    /** print every line, the ones nobody acts on included: the clean fix
+     *  pass, the pool, the tier, the cache declarations, the parked checks,
+     *  the cache counts. STATUS.md always holds them all */
+    verbose?: boolean
 }
 
 export type { TestTier } from '../ledger/gate-checks.ts'
@@ -105,10 +112,26 @@ function ciScope(o: CiOpts): { command: string; fullGate: boolean } {
     return { command: parts.length === 0 ? 'shipkit ci' : `shipkit ci ${parts.join(' ')}`, fullGate: narrowing.length === 0 }
 }
 
+/** `ok: 12 checks green`, or which ones warned. A whole gate adds its tier
+ *  and where its answers came from */
+export function verdictLine(results: CheckResult[], whole: { tier: TestTier; cache: { hit: number; miss: number; attached: number; uncacheable: number } | null } | null): string | null {
+    const ran = results.filter((r) => r.status !== 'skip').length
+    if (ran === 0) return null
+    const warned = results.filter((r) => r.status === 'warn' || (r.status === 'fail' && r.advisory)).map((r) => r.id)
+    const head = warned.length === 0 ? `${ran} check${ran === 1 ? '' : 's'} green` : `${ran} check${ran === 1 ? '' : 's'} passed, ${warned.length} with a warning: ${warned.join(', ')}`
+    if (whole == null) return `ok: ${head}`
+    const c = whole.cache
+    const cache = c == null ? '' : `; ${outcomeCounts({ cached: c.hit, ran: c.miss, attached: c.attached, neverCached: c.uncacheable })}`
+    return `ok: ${head}; ${whole.tier} tier${cache}`
+}
+
 export async function runCi(root: string, o: CiOpts = {}): Promise<number> {
     const print = o.print ?? ((l: string) => console.log(l))
     const collected: string[] = []
     const sink = (l: string): void => { collected.push(l); print(l) }
+    // what the reader never acts on: kept for STATUS.md and --verbose, never
+    // printed on a default run, where every line costs a reader tokens
+    const detail = (l: string): void => { collected.push(l); if (o.verbose === true) print(l) }
     let c = o.config ?? (await loadRepoConfig(root))
     // mechanical failures are not information, so they never cost a round trip
     let fixFailed = false
@@ -121,7 +144,7 @@ export async function runCi(root: string, o: CiOpts = {}): Promise<number> {
     // back as a test failure.
     const narrowed = (o.onlyIds ?? []).length > 0
     if (o.fix !== false) {
-        const pass = await runFixPass(root, c, { rules: !narrowed && o.fixRules !== false, armHooks: !narrowed && o.armHooks === true, print: sink })
+        const pass = await runFixPass(root, c, { rules: !narrowed && o.fixRules !== false, armHooks: !narrowed && o.armHooks === true, print: sink, detail })
         fixFailed = pass.failed
         // a fixer that rewrote the config or moved a check file leaves the
         // config above describing a repo that is gone, so the gate reads the
@@ -132,20 +155,22 @@ export async function runCi(root: string, o: CiOpts = {}): Promise<number> {
                 return 1
             }
         }
-    } else sink('skip: fix pass (--no-fix)')
+    } else detail('skip: fix pass (--no-fix)')
     const tier: TestTier = o.tests ?? envTier()
-    // announced BEFORE the run, so a log that died mid-way still says which
-    // tier it was asking for
-    sink(tier === 'full'
+    // announced BEFORE the run (under --verbose, and in every release log),
+    // so a log that died mid-way still says which tier it was asking for
+    detail(tier === 'full'
         ? `ok: test tier FULL — every suite, the slow ones included (${FULL_TESTS_ENV}=1)`
         : `skip: full test tier (quick run — \`shipkit ci --full\` or ${FULL_TESTS_ENV}=1 includes it)`)
-    for (const l of poolLines()) sink(l)
+    for (const l of poolLines()) (l.startsWith('WARN') ? sink : detail)(l)
     // a floor slot nothing could fill is VISIBLE — a thin gate must never look
     // like a full one (the fresh-repo floor gap)
     const floor = await allTasks(c, root)
-    for (const n of floor.notes ?? []) sink(n)
+    // a narrowed run says nothing about the slots it never asked about
+    const asked = (id: string): boolean => !narrowed || (o.onlyIds ?? []).includes(id)
+    for (const n of floor.notes ?? []) (narrowed ? detail : sink)(n)
     for (const u of floor.unfilled) {
-        sink(`skip: ${u.id} (${u.reason})`)
+        (asked(u.id) ? sink : detail)(`skip: ${u.id} (${u.reason})`)
         // asked for BY NAME and unfillable: this is where an agent lands after
         // the harness refused it the raw runner, so the line says what to add
         // rather than leaving it with `unknown check id` and no next move
@@ -187,6 +212,7 @@ export async function runCi(root: string, o: CiOpts = {}): Promise<number> {
         buildOnly: o.buildOnly,
         bail: o.bail,
         fresh: o.fresh,
+        color: o.color,
         tier,
     }
     try {
@@ -207,7 +233,7 @@ export async function runCi(root: string, o: CiOpts = {}): Promise<number> {
         // visible as a shrinking undeclared one.
         const decided = reg.checks - reg.burnDown.length - reg.declared
         if (reg.burnDown.length > 0 || decided > 0)
-            sink(`skip: cache declarations — ${reg.declared}/${reg.checks} declared, ${decided} never cached on purpose, ${reg.burnDown.length} undeclared, so those run every time (shipkit keys --burn-down)`)
+            detail(`skip: cache declarations — ${reg.declared}/${reg.checks} declared, ${decided} never cached on purpose, ${reg.burnDown.length} undeclared, so those run every time (shipkit keys --burn-down)`)
         if (ledger.layer.failure != null)
             sink(`WARN the git scan failed, so NOTHING comes from the cache and nothing is stored this run — ${ledger.layer.failure}`)
     } catch (e) {
@@ -222,13 +248,14 @@ export async function runCi(root: string, o: CiOpts = {}): Promise<number> {
         onCheck: o.onCheck,
         reportHome: false,
         print: sink,
+        detail,
     })
     // what the suite ACTUALLY ran, from its own headline. A flag that was set
     // proves the intent; the count proves the tests
     // proves the intent; the count proves the tests. Every test check counts,
     // one per unit
     const counts = run.results.map((r) => /Ran (\d+) tests?/.exec(r.lastLine)?.[1]).filter((n) => n != null).map(Number)
-    if (counts.length > 0) sink(`ok: test tier ${tier}: ${counts.reduce((a, b) => a + b, 0)} tests ran${counts.length > 1 ? ` in ${counts.length} test checks` : ''}`)
+    if (counts.length > 0) detail(`ok: test tier ${tier}: ${counts.reduce((a, b) => a + b, 0)} tests ran${counts.length > 1 ? ` in ${counts.length} test checks` : ''}`)
     for (const u of run.undeclared) {
         sink(`FAIL: ${u} does not declare whether it blocks`)
         sink(`      fix: add \`blocking: true\` (about this repo) or \`false\` (about the world) to that check`)
@@ -245,16 +272,23 @@ export async function runCi(root: string, o: CiOpts = {}): Promise<number> {
             advisoryFatal = true
             sink(`FAIL: ${run.advisoryFailures.length} non-blocking check(s) failing and release.requireHealthy is on: ${run.advisoryFailures.join(', ')}`)
             sink('      fix: shipkit check')
-        } else sink(`WARN ${run.advisoryFailures.length} non-blocking check(s) failing, about the world rather than this repo: ${run.advisoryFailures.join(', ')}`)
+        } else detail(`WARN ${run.advisoryFailures.length} non-blocking check(s) failing, about the world rather than this repo: ${run.advisoryFailures.join(', ')}`)
     }
     // the post-run re-hash, then the store. NOTHING was written while the gate
     // ran: a check whose inputs moved under it answered about a tree that no
     // longer exists, and this is where that result is thrown away instead of
     // stored under a key that describes the file as it was before the edit.
-    if (ledger != null) for (const l of ledger.header(ledger.commit())) sink(formatLine(l, false))
+    // the counts line folds into the verdict; what else it says (a store
+    // that failed, answers thrown away) is printed as it is
+    if (ledger != null) for (const [i, l] of ledger.header(ledger.commit()).entries()) (i === 0 ? detail : sink)(formatLine(l, false))
     // one write for the whole gate, after everything has finished
     for (const l of runLog.flush()) sink(formatLine(l, false))
     const code = run.blocked || fixFailed || registrationFailed || advisoryFatal || run.undeclared.length > 0 || run.unknownWhen.length > 0 || run.unknownBudgets.length > 0 ? 1 : 0
+    // THE VERDICT, one line and only on a pass: a red run already said so in
+    // its FAIL lines. The whole gate adds the tier and the cache counts, which
+    // a narrowed run asked no question about
+    const verdict = code === 0 && !run.interrupted ? verdictLine(run.results, scope.fullGate ? { tier, cache: ledger?.counts ?? null } : null) : null
+    if (verdict != null) sink(verdict)
     // motherhome row (docsBase wiki on this disk) — never affects the gate,
     // and never fires under frozen: a bump/release gate must not re-dirty the
     // tree it just proved clean

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/slots.ts

@@ -30,6 +30,11 @@ export const poolDir = (): string => {
     return env != null && env !== '' ? env : join(homedir(), '.cache', 'shipkit', 'slots')
 }
 
+/** the TURN the background gates take, one at a time on the whole machine:
+ *  every batch the plan runs, for every repo. A gate someone asked for
+ *  (a terminal, a button) never takes it, so it never waits behind one */
+export const autoGatePool = (): SlotPool => ({ dir: `${poolDir()}-auto-gate`, size: 1 })
+
 /** this process's pool, or null when it runs inside a check that holds one */
 export function machinePool(): SlotPool | null {
     return process.env[SLOT_HELD_ENV] === '1' ? null : { dir: poolDir(), size: parallelCap() }

package/src/core/statement-end.ts

@@ -0,0 +1,17 @@
+// where a statement of a config file ends, read as text. Pure, so the page
+// can import it too.
+
+/** a statement that starts on `i`, ending where its brackets balance and the
+ *  line is not obviously continued. Deliberately simple: anything it cannot
+ *  read lands as a hand pass rather than as a half rewritten config. */
+export function statementEnd(lines: string[], i: number): number {
+    let depth = 0
+    for (let j = i; j < lines.length; j++) {
+        for (const ch of lines[j]!) {
+            if (ch === '(' || ch === '[' || ch === '{') depth++
+            else if (ch === ')' || ch === ']' || ch === '}') depth--
+        }
+        if (depth <= 0) return j
+    }
+    return lines.length - 1
+}

package/src/core/wire.ts

@@ -49,6 +49,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,135 @@
+// 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 first line it printed about the problem, '' when it printed none */
+    line: 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')
+}