rvlib-shipkit 1.8.0 → 2.0.0

package/src/serve/hub-app/tree-build.ts

@@ -9,6 +9,7 @@ import type { ProcessRow, RowDot } from '../../home/process-rows.ts'
 import { checkVerdictWords, plural } from '../../core/outcome-words.ts'
 import { runsWords } from '../../core/runs-matrix.ts'
 import { checkName } from './check-words.ts'
+import type { WhenAt } from './hub-types.ts'
 import { durationTone, fmtMs, type DurTone } from './dur.ts'
 import type { HashSel } from './hash-route.ts'
 import { SECTION_LETTER, sectionLabel, type SectionId } from './keys.ts'
@@ -234,8 +235,8 @@ export function flattenTree(nodes: TreeNode[], expanded: Set<string>, depth = 0)
 /** the line at the top of the checks page: how much of this repo runs on
  *  every gate, and how much does not. Counts CHECKS only, because nothing
  *  else declares a place to run */
-export function whenCounts(resources: Resource[]): Record<'always' | 'release' | 'health' | 'off', number> {
-    const out = { always: 0, release: 0, health: 0, off: 0 }
+export function whenCounts(resources: Resource[]): Record<WhenAt, number> {
+    const out: Record<WhenAt, number> = { always: 0, release: 0, health: 0, commit: 0, off: 0 }
     for (const r of resources) if (r.check != null) out[r.check.when]++
     return out
 }

package/src/serve/hub-app/tree-svc.ts

@@ -95,9 +95,9 @@ export class TreeSvc {
     /** the line at the top of the checks page: what runs always and what does not */
     get whenLine(): string {
         const c = whenCounts(this.st.cols.resources)
-        const total = c.always + c.release + c.health + c.off
+        const total = c.always + c.release + c.health + c.commit + c.off
         if (total === 0) return ''
-        return [`${c.always} always`, `${c.release} release`, `${c.health} health`, `${c.off} off`].join(' · ')
+        return [`${c.always} always`, `${c.release} release`, `${c.health} health`, `${c.commit} commit`, `${c.off} off`].join(' · ')
     }
 
     get redCount(): number {

package/src/serve/hub-port.ts

@@ -1,15 +1,15 @@
 // the hub's default port, alone in its own module ON PURPOSE.
 //
 // It is four lines of arithmetic that several places need BEFORE any server
-// exists: the repo scaffold writes it into .vscode/tasks.json, `init` prints
-// it, the config resolver defaults to it. Importing it from run-serve.ts drags
+// exists: the repo scaffold writes it into agent/index.md, `init` prints it,
+// the config resolver defaults to it. Importing it from run-serve.ts drags
 // the whole hub (react, the markdown renderer, the sanitiser, every panel)
 // into a caller that only wanted a number, which measured 393ms of module
 // load in the scaffold alone.
 //
 // A port derived from the repo NAME rather than assigned means two repos open
 // side by side almost never collide, and the same repo always reopens on the
-// same port, which is what makes a folder-open task able to advertise a URL.
+// same port, which is what lets a page advertise a URL before the hub runs.
 export function defaultHubPort(name: string): number {
     let h = 0
     for (const c of name) h = (h * 31 + c.charCodeAt(0)) >>> 0

package/src/serve/hub-runtime.ts

@@ -27,8 +27,6 @@ import { wikisCollection } from '../collections/wikis.ts'
 import { pingTick } from '../collections/pings.ts'
 import { buildCollections } from '../collections/providers.ts'
 import { loadRepoConfig, type RepoConfig } from '../repo-config.ts'
-import { CheckCtx } from '../core/check-ctx.ts'
-import { proseView } from '../prose/prose-view.ts'
 import { allTasks, gateInventory } from '../ledger/gate-checks.ts'
 import { runCheck, type CheckEvent } from '../core/run-check.ts'
 import { runCi, type CiOpts } from '../core/run-ci.ts'
@@ -158,9 +156,10 @@ export async function resolveHubDeps(root: string, boot: RepoConfig, io: ServeIo
         graphs.push({ id: 'agent', label: 'agent/', title: `${c.name} agent/`, load: () => scanMdGraph({ root: agentRoot, index: c.serve?.agentIndex }), lint: { root: agentRoot, index: c.serve?.agentIndex } })
     // ONE page for every repo: the studio ALWAYS
     // mounts — kit-less repos get an empty media section, never a second
-    // page. A broken kit degrades to the same empty kit, loudly.
+    // page. A broken kit degrades to the same empty kit, loudly, and a repo
+    // whose own tool owns the picking turns the kit off here
     let kit: ResolvedKit | null = null
-    if (existsSync(join(root, '.shipkit/assets/kit.ts'))) {
+    if (c.serve?.assets !== false && existsSync(join(root, '.shipkit/assets/kit.ts'))) {
         try {
             kit = await loadKit(root)
         } catch (e) {
@@ -390,7 +389,6 @@ export async function resolveHubDeps(root: string, boot: RepoConfig, io: ServeIo
             const input = { facts, runs: readRuns(record), suiteRuns: readSuiteRuns(record) }
             return check == null || check === '' ? shapeTestsRoot(input) : shapeTestCheck(check, input)
         },
-        prose: async () => proseView(CheckCtx.open({ root, config: c }), c),
         needs: () => projectNeeds(allCollections(), hubProblems.collector),
         hubProblems,
         // a job outlives this image, so only an in process run holds a reload back

package/src/serve/project-gutter.ts

@@ -9,7 +9,7 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
 import { basename, dirname, join, resolve, sep } from 'path'
 import { fileURLToPath } from 'url'
-import { gitRoot } from '../core/git-root.ts'
+import { gitRoot, isLinkedWorktree } from '../core/git-root.ts'
 import { DB_FILE } from '../ledger/db.ts'
 import { defaultHubPort } from './hub-port.ts'
 import { LAYOUT } from '../core/layout.ts'
@@ -52,7 +52,9 @@ export const ICON_FILES = ['.shipkit/identity/icon.png', 'public/favicon.png', '
 
 export const ICON_TYPES: Record<string, string> = { png: 'image/png', svg: 'image/svg+xml', ico: 'image/x-icon' }
 
-/** every direct child of `parent` that includes `index`, sorted by name */
+/** every direct child of `parent` that includes `index`, sorted by name. A
+ *  linked worktree of one is that repo checked out again, never a repo of its
+ *  own: its processes would collide with the main checkout's ids and ports */
 export function wiredRepos(parent: string, index: string, home: string): WiredRepo[] {
     let names: string[]
     try {
@@ -65,6 +67,7 @@ export function wiredRepos(parent: string, index: string, home: string): WiredRe
         if (name.startsWith('.')) continue
         const path = join(parent, name)
         if (!includeTargets(path, home).includes(index)) continue
+        if (isLinkedWorktree(path)) continue
         out.push({ name, path, icon: ICON_FILES.find((f) => existsSync(join(path, f))) ?? null })
     }
     return out

package/src/serve/run-lanes.ts

@@ -7,7 +7,8 @@
 //   - a run that writes the tree (a repair pass) waits for every run ahead of
 //     it, and every later run waits for it
 //   - every other run starts at once: the machine slot pool each check body
-//     takes bounds the CPU, never this queue
+//     takes bounds the CPU, never this queue. It admits fewer slots on a
+//     loaded machine (core/slots.ts), so a run past it waits and says why
 //
 // the one constraint a reader breaks first: the stamp is taken when a run
 // STARTS, before its body reads anything, so a tree that moves during the run
@@ -15,6 +16,7 @@
 import { createHash } from 'crypto'
 import { statSync } from 'fs'
 import { join } from 'path'
+import { fixPassRuns } from '../core/fix-scope.ts'
 import { gitBin } from '../core/git-bin.ts'
 
 export type LaneAsk = {
@@ -106,8 +108,10 @@ export function runKey(kind: string, opts: Record<string, unknown>): string {
     return `${kind} ${JSON.stringify(sorted)}`
 }
 
-/** a run with its repair pass on: `fix` and `fixRules` default to on */
-export const writesTree = (opts: Record<string, unknown>): boolean => opts.fix !== false || opts.fixRules !== false
+/** a run whose repair pass runs (core/fix-scope.ts): the structural fixers
+ *  and the hooks only ever run inside it */
+export const writesTree = (opts: Record<string, unknown>): boolean =>
+    fixPassRuns({ fix: typeof opts.fix === 'boolean' ? opts.fix : undefined, onlyIds: Array.isArray(opts.onlyIds) ? (opts.onlyIds as string[]) : undefined })
 
 /** HEAD, what git status lists, and the stat of each listed path, hashed:
  *  equal stamps mean no tracked or untracked file moved in between. Null

package/src/serve/serve-hub.ts

@@ -16,7 +16,6 @@ import type { CheckEvent } from '../core/run-check.ts'
 import { configDirty, readGateBlock, writeGateBlock, type GateEdit } from '../core/when-block.ts'
 import type { InvokedBy } from '../ledger/run-log.ts'
 import type { GraphMount } from '../wiki/graph-mount.ts'
-import type { ProseView } from '../prose/prose-view.ts'
 import type { Timeline } from '../ledger/run-timeline.ts'
 import type { TestCheckView, TestsRootView } from '../collections/test-time.ts'
 import type { LiveView } from '../ledger/live-timeline.ts'
@@ -105,9 +104,6 @@ export type HubDeps = {
     /** the comfy panel; null when the repo declares no workflow module, which
      *  is also when the comfy section is absent from the page */
     comfy: ComfyDeps | null
-    /** rule SK014's hits, grouped by word, over the config on disk: the data
-     *  of the SK014 page. Absent = the endpoint answers 404 */
-    prose?: () => Promise<ProseView>
     /** re-read repo.config.ts when its bytes moved. The switch WRITES that
      *  file, so every surface built on the config asks for this first, or a
      *  toggle reads as a toggle that did nothing until the next restart */
@@ -367,7 +363,7 @@ export function hubHandler(d: HubDeps, o: { base?: string; projects?: Gutter } =
                 if (req.method === 'POST') {
                     try {
                         const body = (await req.json()) as GateEdit & { expect?: string }
-                        const b = await writeGateBlock(d.root, { off: body.off, slow: body.slow, slowRemove: body.slowRemove, words: body.words }, { expect: body.expect })
+                        const b = await writeGateBlock(d.root, { off: body.off, slow: body.slow, slowRemove: body.slowRemove }, { expect: body.expect })
                         await d.refresh?.()
                         return Response.json({ ...b, dirty: configDirty(d.root) })
                     } catch (e) {
@@ -375,17 +371,6 @@ export function hubHandler(d: HubDeps, o: { base?: string; projects?: Gutter } =
                     }
                 }
             }
-            if (path === '/api/prose.json' && d.prose != null) {
-                // every SK014 hit, grouped by word, noisiest first. The word
-                // lists are written through /api/checks/when like every other
-                // edit of repo.config.ts
-                await d.refresh?.()
-                try {
-                    return Response.json(await d.prose())
-                } catch (e) {
-                    return new Response(`the prose check could not run: ${(e as Error).message}`, { status: 500 })
-                }
-            }
             if (path === '/api/check/run' && req.method === 'POST') {
                 const body = (await req.json().catch(() => ({}))) as { only?: string[]; gate?: boolean }
                 // NDJSON: one line per event, so the page colours a row the

package/src/serve/tracked-watch.ts

@@ -48,7 +48,7 @@ export async function gitIgnored(root: string, paths: string[]): Promise<Set<str
 }
 
 /** a commit, a fetch or a tag moved a ref: the one write inside .git a check
- *  keyed on the refs (SK009) must hear. Lock files are git mid write */
+ *  keyed on the refs must hear. Lock files are git mid write */
 export function isRefMove(rel: string): boolean {
     if (rel.endsWith('.lock')) return false
     return rel === '.git/HEAD' || rel === '.git/packed-refs' || rel.startsWith('.git/refs/')

package/src/smoke/run-smoke.ts

@@ -27,6 +27,10 @@ export type SmokeRoute = {
      *  match's href after this route and judges the landed page as its own
      *  row. How a detail page with a real id gets visited without knowing one. */
     open?: string
+    /** the visible text a settled route needs before it counts as rendered,
+     *  default 40. A canvas app (a game) draws everything into one canvas and
+     *  shows no text: `{ path: '/', waitFor: 'canvas', minChars: 0 }`. */
+    minChars?: number
 }
 
 export type SmokeLogin = {
@@ -63,8 +67,9 @@ export type SmokeConfig = {
 const SMOKE_KEYS = new Set(['base', 'routes', 'login', 'paceMs', 'shots'])
 const LOGIN_KEYS = new Set(['path', 'email', 'emailSecret', 'passwordSecret', 'form'])
 const FORM_KEYS = new Set(['email', 'password', 'submit'])
-const ROUTE_KEYS = new Set(['path', 'waitFor', 'open'])
+const ROUTE_KEYS = new Set(['path', 'waitFor', 'open', 'minChars'])
 export const DEFAULT_LOGIN_PATH = '/login'
+export const DEFAULT_MIN_CHARS = 40
 
 export const DEFAULT_PACE_MS = 3000
 export const DEFAULT_SHOTS = `${LAYOUT.tmp}/smoke`
@@ -86,6 +91,8 @@ export function validateSmokeConfig(c: unknown): SmokeConfig {
                 const v = (r as Record<string, unknown>)[k]
                 if (v != null && (typeof v !== 'string' || v === '')) throw new Error(`defineRepo: smoke.routes['${path}'].${k} must be a non-empty selector`)
             }
+            const min = (r as Record<string, unknown>)['minChars']
+            if (min != null && (typeof min !== 'number' || !Number.isInteger(min) || min < 0)) throw new Error(`defineRepo: smoke.routes['${path}'].minChars must be a whole number of characters, 0 or more`)
         }
     }
     if (s['login'] != null) {
@@ -152,8 +159,8 @@ export type SmokeReport = {
  *  nothing threw, an empty `waitFor` on a listing is exactly how a broken
  *  migration looks, and a page that scrolls sideways is a layout defect only
  *  a real browser can see (happy-dom does no layout). */
-export function judgeRoute(r: { route: string; chars: number; matches: number; problems: number; waitFor?: string; overflowPx: number }): RouteReport {
-    const empty = r.chars < 40
+export function judgeRoute(r: { route: string; chars: number; matches: number; problems: number; waitFor?: string; minChars?: number; overflowPx: number }): RouteReport {
+    const empty = r.chars < (r.minChars ?? DEFAULT_MIN_CHARS)
     const noMatch = r.waitFor != null && r.matches === 0
     const sideways = r.overflowPx > 1
     const note = empty ? 'EMPTY PAGE' : noMatch ? `NO MATCH FOR ${r.waitFor}` : sideways ? `PAGE SCROLLS SIDEWAYS +${r.overflowPx}px` : r.problems > 0 ? `${r.problems} problem(s)` : ''
@@ -368,7 +375,7 @@ export async function runSmoke(root: string, config: SmokeConfig, opts: SmokeRun
         }
 
         /** visit one url, settle it, judge it, screenshot it */
-        const visit = async (label: string, url: string, waitFor?: string): Promise<RouteReport> => {
+        const visit = async (label: string, url: string, waitFor?: string, minChars?: number): Promise<RouteReport> => {
             // let the previous page's requests drain out of the concurrency
             // window BEFORE the label moves, or its late failures land on this row
             if (paceMs > 0) await page.waitForTimeout(paceMs)
@@ -387,11 +394,11 @@ export async function runSmoke(root: string, config: SmokeConfig, opts: SmokeRun
                 return Math.max(de.scrollWidth - de.clientWidth, doc.body.scrollWidth - doc.body.clientWidth)
             }).catch(() => 0)
             await page.screenshot({ path: join(shots, `${routeSlug(label)}.png`), fullPage: true })
-            return judgeRoute({ route: label, chars, matches, problems: problems.length - before, waitFor, overflowPx })
+            return judgeRoute({ route: label, chars, matches, problems: problems.length - before, waitFor, minChars, overflowPx })
         }
 
         for (const route of routes) {
-            reports.push(await visit(route.path, route.path, route.waitFor))
+            reports.push(await visit(route.path, route.path, route.waitFor, route.minChars))
             if (route.open == null) continue
             // a detail page with a real id: the first link the selector matches
             const href = await page.locator(route.open).first().getAttribute('href').catch(() => null)

package/src/start-repo.ts

@@ -13,19 +13,24 @@ import { join } from 'path'
 import { ensureGitRepo, ensureIgnoreBaseline, firstGhLine, isScratch, publishRepo, runner, type Run } from './git-bootstrap.ts'
 import { initRepo } from './init-repo.ts'
 import { AGENT_LINE } from './checks/SK003-claude-md-shape.check.ts'
-import { scaffoldProject, TOOLCHAIN } from './scaffold/project-scaffold.ts'
+import { adoptHouse, scaffoldProject, TOOLCHAIN } from './scaffold/project-scaffold.ts'
 import { defaultHubPort } from './serve/hub-port.ts'
 
 /** the one template: `shipkit start <name>` is the only thing anyone types,
- *  and a repo without the corvion wiki in its context is not a started repo.
+ *  and a repo without the house wiki in its context is not a started repo.
  *  Base context first, the repo's own router last, so repo docs override.
  *  A public repo swaps line 1 for the gitignored `@./CLAUDE.local.md`,
  *  which is why that line satisfies the first include (SK003) */
+// sk-disable-next-line RV003 -- the start template writes the house include line itself
 export const HOUSE_INCLUDE = ['@~/dev/corvion/wiki/index.md', '@./agent/index.md']
 export const HOUSE_ALSO_OK = ['@./CLAUDE.local.md']
 /** the day-job checkout: never wired, never given an include */
+// sk-disable-next-line RV003 -- start refuses the day-job checkout by its name
 export const HOUSE_SKIP = ['monoloco']
 
+/** a repo shipkit never touches: no CLAUDE.md, no git, no scaffold, no push */
+export const isSkipped = (name: string, skip: readonly string[] = HOUSE_SKIP): boolean => skip.includes(name)
+
 /** where the first house line points, `~` resolved against `home` */
 export const housePath = (home: string): string => {
     const p = HOUSE_INCLUDE[0]!.replace(/^@/, '')
@@ -72,7 +77,7 @@ export async function startRepo(name: string, opts: StartOpts = {}): Promise<num
     const house = opts.include ?? (houseOnDisk ? HOUSE_INCLUDE : [])
     if (opts.include == null && !houseOnDisk) console.error(`skip: no house wiki at ${housePath(home)} — CLAUDE.md gets the agent route only, and no .claude/ policy files`)
     const alt = opts.alsoOk ?? HOUSE_ALSO_OK
-    const skipped = (opts.skip ?? HOUSE_SKIP).includes(name)
+    const skipped = isSkipped(name, opts.skip)
     if (skipped && house.length > 0) console.error(`skip: ${name} is include-exempt — CLAUDE.md untouched`)
     // start is the from-anywhere verb, and a STARTED repo comes out READY:
     // any dir with no commit history gets a minimal package.json, a first
@@ -146,6 +151,13 @@ export async function startRepo(name: string, opts: StartOpts = {}): Promise<num
                 else console.error(`WARN dependency install failed: ${firstGhLine(r.out)}`)
             }
         }
+        // a repo with history that a house adopts: its own files win, and the
+        // house half of the day-one shape lands beside them, so the include
+        // lines below route at an agent wiki that exists
+        if (wired && !startable && house.length > 0) {
+            try { adoptHouse(dir, { name, print }) }
+            catch (e) { console.error(`WARN could not seed the house files in ${dir}: ${e instanceof Error ? e.message : String(e)} — the dir is still yours`) }
+        }
         let unscaffolded = false
         if (!existsSync(join(dir, 'repo.config.ts'))) {
             if (existsSync(join(dir, 'package.json'))) {

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 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 */
+    /** 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 own CPU inside the parallel run, children included, is inside that CPU allowance skips that run, unless its wall is past the wait allowance or it ended with a child not yet reaped. What earlier suites of its worker burned is never charged to it. 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[]
@@ -41,7 +41,8 @@ export const DEFAULT_BUDGET_MS = 2000
  *  5s default while the preload said otherwise. */
 export const FULL_TIMEOUT_MS = 120_000
 /** the wall ceiling of one `bun test` phase. bun's per test timeout never
- *  fires on a worker stuck in a SYNCHRONOUS call, and bun's spawnSync has been
+ *  fires on a worker stuck in a SYNCHRONOUS call, or in `expect(p).resolves`
+ *  or `.rejects` on a promise that never settles, and bun's spawnSync has been
  *  seen spinning on a child that already exited (planPhases avoids the known
  *  trigger), so without this a hang lasts until something outside kills it. The quick
  *  tier answers in seconds, so two minutes is far from any real run. */
@@ -55,6 +56,10 @@ const OWN_FLAGS = ['--budget-ms', '--slow', '--serial', '--declared-in', '--ceil
 
 export const normSuitePath = (file: string): string => posix.normalize(file.replace(/\\/g, '/')).replace(/^\.\//, '')
 
+/** bun never discovers a file under a dot dir (`.shipkit/repros/` relies on
+ *  it), so neither does the gate */
+export const inDotDir = (file: string): boolean => normSuitePath(file).split('/').slice(0, -1).some((d) => d.startsWith('.') && d !== '.' && d !== '..')
+
 /** the arguments after `bun test`, or null when a shell would interpret the script
  *  (cd, env prefix, pipes, quotes, substitution): that body stays the repo's own */
 export type BunfigTest = { root: string | null; ignores: string[]; error: string | null }
@@ -182,14 +187,16 @@ export function poolWorkers(p: { cores: number; size: number; held: number }): n
 
 type Timed = { file: string; ms: number }
 
-export function judgeSuites(p: { timings: Record<string, number>; tests: TestsConfig; tier: 'quick' | 'full' }): { over: Timed[]; noLongerSlow: Timed[]; slowest: Timed[] } {
+export function judgeSuites(p: { timings: Record<string, number>; tests: TestsConfig; tier: 'quick' | 'full'; red?: string[] }): { over: Timed[]; noLongerSlow: Timed[]; slowest: Timed[] } {
     const budget = p.tests.budgetMs ?? DEFAULT_BUDGET_MS
     const slow = new Set((p.tests.slow ?? []).map((s) => normSuitePath(s.file)))
+    const red = new Set((p.red ?? []).map(normSuitePath))
     const timed = Object.entries(p.timings).map(([file, ms]) => ({ file: normSuitePath(file), ms })).sort((a, b) => b.ms - a.ms)
     return {
         // the budget guards the tier every edit waits on. The full tier is
-        // where slow suites belong, and it only reports
-        over: p.tier === 'quick' ? timed.filter((t) => t.ms > budget && !slow.has(t.file)) : [],
+        // where slow suites belong, and it only reports. A red suite took
+        // the time of its failure (a timeout, a crash), which its red explains
+        over: p.tier === 'quick' ? timed.filter((t) => t.ms > budget && !slow.has(t.file) && !red.has(t.file)) : [],
         // half the budget, so a declaration does not flap on timing noise
         noLongerSlow: timed.filter((t) => slow.has(t.file) && t.ms < budget / 2),
         slowest: timed.slice(0, 3),
@@ -253,6 +260,20 @@ export function confirmOver(suspects: Timed[], alone: Record<string, AloneRun>,
     return { over: judged.filter((c) => c.over != null), cleared: judged.filter((c) => c.over == null) }
 }
 
+/** a lone run over the budget on CPU runs once more. Under load the
+ *  scheduler can spill a lone run onto the efficiency cores, where the same
+ *  retired instructions cost up to 4x the CPU time (measured on Apple
+ *  silicon), and a spill only ever raises the figure. A wait or a wall
+ *  verdict is not CPU, so it keeps its one run */
+export const retryAlone = (t: Timed, run: AloneRun, budgetMs: number, load: MachineLoad): boolean =>
+    confirmOver([t], { [t.file]: run }, budgetMs, load).over[0]?.over === 'cpu'
+
+/** the run charged less, as confirmOver charges it: the smaller of CPU and wall */
+export const smallerRun = (a: AloneRun, b: AloneRun): AloneRun => {
+    const charge = (r: AloneRun): number => Math.min(r.cpuMs ?? r.wallMs, r.wallMs)
+    return charge(b) < charge(a) ? b : a
+}
+
 const secs = (ms: number): string => `${(ms / 1000).toFixed(1)}s`
 
 /** the line a confirmed suite fails with */
@@ -265,49 +286,46 @@ export const overWords = (c: Confirmed, load: MachineLoad, budgetMs: number = DE
  *  (suite-cpu-preload.ts writes it, readPhaseCpu reads it) */
 export const SUITE_CPU_ENV = 'SHIPKIT_SUITE_CPU'
 
-/** one suite's figures from the parallel phase: its own CPU, children
- *  included, and all its worker burned before it began (suite-cpu-preload.ts
- *  says why the sum bounds a lone run) */
-export type PhaseCpu = { cpuMs: number; priorMs: number }
-
 /** what the workers wrote, keyed like the timings: relative to the run's cwd.
- *  `ran` is every suite that finished in the phase, `cpu` the ones whose
- *  figure can be trusted. A file bun ran twice keeps its larger bound, and
- *  none at all once one of its runs could not be trusted */
-export function readPhaseCpu(text: string, cwd: string): { ran: string[]; cpu: Record<string, PhaseCpu> } {
+ *  `ran` is every suite that finished in the phase, `cpu` the own CPU of the
+ *  ones whose figure can be trusted (suite-cpu-preload.ts). A file bun ran
+ *  twice keeps its larger figure, and none at all once one of its runs could
+ *  not be trusted */
+export function readPhaseCpu(text: string, cwd: string): { ran: string[]; cpu: Record<string, number> } {
     const ran = new Set<string>()
     const unsure = new Set<string>()
-    const cpu: Record<string, PhaseCpu> = {}
+    const cpu: Record<string, number> = {}
     const base = cwd.replace(/\\/g, '/')
     for (const line of text.split('\n')) {
-        const [file, ms, prior] = line.split('\t')
-        if (file == null || file === '' || ms == null || prior == null) continue
+        const [file, ms] = line.split('\t')
+        if (file == null || file === '' || ms == null) continue
         const rel = normSuitePath(posix.relative(base, file.replace(/\\/g, '/')))
-        if (ms === '-' && prior === '-') { ran.add(rel); unsure.add(rel); continue }
-        if (!/^\d+$/.test(ms) || !/^\d+$/.test(prior)) continue
+        if (ms === '-') { ran.add(rel); unsure.add(rel); continue }
+        if (!/^\d+$/.test(ms)) continue
         ran.add(rel)
-        const next = { cpuMs: Number(ms), priorMs: Number(prior) }
-        const had = cpu[rel]
-        if (had == null || next.cpuMs + next.priorMs > had.cpuMs + had.priorMs) cpu[rel] = next
+        cpu[rel] = Math.max(cpu[rel] ?? 0, Number(ms))
     }
     for (const f of unsure) delete cpu[f]
     return { ran: [...ran].sort(), cpu }
 }
 
-/** which suspects still need their alone run. A lone run can only need
- *  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 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[] } {
+/** which suspects still need their alone run. A suspect is judged on its OWN
+ *  CPU in the parallel phase, charged and allowed as a lone run is
+ *  (confirmOver): the load it suffered there only raised that figure, so one
+ *  inside the allowance is cleared. What the earlier files of its worker
+ *  burned is never its cost, a module they loaded or a memo they filled
+ *  included: the first suite of a worker that needs shared work pays for it.
+ *  A suspect with no figure (a child not yet reaped) or over its allowance
+ *  runs alone, and 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, number>, budgetMs: number, load: MachineLoad): { rerun: Timed[]; cleared: Confirmed[] } {
     const rerun: Timed[] = []
     const cleared: Confirmed[] = []
     for (const t of suspects) {
-        const f = parallelCpu[t.file]
+        const cpuMs = parallelCpu[t.file]
         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 })
+        const charged = cpuMs == null ? null : Math.min(cpuMs, t.ms)
+        if (charged != null && charged <= cpuAllowance(budgetMs, load) && !mayWait) cleared.push({ file: t.file, ms: charged, wallMs: t.ms, cpuMs: cpuMs ?? null, over: null })
         else rerun.push(t)
     }
     return { rerun, cleared }
@@ -358,6 +376,37 @@ export function failLines(output: string): Map<string, string> {
 
 const clip = (s: string): string => (s.length > 300 ? `${s.slice(0, 299)}…` : s)
 
+/** the clause the headline carries for the gate line: the command phase one
+ *  ran, and the flags the runner added to the script's own. Per file ignores
+ *  stay out, the slow and serial counts already say what they leave out */
+export function ranAs(phase: string[], rawArgs: string[]): string {
+    const shown = phase.filter((a) => !a.startsWith('--path-ignore-patterns'))
+    const added = shown.filter((a) => !rawArgs.includes(a))
+    return `as \`${['bun', 'test', ...shown].join(' ')}\`${added.length > 0 ? ` (added ${added.join(' ')})` : ''}`
+}
+
+/** the suites bun lists under `Interrupted while still running:` when a
+ *  phase is killed, one indented `<file> (<n>s)` line each */
+export function interruptedSuites(output: string): string[] {
+    const out: string[] = []
+    let inBlock = false
+    for (const line of output.split('\n')) {
+        if (/^Interrupted while still running:\s*$/.test(line)) { inBlock = true; continue }
+        if (!inBlock) continue
+        const m = /^\s+(\S+)\s+\(\d+(?:\.\d+)?m?s\)\s*$/.exec(line)
+        if (m == null) { inBlock = false; continue }
+        out.push(normSuitePath(m[1]!))
+    }
+    return out
+}
+
+/** the line a phase killed at its ceiling fails with. Measured on bun 1.4.3:
+ *  a plain await of a promise that never settles fails at the per test
+ *  timeout, while `expect(p).resolves` or `.rejects` on one blocks the worker
+ *  past it, as a synchronous loop does */
+export const stallWords = (name: string, ceilingMs: number, files: string[]): string =>
+    `${name} ran past its ${secs(ceilingMs)} ceiling and was killed${files.length > 0 ? ` with ${files.join(', ')} still running` : ''}: a test blocked its worker past the per test timeout, either a synchronous loop or expect(...).resolves or .rejects on a promise that never settles`
+
 /** the suites bun names as a crashed parallel worker */
 export function crashedWorkers(output: string): { file: string; signal: string }[] {
     return [...output.matchAll(/^\s*✗\s+(\S+)\s+\(worker crashed: (SIG[A-Z0-9]+)\)\s*$/gm)].map((m) => ({ file: normSuitePath(m[1]!), signal: m[2]! }))

package/src/suite/select.ts

@@ -31,6 +31,7 @@ import { blobOid, listingHash } from '../core/read-set.ts'
 import { shipkitRoot } from '../ledger/db.ts'
 import { extractSpecs, resolveSpec } from '../ts/source-graph.ts'
 import { type RvtConfig } from '../ts/config.ts'
+import { inDotDir } from './judge-suites.ts'
 
 export const SELECT_VERSION = 5
 
@@ -489,6 +490,7 @@ export function suiteFiles(top: string, cwdRel: string, testRoot: string | null,
     for (const f of listed) {
         if (f === '' || !isTest(f) || !existsSync(join(top, f))) continue
         const rel = cwdRel === '' || cwdRel === '.' ? f : f.slice(cwdRel.length + 1)
+        if (inDotDir(rel)) continue
         if (res.some((re) => re.test(rel))) continue
         out.push(rel)
     }