rvlib-shipkit 1.2.0 → 1.4.0

package/src/shipkit-files.ts

@@ -49,9 +49,9 @@ export type GlobalProcessDef = {
     probe?: string
     /** a button each beside the switch, by key */
     actions?: Record<string, ProcessAction>
-    /** with `url`: open it as a shipkit app window. Starting it from the
-     *  page opens that window once it answers, in one go */
-    app?: boolean
+    /** what its card wears: an emoji, or a repo-relative image path
+     *  (png, svg, ico, jpg, webp). Absent: the declaring repo's own icon */
+    icon?: string
 }
 
 export type WidgetDef = {
@@ -74,6 +74,19 @@ const KEBAB = /^[a-z0-9][a-z0-9-]*$/
 const words = (v: unknown): boolean => Array.isArray(v) && v.length > 0 && v.every((w) => typeof w === 'string')
 const httpUrl = (v: unknown): boolean => typeof v === 'string' && /^https?:\/\//.test(v)
 
+/** the image types an icon file can be, by extension */
+export const ICON_IMAGE_TYPES: Record<string, string> = { png: 'image/png', svg: 'image/svg+xml', ico: 'image/x-icon', jpg: 'image/jpeg', jpeg: 'image/jpeg', webp: 'image/webp' }
+
+/** the image an icon names (its extension), or null when it is text */
+export const iconImageType = (icon: string): string | null => ICON_IMAGE_TYPES[/\.([a-z]+)$/i.exec(icon)?.[1]?.toLowerCase() ?? ''] ?? null
+
+function iconProblem(icon: unknown): string | null {
+    if (typeof icon !== 'string' || icon.trim() === '') return 'icon is an emoji or a repo relative image path'
+    if (iconImageType(icon) != null) return icon.startsWith('/') || icon.split(/[\\/]/).includes('..') ? `icon '${icon}' must be a repo relative path` : null
+    if (/[\\/.]/.test(icon) || [...icon].length > 8) return `icon '${icon}' is neither an emoji nor an image path (${Object.keys(ICON_IMAGE_TYPES).join(', ')})`
+    return null
+}
+
 /** why a global process declaration cannot run, or null */
 export function globalProcessProblem(d: GlobalProcessDef): string | null {
     const at = `globalProcess '${String(d.id)}'`
@@ -83,7 +96,10 @@ export function globalProcessProblem(d: GlobalProcessDef): string | null {
     if (d.url != null && !httpUrl(d.url)) return `${at}: url must be an http url`
     if (d.probe != null && !httpUrl(d.probe)) return `${at}: probe must be an http url`
     if (d.down != null && d.probe == null && d.url == null) return `${at}: a bring-up (one with down) needs probe or url, the only truth of whether it is up`
-    if (d.app === true && d.url == null) return `${at}: app needs a url to open`
+    if (d.icon !== undefined) {
+        const why = iconProblem(d.icon)
+        if (why != null) return `${at}: ${why}`
+    }
     for (const [k, a] of Object.entries(d.actions ?? {})) {
         if (!KEBAB.test(k)) return `${at}: action '${k}' must be kebab-case`
         if ((a.cmd != null) === (a.run != null)) return `${at}: action '${k}' declares exactly one of cmd or run`

package/src/suite/judge-suites.ts

@@ -18,7 +18,7 @@ export type SerialSuite = {
     why: string
 }
 export type TestsConfig = {
-    /** per suite time in the quick tier (default 2000). A suite whose wall time goes over it under the parallel run is run again alone, and fails when that run burns more CPU than this, or waits more than twice this while the machine is idle. A suite whose CPU inside the parallel run, children included, plus all its worker burned before it stays under it skips that run, unless it may wait on an idle machine or ended with a child not yet reaped. The full tier fails nothing on time */
+    /** per suite time in the quick tier (default 2000). A suite whose wall time goes over it under the parallel run is run again alone, and fails when the smaller of its CPU and its wall passes this, grown with the load share by up to half, or when its wall passes twice this, an allowance that grows with the square of the load share and has no end on a saturated machine. A suite whose CPU inside the parallel run, children included, plus all its worker burned before it stays under it skips that run, unless its wall is past that allowance or it ended with a child not yet reaped. The full tier fails nothing on time */
     budgetMs?: number
     /** suites that break the budget on purpose: the full tier runs them, the quick tier does not */
     slow?: SlowSuite[]
@@ -190,32 +190,58 @@ export const WAIT_FACTOR = 2
 /** how much more CPU the same suite burns on a saturated machine. CPU time is
  *  not load free: measured on 8 cores, one suite went from 1.0s of CPU idle to
  *  1.35 to 1.5s with the cores saturated (load 7 to 19), and did not grow past
- *  that. So a loaded machine fails a suite past the budget times this */
+ *  that. So the CPU allowance grows with the load share up to this factor */
 export const LOADED_CPU_FACTOR = 1.5
+
+/** how much of the machine the other processes took, 0 idle to 1 saturated:
+ *  the one load measure every verdict here reads, so no verdict has a step */
+export const loadShare = (load: MachineLoad): number => (load.cores > 0 ? Math.min(1, Math.max(0, load.load1 / load.cores)) : 0)
+/** the CPU a suite may burn at this load: the budget, plus the measured
+ *  inflation in proportion to how saturated the machine is */
+export const cpuAllowance = (budgetMs: number, load: MachineLoad): number => budgetMs * (1 + (LOADED_CPU_FACTOR - 1) * loadShare(load))
+/** the wall a suite may take before it reads as a WAIT: WAIT_FACTOR times
+ *  the budget on an idle machine, grown with the square of the load share,
+ *  and without end once the machine is saturated. A wall on a busy machine
+ *  is the machine's (measured: 11 to 19s for suites burning 1s of CPU at
+ *  load 20.5 on 8 cores, far past any fair share), so only a quiet machine
+ *  can show a suite that sleeps; the ramp keeps the verdict continuous */
+export const waitAllowance = (budgetMs: number, load: MachineLoad): number => {
+    const free = 1 - loadShare(load) ** 2
+    return free <= 0 ? Infinity : (budgetMs * WAIT_FACTOR) / free
+}
 /** `ms` is the time the verdict used: cpu, or wall for a wait or when no cpu figure exists */
 export type Confirmed = { file: string; ms: number; wallMs: number; cpuMs: number | null; over: 'cpu' | 'wait' | 'wall' | null }
 
-/** the verdict on each suspect once it ran alone. A wall time carries the load
- *  of every other process on the machine, and another gate can triple it, so
- *  the budget judges CPU: what the suite itself burned, which load moves by
- *  a bounded factor only (LOADED_CPU_FACTOR). Wall time still fails a suite
- *  far over the budget while the machine was idle, because only then is the
- *  wait the suite's own */
+/** the verdict on each suspect once it ran alone, continuous in the load.
+ *  A wall time carries the load of every other process on the machine, so
+ *  the budget judges CPU, against an allowance that grows with the load share
+ *  (cpuAllowance). A suite is charged the SMALLER of its CPU and its wall:
+ *  JS runs on one thread, so CPU above the wall is bun's GC and JIT threads
+ *  or children running side by side, time nobody waits on. A wall past its
+ *  wait allowance fails as a wait (waitAllowance), never on a busy machine */
 export function confirmOver(suspects: Timed[], alone: Record<string, AloneRun>, budgetMs: number, load: MachineLoad): { over: Confirmed[]; cleared: Confirmed[] } {
     const byFile = new Map(Object.entries(alone).map(([f, run]) => [normSuitePath(f), run]))
-    const idle = load.load1 < load.cores
     const judged = suspects.map((t): Confirmed => {
         const run = byFile.get(t.file)
         const wallMs = run?.wallMs ?? t.ms
         const cpuMs = run?.cpuMs ?? null
         if (cpuMs == null) return { file: t.file, ms: wallMs, wallMs, cpuMs, over: wallMs > budgetMs ? 'wall' : null }
-        if (cpuMs > budgetMs * (idle ? 1 : LOADED_CPU_FACTOR)) return { file: t.file, ms: cpuMs, wallMs, cpuMs, over: 'cpu' }
-        if (idle && wallMs > budgetMs * WAIT_FACTOR) return { file: t.file, ms: wallMs, wallMs, cpuMs, over: 'wait' }
-        return { file: t.file, ms: cpuMs, wallMs, cpuMs, over: null }
+        const charged = Math.min(cpuMs, wallMs)
+        if (charged > cpuAllowance(budgetMs, load)) return { file: t.file, ms: charged, wallMs, cpuMs, over: 'cpu' }
+        if (wallMs > waitAllowance(budgetMs, load)) return { file: t.file, ms: wallMs, wallMs, cpuMs, over: 'wait' }
+        return { file: t.file, ms: charged, wallMs, cpuMs, over: null }
     })
     return { over: judged.filter((c) => c.over != null), cleared: judged.filter((c) => c.over == null) }
 }
 
+const secs = (ms: number): string => `${(ms / 1000).toFixed(1)}s`
+
+/** the line a confirmed suite fails with */
+export const overWords = (c: Confirmed, load: MachineLoad, budgetMs: number = DEFAULT_BUDGET_MS): string =>
+    c.over === 'cpu' ? `${c.file} ${secs(c.cpuMs ?? c.ms)} of CPU (${secs(c.wallMs)} wall)`
+        : c.over === 'wait' ? `${c.file} ${secs(c.wallMs)} wall at load ${load.load1.toFixed(1)} on ${load.cores} cores, past its ${secs(waitAllowance(budgetMs, load))} wait allowance, with ${secs(c.cpuMs ?? 0)} of CPU: it waits (a timer, a sleep, a poll)`
+            : `${c.file} ${secs(c.wallMs)} wall (no CPU figure)`
+
 /** how the parallel phase's workers hand the runner the CPU of each suite
  *  (suite-cpu-preload.ts writes it, readPhaseCpu reads it) */
 export const SUITE_CPU_ENV = 'SHIPKIT_SUITE_CPU'
@@ -253,16 +279,15 @@ export function readPhaseCpu(text: string, cwd: string): { ran: string[]; cpu: R
  *  what the worker computed by the suite's end, its whole CPU before the
  *  suite (priorMs) plus what the suite burned, and sharing the machine only
  *  raises CPU, so a suspect whose sum is inside the budget is inside it alone
- *  too. A suspect with no figure (a child not yet reaped) runs alone. Only the alone run can see a WAIT, so a
- *  suite past WAIT_FACTOR times the budget in wall time still gets it while
- *  the machine is idle */
+ *  too. A suspect with no figure (a child not yet reaped) runs alone. Only the
+ *  alone run can see a WAIT, so a suite whose wall is past its wait
+ *  allowance still gets it */
 export function aloneRunsNeeded(suspects: Timed[], parallelCpu: Record<string, PhaseCpu>, budgetMs: number, load: MachineLoad): { rerun: Timed[]; cleared: Confirmed[] } {
-    const idle = load.load1 < load.cores
     const rerun: Timed[] = []
     const cleared: Confirmed[] = []
     for (const t of suspects) {
         const f = parallelCpu[t.file]
-        const mayWait = idle && t.ms > budgetMs * WAIT_FACTOR
+        const mayWait = t.ms > waitAllowance(budgetMs, load)
         if (f != null && f.cpuMs + f.priorMs <= budgetMs && !mayWait) cleared.push({ file: t.file, ms: f.cpuMs, wallMs: t.ms, cpuMs: f.cpuMs, over: null })
         else rerun.push(t)
     }

package/src/suite/suite-cli.ts

@@ -16,7 +16,7 @@ import { killTree } from '../core/spawn-timeout.ts'
 import { parallelCap } from '../core/parallel.ts'
 import { poolDir, poolOccupancy } from '../core/slots.ts'
 import { keepTimings, seedTimings, timingsHome } from './kept-timings.ts'
-import { aloneRunsNeeded, bunfigTest, readPhaseCpu, SUITE_CPU_ENV, type AloneRun, type Confirmed, confirmOver, crashedWorkers, WAIT_FACTOR, DEFAULT_BUDGET_MS, FULL_CEILING_MS, failedSuites, failLines, judgeSuites, normSuitePath, parseSuiteFlags, planPhases, QUICK_CEILING_MS, poolWorkers } from './judge-suites.ts'
+import { aloneRunsNeeded, bunfigTest, readPhaseCpu, SUITE_CPU_ENV, type AloneRun, type Confirmed, confirmOver, crashedWorkers, overWords, DEFAULT_BUDGET_MS, FULL_CEILING_MS, failedSuites, failLines, judgeSuites, normSuitePath, parseSuiteFlags, planPhases, QUICK_CEILING_MS, poolWorkers } from './judge-suites.ts'
 
 type Phase = { code: number; signal: string | null; stalled: boolean; out: string; timings: Record<string, number>; cpuMs: number | null }
 
@@ -63,11 +63,6 @@ const CPU_PRELOAD = join(import.meta.dir, 'suite-cpu-preload.ts')
 
 const secs = (ms: number): string => `${(ms / 1000).toFixed(1)}s`
 
-const overWords = (c: Confirmed): string =>
-    c.over === 'cpu' ? `${c.file} ${secs(c.ms)} of CPU (${secs(c.wallMs)} wall)`
-        : c.over === 'wait' ? `${c.file} ${secs(c.wallMs)} wall on an idle machine, more than ${WAIT_FACTOR}x the budget, with ${secs(c.cpuMs ?? 0)} of CPU: it waits (a timer, a sleep, a poll)`
-            : `${c.file} ${secs(c.wallMs)} wall (no CPU figure)`
-
 /** the suite FILES a phase names: a flag is not a file, and the repo's own
  *  `bun test` arguments are not files this runner put there */
 const phaseFiles = (phase: string[], rawArgs: string[]): string[] => phase.filter((a) => !a.startsWith('-') && !rawArgs.includes(a))
@@ -117,6 +112,9 @@ export async function suiteCli(argv: string[]): Promise<number> {
         const kept = timed && parallel ? timingsHome(process.cwd(), unit) : null
         if (kept != null) seedTimings(kept, join(dir, 'parallel.json'))
         const cpuFile = timed && parallel ? join(dir, 'cpu.tsv') : null
+        // the load BEFORE this run: read after it, the one minute average
+        // carries this run's own parallel phase, which is no other process
+        const load = machineLoad()
         const p1At = Date.now()
         const p1 = await runPhase(plan.parallel, timed ? join(dir, 'parallel.json') : null, ceilingMs, tmp, true, cpuFile)
         const p1Ms = Date.now() - p1At
@@ -148,7 +146,6 @@ export async function suiteCli(argv: string[]): Promise<number> {
         // before it can fail the task. One at a time: four alone runs side by
         // side each burned about 40% more CPU than one alone (8 cores)
         const aloneRuns: Record<string, AloneRun> = {}
-        const load = machineLoad()
         const parallelCpu = phaseCpu.cpu
         const { rerun, cleared: clearedInPhase } = aloneRunsNeeded(judged.over, parallelCpu, budget, load)
         const aloneAt = Date.now()
@@ -224,7 +221,7 @@ export async function suiteCli(argv: string[]): Promise<number> {
             ...(!vacuous && (failedTests > 0 || (phases.some((p) => p.code !== 0 && p.signal == null) && killed.length === 0))
                 ? [`FAIL: ${failedTests} test(s) failed, Ran ${ran} tests${slowest}`] : []),
             ...(over.length > 0
-                ? [`FAIL: ${over.length} suite(s) over the ${budget}ms budget: ${over.map(overWords).join(', ')} (run alone, load ${load.load1.toFixed(1)} on ${load.cores} cores). Make each fast, or declare it in ${declaredIn}.slow with what it catches and why it cannot be fast`]
+                ? [`FAIL: ${over.length} suite(s) over the ${budget}ms budget: ${over.map((c) => overWords(c, load, budget)).join(', ')} (run alone, load ${load.load1.toFixed(1)} on ${load.cores} cores before the run). Make each fast, or declare it in ${declaredIn}.slow with what it catches and why it cannot be fast`]
                 : []),
         ]
         // the most actionable failure prints LAST, where the gate reads its headline

package/src/wiki/lint-md.ts

@@ -6,6 +6,7 @@ import { scanMd, type MdDanglingRef, type ScanMdConfig } from 'rvlib-shipkit/src
 export type MdLintReport = {
     index: string | null // resolved entrypoint (null = neither index.md nor README.md found)
     files: number
+    pages: string[] // every scanned .md file, scan-root relative
     orphans: string[] // .md files with no path from the entrypoint
     dangling: MdDanglingRef[] // refs whose target does not exist in the scan
     ok: boolean
@@ -17,6 +18,7 @@ export function lintMd(cfg: ScanMdConfig): MdLintReport {
     return {
         index: scan.index,
         files: scan.graph.nodes.length,
+        pages: scan.graph.nodes.map((n) => n.id),
         orphans,
         dangling: scan.dangling,
         ok: scan.index != null && orphans.length === 0 && scan.dangling.length === 0,

package/src/wiki/scan-md.ts

@@ -4,10 +4,14 @@
 //   → path.md          lazy  — resolved from the scan root, then file-relative
 //   [text](path.md)    lazy  — file-relative
 //   `path.md`          lazy  — file-relative, then from the scan root
+//   [text](dir/)       lazy  — a folder: an edge to every page under it
+//   `dir/`             lazy  — the same, from a backtick mention
+// A ref that leaves the scan root but stays under `boundary` is checked on
+// disk: no edge, and dangling only when the target is really missing.
 // Depth = 0-1 BFS from the index (eager edge keeps depth, lazy adds 1);
 // unreachable files stay in the graph with no depth (lint-md.ts turns those,
 // plus dangling refs, into failures — the graph itself is a viewer).
-import { readdirSync, readFileSync, statSync } from 'fs'
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
 import { basename, dirname, join, relative, resolve } from 'path'
 import type { MdEdge, MdGraph, MdNode } from 'rvlib-shipkit/src/wiki/md-graph.ts'
 
@@ -15,6 +19,7 @@ export type ScanMdConfig = {
     root: string // absolute dir to scan
     index?: string // root-relative entry the BFS starts from (default: index.md AND README.md, both)
     skipDirs?: string[] // dir names to skip on top of node_modules/.git/dist/tmp
+    boundary?: string // absolute dir enclosing root (a repo): refs leaving root but staying here resolve on disk
 }
 
 export type MdDanglingRef = { from: string; token: string } // an @/→/[](…) ref whose target is not in the scan
@@ -46,13 +51,33 @@ export function scanMd(cfg: ScanMdConfig): MdScan {
     // writers inside a scanned dir often name paths from the REPO root
     // ("agent/architecture.md" while scanning agent/) — accept that form too
     const rootBase = `${basename(cfg.root)}/`
-    const resolveRef = (fromRel: string, token: string): string | null => {
-        const cands = [resolve(join(cfg.root, dirname(fromRel)), token), resolve(cfg.root, token)]
-        if (token.startsWith(rootBase)) cands.push(resolve(cfg.root, token.slice(rootBase.length)))
-        for (const cand of cands) {
+    const cands = (fromRel: string, token: string): string[] => {
+        const out = [resolve(join(cfg.root, dirname(fromRel)), token), resolve(cfg.root, token)]
+        if (token.startsWith(rootBase)) out.push(resolve(cfg.root, token.slice(rootBase.length)))
+        return out
+    }
+    // pages a ref reaches: one file, every page under a folder (never the
+    // root itself), or none. `onDisk` = the target exists in the boundary
+    // outside the scan, which is resolved but carries no edge.
+    type Hit = { to: string[]; onDisk: boolean }
+    const resolveRef = (fromRel: string, token: string): Hit | null => {
+        const folder = token.endsWith('/')
+        for (const cand of cands(fromRel, token)) {
             const rel = relative(cfg.root, cand)
-            if (!rel.startsWith('..') && inGraph.has(rel)) return rel
+            if (rel.startsWith('..')) continue
+            if (!folder && inGraph.has(rel)) return { to: [rel], onDisk: false }
+            if (folder && rel === '') return { to: [], onDisk: false }
+            if (folder) {
+                const under = files.filter((f) => f.startsWith(`${rel}/`))
+                if (under.length > 0) return { to: under, onDisk: false }
+                if (existsSync(cand)) return { to: [], onDisk: true }
+            }
         }
+        if (cfg.boundary == null) return null
+        const cand = resolve(join(cfg.root, dirname(fromRel)), token)
+        const inRoot = !relative(cfg.root, cand).startsWith('..')
+        const inBoundary = !relative(cfg.boundary, cand).startsWith('..')
+        if (!inRoot && inBoundary && existsSync(cand)) return { to: [], onDisk: true }
         return null
     }
     const edgesOf = (rel: string): MdEdge[] => {
@@ -64,14 +89,16 @@ export function scanMd(cfg: ScanMdConfig): MdScan {
         // strict: @/→/[](…) are deliberate wiki refs — a miss is a dangling ref.
         // Backtick spans mention paths casually (other repos, deleted examples) — resolve or ignore, never fail.
         const push = (token: string, eager: boolean, strict: boolean) => {
-            const to = resolveRef(rel, token)
-            if (to != null && to !== rel) out.push({ from: rel, to, eager })
-            else if (to == null && strict) dangling.push({ from: rel, token })
+            const hit = resolveRef(rel, token)
+            if (hit == null) { if (strict) dangling.push({ from: rel, token }); return }
+            for (const to of hit.to) if (to !== rel) out.push({ from: rel, to, eager })
         }
-        for (const m of prose.matchAll(/(?:^|[\s(])@([\w][\w./-]*\.md)/gm)) push(m[1]!, true, true)
+        for (const m of prose.matchAll(/(?:^|[\s(])@((?:\.{1,2}\/)*[\w][\w./-]*\.md)/gm)) push(m[1]!, true, true)
         for (const m of prose.matchAll(/→\s*([\w][\w./-]*\.md)\b/g)) push(m[1]!, false, true)
         for (const m of prose.matchAll(/\]\(([^)\s:]+\.md)\)/g)) push(m[1]!, false, true)
+        for (const m of prose.matchAll(/\]\(([^)\s:]*\/)\)/g)) push(m[1]!, false, true)
         for (const s of spans) for (const m of s.matchAll(/[\w][\w./-]*\.md/g)) push(m[0], false, false)
+        for (const s of spans) for (const m of s.matchAll(/(?:^|\s)([\w.][\w./-]*\/)(?=$|[\s<*])/g)) push(m[1]!, false, false)
         return out
     }
     const dangling: MdDanglingRef[] = []

package/src/checks/SK023-stores-under-cap.check.ts

@@ -1,49 +0,0 @@
-// SK023 stores under cap (core/retention.ts owns the caps): every store shipkit
-// writes for this repo, and the machine's own when a home dir exists, is
-// inside its declared cap plus the drift one sweep interval allows. Red means
-// the daemon's hourly sweep stopped running, or a store grows faster than its
-// cap assumes. The fix runs the sweep.
-import { existsSync } from 'fs'
-import { check } from '../check.ts'
-import { fmtAge, fmtBytes, measureStores, repoStores, sweepStores, type Store } from '../core/retention.ts'
-import { homeDir } from '../home/home-paths.ts'
-import { machineStores } from '../home/machine-stores.ts'
-
-const storesOf = (root: string): Store[] => [...repoStores(root), ...(existsSync(homeDir()) ? machineStores(homeDir()) : [])]
-
-const capWords = (s: Store): string =>
-    [
-        s.cap.maxCount != null ? `${s.cap.maxCount} entries` : null,
-        s.cap.maxAgeMs != null ? fmtAge(s.cap.maxAgeMs) : null,
-        s.cap.maxFileBytes != null ? `${fmtBytes(s.cap.maxFileBytes)} a file` : null,
-        s.cap.maxBytes != null ? fmtBytes(s.cap.maxBytes) : null,
-    ].filter((x) => x != null).join(', ')
-
-export const storesUnderCap = check({
-    id: 'SK023',
-    blocking: false,
-    title: 'stores under cap',
-    description: 'every store shipkit writes (answers, run record, logs, jobs) is inside its cap',
-    owner: 'build/shipkit/built-in-checks.md',
-    when: 'health',
-    run: (c) => {
-        const all = measureStores(storesOf(c.root))
-        const over = all.filter((m) => m.over != null)
-        const unread = all.filter((m) => m.use == null)
-        for (const m of over) c.fail(`${m.store.id} over its cap: ${m.over} (${m.store.where})`, 'shipkit check --fix SK023 runs the sweep the daemon runs hourly')
-        for (const m of unread) c.warn(`${m.store.id} could not be read (${m.store.where})`)
-        if (over.length === 0) c.ok(`${all.length} stores inside their caps: ${all.map((m) => `${m.store.id} ${m.use?.count ?? '?'} (cap ${capWords(m.store)})`).join(', ')}`)
-    },
-    fix: async (c) => {
-        const stores = storesOf(c.root)
-        const before = measureStores(stores).filter((m) => m.over != null)
-        const r = await sweepStores(stores)
-        const broke = r.filter((x) => x.error != null)
-        return {
-            changed: before.length > 0,
-            summary: `swept ${stores.length} stores${before.length > 0 ? `, ${before.map((m) => m.store.id).join(', ')} were over` : ''}${broke.length > 0 ? `; failed: ${broke.map((x) => `${x.id} (${x.error})`).join(', ')}` : ''}`,
-        }
-    },
-})
-
-export default storesUnderCap

package/src/checks/contracts.check.ts

@@ -1,20 +0,0 @@
-// the contracts check — `.shipkit/*` release-contract fulfillness. It shares ONE
-// evaluation with check SK002 (the `contractsResult` scan), and it tags with
-// that id, because the invariant has one owner and two surfaces report it. A
-// venue deploy step deps on it BY NAME, which needs nothing from this end.
-import { applyContractsResult, contractsResult } from '../contracts/apply-contracts.ts'
-import { check } from '../check.ts'
-import { contractsFulfillness } from './SK002-contracts-fulfillness.check.ts'
-
-export const contractsCheck = check({
-    id: 'contracts',
-    title: 'contracts',
-    description: 'every declared venue has the `.shipkit/*` release contract it demands',
-    owner: 'meta/contracts.md',
-    blocking: true,
-    run: async (c) => {
-        applyContractsResult(c, await c.use(contractsResult), contractsFulfillness)
-    },
-})
-
-export default contractsCheck