rvlib-shipkit 1.2.0 → 1.3.0

package/src/cli/cmd_Keys.ts

@@ -8,7 +8,8 @@
 import { createHash } from 'crypto'
 import { Command, Option } from 'clipanion'
 import { loadRepoConfig } from '../repo-config.ts'
-import { envTier, FULL_TESTS_ENV, gateChecks } from '../ledger/gate-checks.ts'
+import { envTier, FULL_TESTS_ENV, gateInventory } from '../ledger/gate-checks.ts'
+import { planGap, plannable } from '../plan/repo-source.ts'
 import { KeyLayer } from '../ledger/git-key.ts'
 import { Ledger } from '../ledger/ledger.ts'
 import { gateBinary } from '../ledger/toolchain-identity.ts'
@@ -42,14 +43,22 @@ export class KeysCommand extends Command {
         // every task's env, which is in the key, so a surface that renders keys
         // without it renders a tier nobody asked for
         const tier = this.full ? 'full' : envTier()
-        const decls = await gateChecks(root, c, { tier })
+        const rows = await gateInventory(root, c, { tier })
+        const decls = rows.map((r) => r.decl)
+        // the plan's side of the burn-down: a check nothing keys and that
+        // declares no cadence is re-asked on a guess. A built-in there is a
+        // toolkit bug, a repo check rides the default range until it declares
+        const planGaps = rows.filter(plannable).flatMap((r) => {
+            const gap = planGap(r)
+            return gap == null ? [] : [{ id: r.decl.id, from: r.from, gap }]
+        })
         const layer = KeyLayer.open(root, decls, { cliEntry: gateBinary() })
         const keys = layer.keys()
         const out = (l: string): void => { this.context.stdout.write(`${l}\n`) }
 
         if (this.json) {
             const drift = this.rescan ? layer.rescan() : null
-            out(JSON.stringify({ tier, checks: keys, burnDown: layer.registration.burnDown, errors: layer.registration.errors, layerMs: Math.round(layer.openMs), scanMs: Math.round(layer.scanMs), failure: layer.failure, drift }))
+            out(JSON.stringify({ tier, checks: keys, burnDown: layer.registration.burnDown, planGaps, errors: layer.registration.errors, layerMs: Math.round(layer.openMs), scanMs: Math.round(layer.scanMs), failure: layer.failure, drift }))
             return layer.registration.errors.length > 0 || layer.failure != null ? 1 : 0
         }
 
@@ -115,6 +124,11 @@ export class KeysCommand extends Command {
         const decided = new Set(layer.decls.filter((d) => d.never != null && d.never !== '').map((d) => d.id))
         const shown = this.burnDown ? keys.filter((k) => k.population === 'none' && !decided.has(k.id)) : keys
         for (const k of shown) out(`${k.population.padEnd(7)} ${k.id.padEnd(28)} ${k.key ?? `— ${k.reason ?? ''}`}`)
+        if (planGaps.length > 0) out('')
+        for (const g of planGaps)
+            out(g.from === 'repo'
+                ? `WARN ${g.id}: ${g.gap}, so the plan runs it every 20h..28h. Declare inputs, a cacheKey, ttl or every`
+                : `FAIL: built-in ${g.id}: ${g.gap}. A toolkit bug: the plan waits for a save until it declares one`)
 
         const content = keys.filter((k) => k.population === 'content').length
         const reads = keys.filter((k) => k.population === 'reads').length

package/src/cli/cmd_Overview.ts

@@ -0,0 +1,98 @@
+// shipkit overview: the overview page in the console, top to bottom as the
+// page: the monitor widgets as the daemon last rendered them, their html read
+// as text by widget-text.ts, then the processes through
+// globalProcessesAnswer (the rows `shipkit gp` prints: pm, the daemon and the
+// web first, then the global processes). Nothing renders a widget here: the
+// daemon holds the render, and while it is down the monitor is unknown.
+import { Command, Option } from 'clipanion'
+import { daemonUrl } from '../home/home-paths.ts'
+import type { WidgetsAnswer } from '../home/home-routes.ts'
+import type { ChildView, PmAnswer } from '../home/pm.ts'
+import { splitWidgetHead, widgetText } from '../home/widget-text.ts'
+import { askDaemon, askPm, globalProcessesAnswer, localProcessDeps, renderGlobalProcesses, type GlobalProcessesAnswer, type GlobalProcessesDeps } from './cmd_GlobalProcesses.ts'
+
+export type OverviewAnswer = {
+    now: number
+    /** pm as it answered: its own pid and version, its children; null when it did not */
+    pm: { pid: number; since: number | null; version: string; children: ChildView[] } | null
+    /** the daemon's identity, asked of the daemon itself; null when it does not answer */
+    daemon: { version: string } | null
+    /** the global processes, exactly as `shipkit global-processes --json` */
+    processes: GlobalProcessesAnswer
+    /** the daemon's widgets route payload; null when the daemon does not answer */
+    widgets: WidgetsAnswer | null
+}
+
+export type OverviewDeps = Pick<GlobalProcessesDeps, 'declared' | 'order'> & {
+    pm: () => Promise<PmAnswer | null>
+    daemon: () => Promise<{ version: string } | null>
+    widgets: () => Promise<WidgetsAnswer | null>
+    now: number
+}
+
+async function getJson<T>(url: string): Promise<T | null> {
+    try {
+        const r = await fetch(url, { signal: AbortSignal.timeout(3_000) })
+        return r.ok ? ((await r.json()) as T) : null
+    } catch {
+        return null
+    }
+}
+
+/** the daemon's widgets route payload, or null */
+export const askWidgets = (url = daemonUrl()): Promise<WidgetsAnswer | null> => getJson<WidgetsAnswer>(`${url}/api/home/widgets.json`)
+
+export async function overviewAnswer(d: OverviewDeps): Promise<OverviewAnswer> {
+    const [pm, daemon, widgets] = await Promise.all([d.pm(), d.daemon(), d.widgets()])
+    const processes = await globalProcessesAnswer({ pm: async () => pm, daemon: async () => daemon, declared: d.declared, order: d.order, now: d.now })
+    return { now: d.now, pm: pm == null ? null : { pid: pm.pid, since: pm.since ?? null, version: pm.version, children: pm.children }, daemon, processes, widgets }
+}
+
+const indent = (lines: string[], by = '  '): string[] => lines.map((l) => by + l)
+
+/** the page as text: the monitor, then the processes (shipkit's own first),
+ *  each section saying what is unknown and why when pm or the daemon does not
+ *  answer */
+export function renderOverview(a: OverviewAnswer): string[] {
+    const out: string[] = ['monitor']
+    if (a.widgets == null) out.push(`  the daemon does not answer on ${daemonUrl()}, and it renders the widgets: the monitor is unknown`)
+    else {
+        if (a.widgets.widgets.length === 0 && a.widgets.errors.length === 0) out.push('  no widget declared: a repo declares one in a <name>.shipkit.ts file, as export default widget({...})')
+        for (const x of a.widgets.widgets) {
+            const { head, body } = splitWidgetHead(x.html ?? '')
+            out.push(`  ${x.title}${head == null ? '' : ` · ${widgetText(head).join(' ')}`}`)
+            if (x.error != null) out.push(`    WARN ${x.error}`)
+            if (x.html == null) out.push('    not rendered yet')
+            else out.push(...indent(widgetText(body), '    '))
+        }
+        for (const e of a.widgets.errors) out.push(`  WARN ${e}`)
+    }
+    out.push('processes', ...indent(renderGlobalProcesses(a.processes)))
+    if (a.daemon == null) out.push(`  the daemon does not answer on ${daemonUrl()}`)
+    return out
+}
+
+export class OverviewCommand extends Command {
+    static override paths = [['overview']]
+
+    static override usage = Command.Usage({
+        category: 'Home',
+        description: 'the overview page in the console: every monitor widget as text, from the html the daemon last rendered, then the processes as `shipkit gp` prints them (pm, the daemon and the web with pid, uptime and version, then every global process). When pm or the daemon does not answer, it says which and prints what is still known. Always exits 0',
+        examples: [
+            ['the overview', 'shipkit overview'],
+            ['the answers the page reads, as json', 'shipkit overview --json'],
+        ],
+    })
+
+    json = Option.Boolean('--json', false, { description: 'the answers as json: { now, pm, daemon, processes, widgets }, processes as `shipkit gp --json`, widgets the daemon route\'s payload' })
+
+    async execute(): Promise<number> {
+        const a = await overviewAnswer({ ...localProcessDeps(process.cwd()), pm: () => askPm(), daemon: () => askDaemon(), widgets: () => askWidgets(), now: Date.now() })
+        if (this.json) {
+            this.context.stdout.write(`${JSON.stringify(a, null, 2)}\n`)
+            return 0
+        }
+        for (const l of renderOverview(a)) this.context.stdout.write(`${l}\n`)
+        return 0
+    }
+}

package/src/cli/cmd_Planned.ts

@@ -0,0 +1,117 @@
+// shipkit planned: the planned page in the console. The plan lives in the
+// daemon (its marks, the running batch, the catch up spread all exist only
+// there), so this asks the daemon's route, the one the page polls, and only
+// renders it: the order and every word come from plan-timeline.ts, the page's
+// own functions. Nothing is computed from disk: a plan rebuilt here would load
+// every repo's checks and still not know what the daemon's plan holds.
+import { Command, Option } from 'clipanion'
+import { daemonUrl } from '../home/home-paths.ts'
+import type { PlannedAnswer } from '../home/home-routes.ts'
+import { markOf, spanShort, timeline, titleWords, waitingRows, waitingWords, whenWords, type Section } from '../plan/plan-timeline.ts'
+import type { PlanRow } from '../plan/planner.ts'
+
+/** the daemon's planned answer, or null when it does not answer */
+export async function askPlanned(url = daemonUrl()): Promise<PlannedAnswer | null> {
+    try {
+        const r = await fetch(`${url}/api/home/planned.json`, { signal: AbortSignal.timeout(8_000) })
+        if (!r.ok) return null
+        return (await r.json()) as PlannedAnswer
+    } catch {
+        return null
+    }
+}
+
+/** the answer for one repo: its rows and its load error only */
+export function onlyRepo(a: PlannedAnswer, repo: string): PlannedAnswer {
+    return { ...a, rows: a.rows.filter((r) => r.repo === repo), errors: a.errors.filter((e) => e.repo === repo) }
+}
+
+const pad = (s: string, n: number): string => (s.length >= n ? s : s + ' '.repeat(n - s.length))
+
+const lastWords = (r: PlanRow, now: number): string =>
+    r.last == null ? 'never ran' : `last ${r.last.status} ${spanShort(Math.max(0, now - r.last.at))} ago${r.last.streak > 1 ? ` (${r.last.streak} in a row)` : ''}`
+
+const SECTION_WORDS: Record<Section, string> = { now: 'now', next: 'next' }
+
+/** the page's one list as text: its three sections in its order, a line per
+ *  row (when, repo, check and title, mark, last result) and the rule under
+ *  it; the checks that only wait for a save are counted, or listed with `all` */
+export function renderPlanned(a: PlannedAnswer, o: { all?: boolean } = {}): string[] {
+    const out: string[] = [...(a.held ?? [])]
+    const list = timeline(a.rows)
+    const idle = a.rows.filter((r) => r.state === 'idle')
+    const w = {
+        when: Math.max(0, ...list.map((x) => whenWords(x.row, a.now).length)),
+        what: Math.max(0, ...list.map((x) => `${x.row.repo} ${x.row.check}`.length)),
+    }
+    let prev: Section | null = null
+    for (const { section, row } of list) {
+        if (section !== prev) {
+            out.push(SECTION_WORDS[section])
+            prev = section
+        }
+        const m = markOf(row)
+        const title = titleWords(row.title, row.check)
+        const cells = [`  ${pad(whenWords(row, a.now), w.when)}`, pad(`${row.repo} ${row.check}`, w.what), m.words, lastWords(row, a.now)]
+        out.push(cells.filter((c) => c !== '').join('  '))
+        out.push(`      ${title == null ? '' : `${title} · `}${row.rule}`)
+        if (row.error != null) out.push(`      error: ${row.error}`)
+    }
+    if (list.length === 0) out.push(a.rows.length === 0 ? 'nothing is planned' : 'nothing has a time of its own')
+    const waiting = waitingRows(a.rows)
+    if (waiting.length > 0) {
+        out.push(`${waitingWords(a.rows)}${o.all === true ? '' : ' (--all lists them)'}`)
+        if (o.all === true) for (const r of waiting) out.push(`  ${r.repo} ${r.check}  ${lastWords(r, a.now)}  · ${r.rule}`)
+    }
+    if (o.all === true && idle.length > 0) {
+        out.push('on a save only')
+        for (const r of [...idle].sort((x, y) => x.repo.localeCompare(y.repo) || x.check.localeCompare(y.check))) out.push(`  ${r.repo} ${r.check}  ${lastWords(r, a.now)}  · ${r.rule}`)
+    }
+    for (const e of a.errors) out.push(`WARN ${e.repo}: ${e.error}`)
+    const n = { now: list.filter((x) => x.section === 'now').length, next: list.filter((x) => x.section === 'next').length }
+    out.push(`${n.now} now, ${n.next} next, ${waiting.length} waiting, ${idle.length} on a save only${o.all === true || idle.length === 0 ? '' : ' (--all lists them)'}`)
+    return out
+}
+
+export class PlannedCommand extends Command {
+    static override paths = [['planned']]
+
+    static override usage = Command.Usage({
+        category: 'Home',
+        description: 'the planned page in the console: every check the machine runs on its own time, running now, then next, each with its repo, check and title, when, the rule that planned it and its last result. Asks the daemon, which holds the plan. With the daemon down it says so and exits 0',
+        examples: [
+            ['the plan, as the page lists it', 'shipkit planned'],
+            ['one repo only', 'shipkit planned --repo my-app'],
+            ['also the checks that only a save runs', 'shipkit planned --all'],
+            ['the route\'s exact payload', 'shipkit planned --json'],
+        ],
+    })
+
+    json = Option.Boolean('--json', false, { description: 'the daemon route\'s exact payload: { now, rows, errors, running, held }' })
+    repo = Option.String('--repo', { required: false, description: 'only this repo\'s rows' })
+    all = Option.Boolean('--all', false, { description: 'also list the checks that only a save runs (the page leaves them out)' })
+
+    async execute(): Promise<number> {
+        const got = await askPlanned()
+        if (got == null) {
+            const why = `the daemon does not answer on ${daemonUrl()}, and the plan lives there: no plan is known (\`shipkit pm\` starts it)`
+            if (this.json) {
+                this.context.stdout.write('null\n')
+                this.context.stderr.write(`${why}\n`)
+            } else this.context.stdout.write(`${why}\n`)
+            return 0
+        }
+        const a = this.repo == null ? got : onlyRepo(got, this.repo)
+        if (this.json) {
+            this.context.stdout.write(`${JSON.stringify(a, null, 2)}\n`)
+            return 0
+        }
+        if (this.repo != null && a.rows.length === 0 && a.errors.length === 0) {
+            const known = [...new Set(got.rows.map((r) => r.repo))].sort()
+            this.context.stdout.write(`no planned check in ${this.repo}; the plan holds ${known.join(', ') || 'no repo'}\n`)
+            return 0
+        }
+        for (const l of renderPlanned(a, { all: this.all })) this.context.stdout.write(`${l}\n`)
+        return 0
+    }
+}

package/src/cli.ts

@@ -9,7 +9,11 @@ import { AssetsAddCommand, AssetsCheckCommand, AssetsFillCommand, AssetsGenComma
 import { BumpCommand } from './cli/cmd_Bump.ts'
 import { CheckCommand } from './cli/cmd_Check.ts'
 import { CommandsCommand } from './cli/cmd_Commands.ts'
+import { aliasArgs, CrossRepoActivityCommand } from './cli/cmd_CrossRepoActivity.ts'
 import { ConfigKeysCommand } from './cli/cmd_ConfigKeys.ts'
+import { GlobalProcessesCommand } from './cli/cmd_GlobalProcesses.ts'
+import { PlannedCommand } from './cli/cmd_Planned.ts'
+import { OverviewCommand } from './cli/cmd_Overview.ts'
 import { CiCommand } from './cli/cmd_Ci.ts'
 import { ContractsCommand } from './cli/cmd_Contracts.ts'
 import { FleetCommand } from './cli/cmd_Fleet.ts'
@@ -86,6 +90,10 @@ export function buildCli(): Cli {
     cli.register(SmokeCommand)
     cli.register(ReflectCommand)
     cli.register(KeysCommand)
+    cli.register(GlobalProcessesCommand)
+    cli.register(CrossRepoActivityCommand)
+    cli.register(PlannedCommand)
+    cli.register(OverviewCommand)
     cli.register(ChecksCommand)
     cli.register(UnitsAliasCommand)
     cli.register(CommandsCommand)
@@ -100,7 +108,7 @@ export function buildCli(): Cli {
 // this one (one-lib.ts), so the machine's version runs in every repo. Then pm
 // is started when it is down (autostart.ts), before the command runs
 if (import.meta.main) {
-    const argv = process.argv.slice(2)
+    const argv = aliasArgs(process.argv.slice(2))
     const { handoff } = await import('./home/handoff.ts')
     handoff(argv)
     const { useOneLib } = await import('./core/one-lib.ts')

package/src/collections/checks.ts

@@ -18,7 +18,7 @@ import { homedir } from 'os'
 import { isAbsolute, join, relative, resolve } from 'path'
 import { rawName, routesToShipkit } from '../core/canonical-scripts.ts'
 import { FLOOR_IDS } from '../core/floor.ts'
-import { formatLine, parseDuration } from '../core/wire.ts'
+import { FOREVER_MS, formatLine, ttlMsOf } from '../core/wire.ts'
 import { gateInventory, type CheckRow } from '../ledger/gate-checks.ts'
 import { readLastLines, readRuns, runsPath, type LastLine, type RunRow } from '../ledger/run-log.ts'
 import { checkStatsFor, type CheckStat } from '../ledger/check-stats.ts'
@@ -166,7 +166,8 @@ function instanceOf(root: string, c: RepoConfig, row: CheckRow, stat: CheckStat
 export function keepsUntil(ttl: string | undefined, stat: Pick<CheckStat, 'measuredAt' | 'measuredStatus'> | undefined): number | null {
     if (ttl == null || ttl === '' || stat?.measuredAt == null) return null
     let ms = 0
-    try { ms = parseDuration(ttl) } catch { return null }
+    try { ms = ttlMsOf(ttl) } catch { return null }
+    if (ms >= FOREVER_MS && stat.measuredStatus === 'pass') return null
     if (ms <= 0) return null
     return stat.measuredAt + (stat.measuredStatus === 'pass' ? ms : Math.min(ms, NEGATIVE_TTL_CAP_MS))
 }

package/src/collections/providers.ts

@@ -31,7 +31,7 @@ import { testsCollection } from './tests.ts'
 import { checksCollection } from './checks.ts'
 import { LAYOUT } from '../core/layout.ts'
 import { isBudgetLine } from '../core/budget.ts'
-import { GH_LOGIN_CRED } from '../checks/SK021-github-login.check.ts'
+import { GH_LOGIN_CRED } from '../core/gh-login.ts'
 
 const askDirOf = (root: string, c: RepoConfig): string => join(root, c.asks?.dir ?? LAYOUT.asks)
 // read path must not mint an asks/ dir (listAsks mkdirs on read)

package/src/collections/test-time.ts

@@ -127,9 +127,15 @@ export type TestCheckRow = {
     shape: Shape | null
 }
 
+/** one file of any test check, named with the check that runs it */
+export type TestFileRow = FileTime & { check: string }
+
 export type TestsRootView = {
     /** slowest wall first, the never ran ones last */
     checks: TestCheckRow[]
+    /** every file of every test check, slowest first, the never ran ones
+     *  last: each check's own list, merged */
+    files: TestFileRow[]
     failing: FailingFile[]
 }
 
@@ -270,8 +276,10 @@ function lastRunOf(checkId: string, at: number, files: FileTime[], sumMs: number
 
 export function shapeTestsRoot(o: TestTimeInput): TestsRootView {
     const ids = [...new Set(o.facts.filter((f) => f.standing === 'runs' && f.checkId != null).map((f) => f.checkId!))]
+    const files: TestFileRow[] = []
     const checks = ids.map((checkId): TestCheckRow => {
         const v = shapeTestCheck(checkId, o)
+        for (const f of v.files) files.push({ ...f, check: checkId })
         const top = v.files.find((f) => f.ms != null)
         return {
             checkId,
@@ -284,5 +292,6 @@ export function shapeTestsRoot(o: TestTimeInput): TestsRootView {
             shape: v.last?.shape ?? null,
         }
     }).sort((a, b) => (b.wallMs ?? -1) - (a.wallMs ?? -1) || a.checkId.localeCompare(b.checkId))
-    return { checks, failing: failingOf(o.facts) }
+    files.sort((a, b) => (b.ms ?? -1) - (a.ms ?? -1) || a.file.localeCompare(b.file))
+    return { checks, files, failing: failingOf(o.facts) }
 }

package/src/core/agent-spawn.ts

@@ -0,0 +1,46 @@
+// AGENT SPAWN, found statically: code that starts a Claude or agent process on
+// its own (a spawn or exec of `claude`, `claude -p`, the agent sdk). No tool
+// here starts an agent unless its owner asks in person, so the sweep tests
+// (tests/no-agent-spawn.test.ts, and the house repo's own) fail on any hit.
+//
+// a string that only MENTIONS claude (a url, `~/.claude/projects`, a help
+// line naming the product) is no spawn, and comments are skipped.
+
+export type AgentSpawn = { line: number; what: string }
+
+const SHAPES: { re: RegExp; what: string }[] = [
+    // the sdks that run an agent loop in process or spawn the cli
+    { re: /(['"`])@anthropic-ai\/(?:claude-agent-sdk|claude-code)(?:\/[^'"`]*)?\1/, what: 'imports the agent sdk' },
+    // an argv whose command is claude: spawn(['claude', …]), c.exec(['claude'])
+    { re: /\[\s*(['"`])(?:[^'"`\s]*\/)?claude\1/, what: 'an argv that runs claude' },
+    // spawn('claude', …), execSync('claude -p …'), execFile('claude')
+    { re: /\b(?:spawn|spawnSync|exec|execSync|execFile|execFileSync|execa|execaSync|fork)\s*\(\s*(['"`])(?:[^'"`\s]*\/)?claude(?:\s[^'"`]*)?\1/, what: 'a process call that runs claude' },
+    // the bun shell: $`claude -p …`
+    { re: /\$\s*`\s*(?:[^`\s]*\/)?claude(?:\s|`)/, what: 'a bun shell line that runs claude' },
+    // the headless form, wherever the string goes
+    { re: /(['"`])(?:[^'"`\s]*\/)?claude\s+(?:-p|--print)\b/, what: 'a claude -p command line' },
+]
+
+/** the first agent spawn in one source text, 1-based line, comments skipped */
+export function agentSpawnIn(src: string): AgentSpawn | null {
+    const lines = src.split('\n')
+    let inBlock = false
+    for (let i = 0; i < lines.length; i++) {
+        let l = lines[i]!
+        if (inBlock) {
+            const end = l.indexOf('*/')
+            if (end < 0) continue
+            l = l.slice(end + 2)
+            inBlock = false
+        }
+        l = l.replace(/\/\*.*?\*\//g, '')
+        const open = l.indexOf('/*')
+        if (open >= 0) {
+            inBlock = true
+            l = l.slice(0, open)
+        }
+        l = l.replace(/(^|\s)\/\/.*$/, '$1')
+        for (const s of SHAPES) if (s.re.test(l)) return { line: i + 1, what: s.what }
+    }
+    return null
+}

package/src/core/archived.ts

@@ -0,0 +1,82 @@
+// `archived: true` in repo.config.ts: the repo stays known and listed, and
+// nothing runs there (no hub load, so no watch, no plan rows, no gates, no
+// processes, no widgets, no identity fill). Read and written as TEXT, never by
+// loading the config: the daemon and the page rows read many configs per poll,
+// and the toggle moves that one key and no other byte.
+import { readFileSync } from 'fs'
+import { join } from 'path'
+import { atomicWrite } from './locked-write.ts'
+import { configDepths } from './identity-color.ts'
+
+const KEY_RE = /(?:^|[{,])\s*(['"]?)archived\1\s*:\s*(true|false)\b/gm
+
+/** every top level `archived` key of `defineRepo({…})` with its value and the
+ *  offsets of the whole `archived: <value>` token */
+function archivedKeys(text: string): { on: boolean; start: number; end: number }[] {
+    const depth = configDepths(text)
+    const out: { on: boolean; start: number; end: number }[] = []
+    for (const m of text.matchAll(KEY_RE)) {
+        const lead = /^[{,]/.test(m[0]) ? 1 : 0
+        const sep = lead === 1 ? m.index : m.index - 1
+        if (sep < 0 || depth[sep] !== 1) continue
+        const start = m.index + lead + /^[{,]?(\s*)/.exec(m[0])![1]!.length
+        out.push({ on: m[2] === 'true', start, end: m.index + m[0].length })
+    }
+    return out
+}
+
+/** does the config text archive the repo */
+export const archivedOfText = (text: string): boolean => archivedKeys(text).some((k) => k.on)
+
+/** the config text with the repo archived or not. On: the key reads true, a
+ *  missing one lands as the first key of `defineRepo({`. Off: the key goes,
+ *  so a round trip gives the text back byte for byte */
+export function setArchivedText(text: string, on: boolean): string {
+    const keys = archivedKeys(text)
+    if (keys.length > 1) throw new Error('repo.config.ts declares `archived` more than once, set it by hand')
+    const k = keys[0]
+    if (on) {
+        if (k != null) return k.on ? text : `${text.slice(0, k.start)}archived: true${text.slice(k.end)}`
+        const lines = text.split('\n')
+        const open = lines.findIndex((l) => /defineRepo\(\s*\{/.test(l))
+        if (open === -1) throw new Error('repo.config.ts has no `defineRepo({` to write `archived` into, set it by hand')
+        const line = lines[open]!
+        if (/defineRepo\(\s*\{\s*$/.test(line)) {
+            const next = lines.slice(open + 1).find((l) => l.trim() !== '' && !/^\s*}/.test(l))
+            const pad = next != null ? /^(\s*)/.exec(next)![1]! : `${/^(\s*)/.exec(line)![1]!}    `
+            return [...lines.slice(0, open + 1), `${pad}archived: true,`, ...lines.slice(open + 1)].join('\n')
+        }
+        lines[open] = line.replace(/defineRepo\(\s*\{\s*/, (m) => `${m}archived: true, `)
+        return lines.join('\n')
+    }
+    if (k == null) return text
+    // a line of its own goes whole, an inline key goes with its comma
+    const lineStart = text.lastIndexOf('\n', k.start - 1) + 1
+    const lineEnd = text.indexOf('\n', k.end)
+    const rest = text.slice(k.end, lineEnd === -1 ? text.length : lineEnd)
+    if (text.slice(lineStart, k.start).trim() === '' && /^\s*,?\s*$/.test(rest)) return text.slice(0, lineStart) + text.slice(lineEnd === -1 ? text.length : lineEnd + 1)
+    const after = /^\s*,\s*/.exec(text.slice(k.end))
+    if (after != null) return text.slice(0, k.start) + text.slice(k.end + after[0].length)
+    const before = /,\s*$/.exec(text.slice(0, k.start))
+    return before != null ? text.slice(0, k.start - before[0].length) + text.slice(k.end) : text.slice(0, k.start) + text.slice(k.end)
+}
+
+const CONFIG_FILE = 'repo.config.ts'
+
+/** is this repo archived; false when it has no readable config */
+export function isArchived(root: string): boolean {
+    try {
+        return archivedOfText(readFileSync(join(root, CONFIG_FILE), 'utf8'))
+    } catch {
+        return false
+    }
+}
+
+/** archive the repo or bring it back: only that key of its config moves */
+export function writeArchived(root: string, on: boolean): boolean {
+    const path = join(root, CONFIG_FILE)
+    const text = readFileSync(path, 'utf8')
+    const out = setArchivedText(text, on)
+    if (out !== text) atomicWrite(path, out)
+    return on
+}

package/src/core/canonical-scripts.ts

@@ -65,12 +65,21 @@ export function routesToShipkit(body: string): boolean {
     return /\bshipkit\b\S*(?:\s+\S+)*?\s+ci(?:\s|$)/.test(body.split(/&&|\|\||;/)[0] ?? body)
 }
 
-// recover the consumption style from existing scripts: any shipkit command
-// already running `bun <path>/cli.ts <cmd>` fixes the style for new bodies
+/** is this path shipkit's own cli: a file named exactly `cli.ts` under a
+ *  directory whose name says shipkit. A repo's own cli (`src/cli.ts`,
+ *  `src/cli/comfy-ts-cli.ts`) is not, and taking it for shipkit writes
+ *  scripts that call a command that cli does not have */
+export function isShipkitCli(path: string): boolean {
+    const parts = path.split('/')
+    return parts.at(-1) === 'cli.ts' && parts.slice(0, -1).some((d) => /shipkit/.test(d))
+}
+
+// recover the consumption style from existing scripts: any script already
+// running shipkit's cli by path fixes the style for new bodies
 export function inferBin(scripts: Record<string, string>): string | undefined {
     for (const body of Object.values(scripts)) {
         const m = body.match(/^bun (?:--watch )?(\S+cli\.ts) /)
-        if (m != null && m[1] !== 'node_modules/rvlib-shipkit/src/cli.ts') return m[1]
+        if (m != null && isShipkitCli(m[1]!) && m[1] !== 'node_modules/rvlib-shipkit/src/cli.ts') return m[1]
     }
     return undefined
 }

package/src/core/check-runner.ts

@@ -39,7 +39,7 @@ import { parallelCap } from './parallel.ts'
 import { machinePool, SLOT_HELD_ENV, takeSlot, type SlotPool } from './slots.ts'
 import { budgetLine, machineLoad } from './budget.ts'
 import { killTree, spawnWithTimeout } from './spawn-timeout.ts'
-import { formatLine, parseWireOutput, type Line } from './wire.ts'
+import { FOREVER_MS, formatLine, parseWireOutput, type Line } from './wire.ts'
 import { offLine, type WhenDecl } from './when.ts'
 import { runCheckBody, type CheckDef, type CheckEnv } from '../check.ts'
 import { Ledger, stampCached } from '../ledger/ledger.ts'
@@ -47,7 +47,7 @@ import { attachedStamp } from './outcome-words.ts'
 import type { RunLog, RunStatus } from '../ledger/run-log.ts'
 import { liveStateOf } from '../ledger/live-runs.ts'
 import { CHECK_ID_ENV } from '../ledger/suite-log.ts'
-import { rememberWorld, replayWorld, type WorldCache } from '../ledger/world-cache.ts'
+import { rememberWorld, replayWorld, worldKeyOf, type WorldCache } from '../ledger/world-cache.ts'
 import { extractProblems } from '../problems/extract.ts'
 import { feedsProblemsPane, type Population, type Problem } from '../problems/problem-line.ts'
 
@@ -191,6 +191,9 @@ export type RunChecksOpts = {
      *  gate the whole repo, since the check's own gate already ran. */
     exclude?: string[]
     print?: (line: string) => void
+    /** where the green summary goes when the caller prints its own verdict
+     *  (`shipkit ci` does). Default: print */
+    detail?: (line: string) => void
     color?: boolean
     onCheck?: (e: CheckEvent) => void
 }
@@ -227,11 +230,21 @@ function closure(checks: RunnableCheck[], ids: string[]): Set<string> {
     return keep
 }
 
+/** how many tests a suite ran, read from the headline it prints last
+ *  (`Ran 920 tests across 12 files.`), null when it printed none */
+export function testsRan(lastLine: string): number | null {
+    const m = /Ran (\d+) tests?/.exec(lastLine)
+    return m == null ? null : Number(m[1])
+}
+
 export type Selection = {
     /** what this run measures */
     selected: RunnableCheck[]
     /** turned off by name, with the reason: never run, always reported */
     off: RunnableCheck[]
+    /** off, and outside what `--only` asked about: reported where the caller
+     *  keeps what nobody acts on */
+    offElsewhere?: RunnableCheck[]
     /** not asked about by this run, and why */
     parked: { id: string; text: string }[]
     /** asked for, and it never said whether it blocks */
@@ -337,6 +350,8 @@ export function selectChecks(o: Pick<RunChecksOpts, 'checks' | 'audience' | 'ful
     if (o.onlyIds != null && o.onlyIds.length > 0) {
         const keep = closure(o.checks, onlyIds)
         selected = selected.filter((u) => keep.has(u.id))
+        // a narrowed run says nothing about the checks it never asked about
+        return { selected, off: off.filter((u) => keep.has(u.id)), offElsewhere: off.filter((u) => !keep.has(u.id)), parked, undeclared, errors }
     }
     return { selected, off, parked, undeclared, errors }
 }
@@ -445,9 +460,9 @@ export async function runChecks(o: RunChecksOpts): Promise<RunChecksSummary> {
 
     // OFF, in ONE place: skipped by name, never run, never stored, and the
     // reason printed where the verdict would have been
-    for (const u of sel.off) {
+    for (const u of [...sel.off, ...(sel.offElsewhere ?? [])]) {
         const line: Line = { kind: 'skip', text: offLine(u.id, u.when) }
-        emit(line)
+        if (sel.off.includes(u)) emit(line); else (o.detail ?? print)(formatLine(line, color))
         report(u, { id: u.id, status: 'skip', advisory: false, replayed: false, ms: 0, exitCode: null, lines: [line], problems: [], lastLine: line.text, note: 'off', logPath: null })
     }
     // `--only` that leaves nothing to run asked a question nobody answers, and
@@ -499,10 +514,15 @@ export async function runChecks(o: RunChecksOpts): Promise<RunChecksSummary> {
      *  or that a different shipkit measured it. */
     const worldKey = (u: RunnableCheck): string => {
         let code = ''
-        try { code = o.ledger?.layer.keyFor(u.id).codeKey ?? '' } catch { code = '' }
-        // a check that writes answers a different question when frozen
-        const frozen = u.writes === true ? `\0frozen=${process.env['SHIPKIT_FROZEN'] === '1'}` : ''
-        return `tc=${o.ledger?.layer.toolchainId ?? ''}\0code=${code}\0${u.rotation ?? ''}${frozen}`
+        if (u.ttlMs < FOREVER_MS) try { code = o.ledger?.layer.keyFor(u.id).codeKey ?? '' } catch { code = '' }
+        return worldKeyOf({
+            ttlMs: u.ttlMs,
+            toolchain: u.ttlMs < FOREVER_MS ? o.ledger?.layer.toolchainId ?? '' : '',
+            code,
+            rotation: u.rotation ?? '',
+            // a check that writes answers a different question when frozen
+            frozen: u.writes === true ? process.env['SHIPKIT_FROZEN'] === '1' : null,
+        })
     }
 
     // a non-blocking failure becomes a WARNING here, at the source: printing
@@ -532,10 +552,18 @@ export async function runChecks(o: RunChecksOpts): Promise<RunChecksSummary> {
         // baked into a remembered line comes back on a replay as if this run
         // had measured it (ledger/ledger.ts rule 5)
         const head = u.lines[0]
+        // a suite's count rides on its own line: `test 920 tests (1.4s)`
+        const ran = u.status === 'pass' || u.status === 'warn' ? testsRan(u.lastLine) : null
+        const counted = ran != null && head != null && head.kind === 'ok' && (head.text === u.id || head.text.startsWith(`${u.id} (`))
+        const id = counted ? `${u.id} ${ran} test${ran === 1 ? '' : 's'}` : u.id
         const shown = u.synthetic && !u.replayed && head != null
-            ? [{ ...head, text: `${u.id} (${(u.ms / 1000).toFixed(1)}s)${u.tail}` }, ...u.lines.slice(1)]
-            : u.lines
-        for (const l of shown) emit(l)
+            ? [{ ...head, text: `${id} (${(u.ms / 1000).toFixed(1)}s)${u.tail}` }, ...u.lines.slice(1)]
+            : counted ? [{ ...head, text: `${id}${head.text.slice(u.id.length)}` }, ...u.lines.slice(1)] : u.lines
+        // a caller printing its own verdict wants one line per green check and
+        // only the warnings of a warned one; a failure prints whole
+        const quiet = (l: Line, i: number): boolean =>
+            o.detail != null && (u.status === 'pass' ? i > 0 : u.status === 'warn' || u.advisory ? l.kind === 'ok' || l.kind === 'note' || l.kind === 'skip' : false)
+        for (const [i, l] of shown.entries()) if (quiet(l, i)) o.detail!(formatLine(l, color)); else emit(l)
         if (u.status === 'fail' && !u.advisory && u.logPath != null)
             emit({ kind: 'fix-fail', text: `full log: ${u.logPath}` })
         report(u, { id: u.id, status: u.status, advisory: u.advisory, replayed: u.replayed, ms: u.ms, exitCode: u.exitCode, lines: u.lines, problems: u.problems, lastLine: u.lastLine, note: u.note, logPath: u.logPath }, finishedAt, u.attached)
@@ -842,7 +870,7 @@ export async function runChecks(o: RunChecksOpts): Promise<RunChecksSummary> {
     const warned = results.filter((r) => r.status === 'warn' || (r.status === 'fail' && r.advisory))
     const ran = results.filter((r) => r.status !== 'skip').length
     if (blocked.length === 0 && !interrupted && results.length > 0)
-        emit({ kind: 'ok', text: warned.length === 0 ? `all ${ran} check(s) green` : `all ${ran} check(s) passed, ${warned.length} with a warning: ${warned.map((r) => r.id).join(', ')}` })
+        (o.detail ?? print)(formatLine({ kind: 'ok', text: warned.length === 0 ? `all ${ran} check(s) green` : `all ${ran} check(s) passed, ${warned.length} with a warning: ${warned.map((r) => r.id).join(', ')}` }, color))
     return {
         ok: blocked.length === 0 && !interrupted,
         interrupted,