rvlib-shipkit 1.9.0 → 2.0.0

package/src/scaffold/project-scaffold.ts

@@ -10,10 +10,9 @@
 // package.json rewrite reformats the file it edits.
 // Templates live beside this file in files/ and ship in the npm tarball, so
 // none of them may name a machine-local tool or a private path.
-import { existsSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
 import { dirname, join } from 'path'
 import { defaultHubPort } from '../serve/hub-port.ts'
-import { hubProblemMatcher } from '../problems/problem-line.ts'
 
 const FILES = join(import.meta.dir, 'files')
 
@@ -36,15 +35,14 @@ export type ScaffoldOpts = {
     claudePolicy?: boolean
 }
 
-/** every dep the house toolchain needs for the scripts below to run */
-export const TOOLCHAIN = ['typescript', 'oxlint', 'oxfmt', '@types/bun'] as const
+/** every dep the house toolchain needs for the scripts below to run. The
+ *  linter and the formatter are bun's own, declared in bunfig.toml */
+export const TOOLCHAIN = ['typescript', '@types/bun'] as const
 
 /** script bodies for a fresh repo whose only source dir is src/. A stack
- *  scaffold (vite, hono) adds dev/build on top; these three are the floor
- *  rule SK001 asks every repo for */
+ *  scaffold (vite, hono) adds dev/build on top. No `lint` or `fmt`: a script
+ *  of either name would shadow `bun lint` and `bun fmt` */
 const SCRIPTS: Record<string, string> = {
-    lint: 'oxlint src/',
-    fmt: 'oxfmt src/',
     typecheck: 'tsc --noEmit',
 }
 
@@ -104,64 +102,12 @@ function put(root: string, rel: string, body: string): boolean {
     return true
 }
 
-export type ErgonomicsOpts = {
-    /** repo name, substituted into the templates */
-    name: string
-    /** the port the hub actually listens on, resolved by the caller from the
-     *  repo config (`serve.port`, else the name-derived default), so the task
-     *  advertises a url something answers on */
-    port: number
-}
-
-/** the folder-open story, and the ONE file of it a repo shipkit did not create
- *  can be handed unasked.
- *
- *  What lands is `tasks.json` alone. `settings.json` turns eslint off and hands
- *  formatting to an oxc extension, so writing it into a repo that lints with
- *  eslint silences the linter that repo chose: that is an answer about what the
- *  repo IS, and a repo with a history of its own already gave it. A tasks file
- *  is the opposite: with no `folderOpen` task nothing starts at all, so there
- *  is no existing answer to overrule.
- *
- *  What lands INSIDE it is only what is true of every wired repo: the hub,
- *  whose script `init` writes, carrying the problem matcher that turns every
- *  check's findings into the problems pane. There is no type checker task, the
- *  hub runs `typecheck` like any other check. Every watcher a stack earns (a
- *  dev server, css) stays the analysis step `build/vscode-tasks.md` describes,
- *  and the caller says so out loud.
- *
- *  Create-only: an adopted repo often carries a `.vscode/` from whatever it was
- *  forked from, and that one wins byte for byte (rule SK017 then repairs its
- *  hub task in place). Returns the paths it wrote. */
-export function editorErgonomics(root: string, opts: ErgonomicsOpts): string[] {
-    // a symlinked .vscode is a dotfiles pattern pointing at a SHARED dir, and
-    // writing through it lands files outside the repo being wired
-    if (isLink(join(root, '.vscode'))) return []
-    const body = tasksTemplate({ NAME: opts.name, PORT: String(opts.port) })
-    return put(root, '.vscode/tasks.json', body) ? ['.vscode/tasks.json'] : []
-}
-
-const isLink = (path: string): boolean => {
-    try {
-        return lstatSync(path).isSymbolicLink()
-    } catch {
-        return false
-    }
-}
-
-/** the tasks template, the hub's problem matcher rendered in from the one
- *  module the hub prints through, so the two can never disagree */
-export function tasksTemplate(vars: Record<string, string>): string {
-    return template('vscode-tasks.json', vars).replace(/^(\s*)(.*)\{\{HUB_PROBLEM_MATCHER\}\}/m, (_all, indent: string, head: string) =>
-        `${indent}${head}${JSON.stringify(hubProblemMatcher(), null, 3).split('\n').join(`\n${indent}`)}`)
-}
-
 export function scaffoldProject(root: string, opts: ScaffoldOpts): string[] {
     const p = opts.print ?? console.log
     // the hub resolves its port from repo.config, whose name `init` takes from
     // the CALLER first and the manifest only after (init-repo.ts repoName). A
-    // dir that arrived holding a forked package.json would otherwise get a
-    // tasks.json advertising a port nothing listens on, so the caller that
+    // dir that arrived holding a forked package.json would otherwise get an
+    // agent index advertising a port nothing listens on, so the caller that
     // knows the name it is about to wire passes the port it resolves
     const port = opts.port ?? defaultHubPort(packageName(root) ?? opts.name)
     const vars = {
@@ -175,15 +121,32 @@ export function scaffoldProject(root: string, opts: ScaffoldOpts): string[] {
 
     write('src/index.ts', 'export {}\n')
     write('tsconfig.json', template('tsconfig.json', vars))
-    ;(editorErgonomics(root, { name: opts.name, port }).length > 0 ? written : skipped).push('.vscode/tasks.json')
-    // settings.json only here: it turns eslint off and hands formatting to an
-    // oxc extension, which is a decision only the repo's creator gets to make
+    write('bunfig.toml', template('bunfig.toml', vars))
+    // settings.json only here: it turns eslint off and keeps tsserver from
+    // formatting, which is a decision only the repo's creator gets to make
     write('.vscode/settings.json', template('vscode-settings.json', vars))
     write('.claude/skills/verify/SKILL.md', template('verify-skill.md', vars))
+    writeHouseFiles(write, vars, opts.claudePolicy === true, written, p)
+
+    addScripts(root, written, p)
+    addIgnoreLines(root, written)
+
+    if (written.length > 0) p(`ok: scaffolded ${written.length} file(s): ${written.slice(0, 6).join(', ')}${written.length > 6 ? `, +${written.length - 6} more` : ''}`)
+    // the skips are the interesting half on a half-built dir: a pre-existing
+    // .claude/settings.json means no attribution silencer, and that one only
+    // counts from the first commit on
+    if (skipped.length > 0) p(`skip: ${skipped.length} file(s) already present, left untouched: ${skipped.join(', ')}`)
+    return written
+}
+
+/** the half of the day-one shape a house brings, whatever the repo already
+ *  is: the agent wiki its CLAUDE.md routes at, the reflections folder, and
+ *  for a caller that declared a house the .claude/ policy files. Create-only */
+function writeHouseFiles(write: (rel: string, body: string) => void, vars: Record<string, string>, claudePolicy: boolean, written: string[], p: (line: string) => void): void {
     // a permission grant and a git-history policy are decisions about someone
     // else's repo, so they land only for a caller that declared a house, and
     // the grant is named out loud the one time it is written
-    if (opts.claudePolicy === true) {
+    if (claudePolicy) {
         write('.claude/settings.json', template('claude-settings.json', vars))
         write('.claude/settings.local.json', template('claude-settings-local.json', vars))
         if (written.includes('.claude/settings.local.json')) p(`ok: .claude/ policy written — agents are pre-approved for ${grantSummary()} in this repo, and the harness writes no attribution trailer`)
@@ -197,15 +160,18 @@ export function scaffoldProject(root: string, opts: ScaffoldOpts): string[] {
     // gitignored by policy, so it never ships: it exists so an agent hitting
     // friction with the toolchain finds the place to write it down
     write('.shipkit/reflections/README.md', REFLECTIONS_README)
+}
 
-    addScripts(root, written, p)
-    addIgnoreLines(root, written)
-
-    if (written.length > 0) p(`ok: scaffolded ${written.length} file(s): ${written.slice(0, 6).join(', ')}${written.length > 6 ? `, +${written.length - 6} more` : ''}`)
-    // the skips are the interesting half on a half-built dir: a pre-existing
-    // .claude/settings.json means no attribution silencer, and that one only
-    // counts from the first commit on
-    if (skipped.length > 0) p(`skip: ${skipped.length} file(s) already present, left untouched: ${skipped.join(', ')}`)
+/** an ADOPTED repo (one with history) whose start declares a house: the
+ *  include lines pull it into the house contract, so it gets the house half
+ *  of the day-one shape and nothing that says what the repo IS. Create-only,
+ *  so every file the repo already holds wins. Returns the paths it wrote */
+export function adoptHouse(root: string, opts: { name: string; today?: string; print?: (line: string) => void }): string[] {
+    const p = opts.print ?? console.log
+    const vars = { NAME: opts.name, PORT: String(defaultHubPort(opts.name)), DATE: opts.today ?? new Date().toISOString().slice(0, 10) }
+    const written: string[] = []
+    writeHouseFiles((rel, body) => { if (put(root, rel, body)) written.push(rel) }, vars, true, written, p)
+    if (written.length > 0) p(`ok: adopted into the house, ${written.length} file(s) seeded: ${written.join(', ')}`)
     return written
 }
 
@@ -227,14 +193,14 @@ What broke, which page or lib, what you expected. Gitignored on purpose,
 transient by design: it is harvested, then deleted.
 `
 
-/** the three baseline scripts, added only where the key is free */
+/** the baseline scripts, added only where the key is free */
 function addScripts(root: string, written: string[], p: (line: string) => void): void {
     const path = join(root, 'package.json')
-    if (!existsSync(path)) return void p('WARN no package.json here — the lint/fmt/typecheck scripts were not written')
+    if (!existsSync(path)) return void p('WARN no package.json here — the typecheck script was not written')
     const raw = readFileSync(path, 'utf8')
     let pkg: { scripts?: Record<string, string> }
     try { pkg = JSON.parse(raw) as { scripts?: Record<string, string> } }
-    catch (e) { return void p(`WARN package.json is unparseable (${String(e).slice(0, 80)}) — the lint/fmt/typecheck scripts were not written, repair it then re-run`) }
+    catch (e) { return void p(`WARN package.json is unparseable (${String(e).slice(0, 80)}) — the typecheck script was not written, repair it then re-run`) }
     pkg.scripts ??= {}
     let added = 0
     for (const [k, v] of Object.entries(SCRIPTS)) if (pkg.scripts[k] == null) { pkg.scripts[k] = v; added++ }

package/src/serve/hub-app/check-view.tsx

@@ -13,7 +13,6 @@ import type { RepoSt } from './repo-st.ts'
 import type { SlowSuite, CheckFacts, RecentRun } from './hub-types.ts'
 import { renderMd, renderMdInline } from './md.ts'
 import { nextRun } from './next-run.ts'
-import { ProseHits } from './prose-hits-view.tsx'
 import { stampWords, TimeAgo, TimeAhead } from './time-ago.tsx'
 import { checkName, commandOf, docPath, editorHref, lastRun, rememberedFact, repoPath, whatFacts, type ShortPath } from './check-words.ts'
 
@@ -23,8 +22,9 @@ const SOURCE_CHIP: Record<CheckFacts['whenSource'], string> = {
     off: 'repo.config.ts',
     when: 'when (retired)',
     ruleExempt: 'ruleExempt (retired)',
+    'hooks.disable': 'hooks.disable (retired)',
     'check-file': 'the check file',
-    defaults: 'defaults',
+    defaults: 'defaults (retired)',
     default: 'derived',
 }
 
@@ -33,7 +33,8 @@ const SOURCE_WORD: Record<CheckFacts['whenSource'], string> = {
     when: 'turned off by the retired `when` key, which `shipkit ci` ports to `off` (SK029)',
     ruleExempt: 'turned off by the retired `ruleExempt` key, which `shipkit ci` ports to `off` (SK029)',
     'check-file': 'declared by the check file itself: every context it runs in, no default',
-    defaults: 'from the `defaults` block, which removes the floor slot entirely',
+    'hooks.disable': 'turned off by the retired `hooks.disable` key, which `shipkit ci` ports to `off` (SK029)',
+    defaults: 'turned off by the retired `defaults: { <slot>: false }`, which `shipkit ci` ports to `off` (SK029)',
     default: 'a row with no file of its own: the code that derives it writes every context',
 }
 
@@ -359,7 +360,6 @@ export const CheckCard = observer(({ app, id }: { app: RepoSt; id: string }) =>
             </div>
             <WhereItRuns app={app} u={u} />
             {u.build && u.checkId === 'test' ? <SlowSuites app={app} /> : null}
-            {u.checkId === 'SK014' ? <ProseHits app={app} /> : null}
             <LastOutput app={app} lines={u.lastLines} />
         </div>
     )

package/src/serve/hub-app/check-words.ts

@@ -19,6 +19,7 @@ const CADENCE: Record<WhenAt, string> = {
     always: 'on every run',
     release: 'on every release run',
     health: 'each time the plan runs it',
+    commit: 'on every commit, in a git hook',
     off: 'nowhere, it is off',
 }
 

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

@@ -100,8 +100,7 @@ export class ChecksSvc {
         }
     }
 
-    /** ONE write path for the switch, the slow suite form and the prose word
-     *  lists alike: it edits repo.config.ts in place and leaves it dirty to be
+    /** ONE write path for the switch and the slow suite form alike: it edits repo.config.ts in place and leaves it dirty to be
      *  reviewed. Resolves true when the server took the edit */
     async writeGate(edit: Record<string, unknown>, said: string): Promise<boolean> {
         if (this.gateBusy) return false

package/src/serve/hub-app/home.html

@@ -6,7 +6,6 @@
   <title>home</title>
   <link rel="stylesheet" href="./hub.css" />
   <link rel="stylesheet" href="./project-list.css" />
-  <link rel="stylesheet" href="./prose-hits.css" />
   <link rel="stylesheet" href="./home-strip.css" />
   <link rel="stylesheet" href="./planned.css" />
   <link rel="stylesheet" href="./when.css" />

package/src/serve/hub-app/hub-types.ts

@@ -145,8 +145,6 @@ export type GateBlock = {
     tests: { budgetMs?: number; slow?: SlowSuite[]; serial?: { file: string; why: string }[] }
     declaredOutside: boolean
     dirty: boolean
-    /** the prose words block inside `prose: {` (core/when-block.ts) */
-    wordsState?: 'missing-file' | 'missing-block' | 'stale' | 'current' | 'no-prose'
 }
 
 /** one check finishing, as the run stream sends it */

package/src/serve/hub-app/index.html

@@ -6,7 +6,6 @@
   <title>hub</title>
   <link rel="stylesheet" href="./hub.css" />
   <link rel="stylesheet" href="./project-list.css" />
-  <link rel="stylesheet" href="./prose-hits.css" />
   <link rel="stylesheet" href="./home-strip.css" />
   <link rel="stylesheet" href="./planned.css" />
   <link rel="stylesheet" href="./when.css" />

package/src/serve/hub-app/project-list.css

@@ -1,5 +1,4 @@
-/* the project list, the page's left panel. Its classes are pj*: another
-   sheet of the page already styles .plist (prose-hits.css). It fills its
+/* the project list, the page's left panel. Its classes are pj*. It fills its
    panel (hub-app.tsx, react-resizable-panels), whose width is the only one:
    this sheet sizes the rows and never the list. Colours are hub.css tokens only, spacing is its scale:
    tests/hub-css-invariants.test.ts reads this sheet too. Every icon is 18px

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'
@@ -391,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/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/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[]
@@ -56,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 }
@@ -282,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 }

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)
     }

package/src/suite/suite-cli.ts

@@ -57,7 +57,10 @@ async function runPhase(args: string[], timingsFile: string | null, ceilingMs: n
             if (echo) sink.write(text)
         }
     }
-    await Promise.all([pump(proc.stdout, process.stdout), pump(proc.stderr, process.stderr)])
+    // bun reports on stderr, and it is echoed on stdout: two pipes reach the
+    // gate in either order, so bun's `Ran 0 tests` could land after the FAIL
+    // printed below and become the headline. One stream keeps the order
+    await Promise.all([pump(proc.stdout, process.stdout), pump(proc.stderr, process.stdout)])
     const code = await proc.exited
     clearTimeout(ceiling)
     clearTimeout(killer)
@@ -224,7 +227,7 @@ async function runSuites(argv: string[], ctx: SelectCtx): Promise<number> {
         }
         const aloneMs = Date.now() - aloneAt
         const { over, cleared } = rerun.length > 0 ? confirmOver(rerun, aloneRuns, budget, load) : { over: [], cleared: [] }
-        for (const c of clearedInPhase) notes.push(`note: ${c.file} took ${secs(c.wallMs)} in the parallel run and burned ${secs(c.cpuMs ?? 0)} of CPU there, plus ${secs(parallelCpu[c.file]?.priorMs ?? 0)} a lone run loads first, inside the ${budget}ms budget, so it did not run again alone`)
+        for (const c of clearedInPhase) notes.push(`note: ${c.file} took ${secs(c.wallMs)} in the parallel run but burned ${secs(c.ms)} of its own CPU there, inside the ${budget}ms budget (load ${load.load1.toFixed(1)} on ${load.cores} cores), so it did not run again alone`)
         for (const c of cleared) notes.push(`note: ${c.file} took ${secs(c.wallMs)} alone but burned ${c.cpuMs != null ? secs(c.cpuMs) : '?'} of CPU, inside the ${budget}ms budget (load ${load.load1.toFixed(1)} on ${load.cores} cores)`)
 
         // a ceiling kill makes bun report every worker it held as crashed, and
@@ -254,7 +257,7 @@ async function runSuites(argv: string[], ctx: SelectCtx): Promise<number> {
         // rerun, the parallel phase's own figure, or a phase that ran that one file
         const phaseOf = (f: string): SuitePhase => (p2 != null && Object.keys(p2.timings).some((k) => normSuitePath(k) === f) ? 'serial' : parallel ? 'parallel' : 'sequential')
         const soloCpu = (p: Phase | null): number | null => (p != null && Object.keys(p.timings).length === 1 ? p.cpuMs : null)
-        const cpuOf = (f: string): number | null => aloneRuns[f]?.cpuMs ?? (phaseOf(f) === 'serial' ? soloCpu(p2) : parallelCpu[f]?.cpuMs ?? soloCpu(p1))
+        const cpuOf = (f: string): number | null => aloneRuns[f]?.cpuMs ?? (phaseOf(f) === 'serial' ? soloCpu(p2) : parallelCpu[f] ?? soloCpu(p1))
         const check = process.env[CHECK_ID_ENV] ?? ''
         const serialFiles = p2 == null ? 0 : Object.keys(p2.timings).length
         const unrecorded = recordSuites(process.cwd(), Object.entries(timings).map(([file, ms]) => {