rvlib-shipkit 1.8.0 → 1.9.0

package/CHANGELOG.md

@@ -1,3 +1,35 @@
+## 1.9.0
+
+- **A commit in a linked worktree passes the pre-commit hook.** git sets GIT_DIR for a hook there, and the installed copy then asked git where the house sits and got the worktree back, so it never handed off to the house source. Then it ran itself and failed every built-in check with ENOENT on a `?v=` stamped path. A directory with its own `.git` is now asked with the locating variables stripped, and an installed copy that runs itself (CI, `SHIPKIT_NO_HOME`) loads its own check files.
+- **A broken built-in check no longer aborts every repo's gate.** In a repo that only consumes the toolkit, a built-in that does not load or is refused is one non-blocking WARN that names the file. The repo that hosts the toolkit source still fails on it. Before, it threw a misleading "names the page that OWNS the invariant" error before any check ran.
+- **`sk gp open <id>` probes before it trusts "up".** A process that died since pm last looked now starts before its window opens, instead of a window on a dead port.
+- **A linked worktree of a house repo is no longer a house repo of its own.** The home, the global context and pm skip a sibling whose `.git` is a file, so its global processes no longer collide with the main checkout's ids and ports.
+- **`sk ci --only <check>` leaves the tree alone.** A narrowed run no longer runs the fix pass unless `--fix` is named, so `bun run test`, `lint` and `typecheck`, which route through `--only`, never reformat a shared tree. Before, the formatter ran on every narrowed run and rewrote 478 files of one checkout, other agents' uncommitted work included. A whole gate still repairs first, and `--no-fix` still turns it off.
+
+- **The machine pool admits fewer checks on a loaded machine.** A slot is a check, and a check is often a whole multi core tool, so eight slots on eight cores could put several times the cores to work. Past a 1 minute load of one per core the pool now admits slots in proportion to the load, never fewer than one: at load 20 on 8 cores it admits 3 of 8. A slot already held is never taken back. A waiting check prints the load and what the pool admits.
+
+- **The plan holds save runs while someone gates the repo.** A check a save moved now also waits 10 minutes after the latest run a terminal, an agent or a click started in its repo. On one repo with several agents, most of the plan's test runs had started within those 10 minutes and measured a tree the agents were gating themselves. The run is held, not dropped, so the tree still gets one verdict once they stop. `sk planned` shows the hold as a `deferred:` line.
+- **A suite over the CPU budget in its lone run runs alone once more, and the smaller figure stands.** On a busy Apple silicon machine the scheduler can spill a lone run onto the efficiency cores, where the same work burns up to 4x the CPU time, so a suite inside its budget failed one run in three and passed a minute later. A spill only raises CPU time, so the second run can clear a false red and never hide a real one. A wait or a suite with no CPU figure keeps its one run, and a green gate pays nothing.
+
+- **The gate's test line says the command the suite runner ran.** A plain `bun test` body does not run as written under `sk ci`: the runner adds `--parallel=<n>` and `--no-isolate`. The line now reads `ok: test 412 tests (ran 1.5s) as \`bun test --parallel=7 --no-isolate\` (added --parallel=7 --no-isolate)`, so a reader of package.json knows that `bun run test` outside the gate runs another way. Per file ignores stay out of it.
+
+- **A test phase killed at its ceiling names the suite that hung, and both things that hang a worker.** bun lists the suites still running when a phase is killed, and the parallel phase now reads that list, so the line says `with tests/x.test.ts still running`. It names a synchronous loop and `expect(p).resolves` or `.rejects` on a promise that never settles: bun's per test timeout stops neither, while a plain `await` of such a promise fails at the per test timeout. And a red suite is no longer judged on time: its time is its failure's, so a test that timed out no longer runs again alone and no longer adds a budget FAIL.
+- **The gate typecheck keeps its own incremental cache, and a release can publish with bun.** The built-in typecheck passes `--incremental --tsBuildInfoFile <project dir>/node_modules/.cache/shipkit/<config>.tsbuildinfo` for every project, so a `tsc --watch` task or a raw script on the same tsconfig no longer writes the cache the gate reads. A config without `incremental` gets it too: rvlib-shipkit's own typecheck went from 0.81 s to 0.35 s warm. `release.publisher: 'bun'` makes `sk release` and `sk bump` run `bun publish --access public`, with the token from `release.npmTokenCommand` in `NPM_CONFIG_TOKEN`, for a repo that tests its tarball with `bun pm pack`. The default stays npm, and an unknown publisher fails `defineRepo`.
+
+- **`alert`, `confirm` and `prompt` work in the shipkit app and in every process app.** The app window answered each one at once with no panel: `confirm` returned false and `prompt` null, so a page button behind one did nothing. Each now shows as a sheet on its window. The prompt's text field holds the default text, selected. Return is OK and Esc is Cancel. An app picks it up the next time `sk gui` or `sk gp open <id> --app` opens it, because a changed source rebuilds the app and quits the running copy.
+
+- **The `prompt` and `seed` vars contract binds only the workflows a kit kind drives.** Loading the workflows folder no longer refuses a module that lacks them, so a workflow the repo drives with its own tools (portraits, voice, music) names its vars freely. The check runs when the atelier resolves the workflow for a kind, and the error names that kind.
+
+- **`sk assets gen` works on a repo whose comfy-ts is newer than shipkit's.** The one comfy-ts instance of the process is now created through the copy the repo's workflow modules import, so a module gets the vars builder of its own version. Before, shipkit's older copy rooted it, and a module using a newer var kind failed every roll (`v.model is not a function`).
+
+- **The og card draws accented names.** The default card names a font family list (Helvetica, Arial, DejaVu Sans, Liberation Sans, Noto Sans, then sans-serif). The generic sans-serif alone resolved on macOS to a face with no Latin-1 accents, so a French name rendered with a missing glyph box.
+
+- **`sk smoke` serves canvas apps: a route takes `minChars`**, the visible text a settled route needs (default 40). A game that draws into one canvas declares `{ path: '/', waitFor: 'canvas', minChars: 0 }`, and a missing canvas still fails the route.
+
+- **`serve: { assets: false }` hides the asset kit from the hub page and from `sk needs`**, for a repo whose own tool mounts `studioRoutes` and owns the picking. Workflows and posts stay.
+
+- **`defineKit({ rollFormat: 'webp-lossless' })` stores new image rolls as lossless webp**, the same pixels at about 60 percent of the png bytes, encoded with sharp. Existing png rolls stay readable beside them.
+
 ## 1.8.0
 
 - **The quick tier can run only the suites a change reaches** (opt in: `tests: { select: true }`, or `SHIPKIT_TEST_SELECT=1` for one run). It keeps the snapshot of the last run and its red suites, and runs those plus every suite whose import closure, or whose recorded runtime reads, a change since then reaches. What it cannot see it runs: an unclaimed change under a code root, a spawn it does not know, a module that threw while loading, a run config file. The full tier still runs every suite.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rvlib-shipkit",
-    "version": "1.8.0",
+    "version": "1.9.0",
     "funding": "https://github.com/sponsors/rvion",
     "description": "All-in-one repo companion: ci gate (task DAG), auto-discovered health checks, release-contract fulfillness, asks queue, md-wiki tools, asset atelier, live tui",
     "license": "MIT",

package/src/assets/gen/comfyts-gen.ts

@@ -40,6 +40,19 @@ const varsOf = (wf: DefinedWorkflow): Record<string, AnyVar> => wf.vars as Recor
 export const isRollImage = (img: Pick<MediaImage, 'ComfyNode'>): boolean =>
     !/preview/i.test(img.ComfyNode?.class_type ?? '')
 
+/** the ComfyTS class of the comfy-ts a bare import from `dir` reaches,
+ *  shipkit's own when the repo carries none */
+async function comfyTsOf(dir: string): Promise<typeof ComfyTS> {
+    let path: string
+    try {
+        path = Bun.resolveSync('comfy-ts', dir)
+    } catch {
+        return ComfyTS
+    }
+    const mod = (await import(path)) as { ComfyTS?: typeof ComfyTS }
+    return typeof mod.ComfyTS?.create === 'function' ? mod.ComfyTS : ComfyTS
+}
+
 /** dir = the flat folder holding the <id>.cflow.ts workflow modules.
  *  root pins `.comfy-ts/` (drafts, hosts cache) to the repo, cwd-independent. */
 export async function loadCflowWorkflows(root: string, dir: string): Promise<Map<string, LoadedWorkflow>> {
@@ -51,9 +64,12 @@ export async function loadCflowWorkflows(root: string, dir: string): Promise<Map
     // module then returns this same instance. comfy-ts keeps ONE instance per
     // process, and the daemon serves every repo from one process, so only the
     // first repo roots it. What it roots is the host caches, shared by every
-    // repo on the same host; each repo's drafts resolve from its own root
-    if ((globalThis as { comfyts?: unknown }).comfyts == null) ComfyTS.create({ rootPath: root })
+    // repo on the same host; each repo's drafts resolve from its own root.
+    // The instance is created through the copy the modules import, never
+    // shipkit's own: a host hands its vars builder to defineWorkflow, so an
+    // older copy gives a newer module a v without its newer var kinds
     if (!existsSync(dir)) fail(`${dir}/ missing — ship at least one <id>.cflow.ts comfy-ts workflow module (copy from the rv-comfy template)`)
+    if ((globalThis as { comfyts?: unknown }).comfyts == null) (await comfyTsOf(dir)).create({ rootPath: root })
     const out = new Map<string, LoadedWorkflow>()
     for (const f of readdirSync(dir).filter((x) => x.endsWith('.cflow.ts')).sort()) {
         const file = join(dir, f)
@@ -65,24 +81,25 @@ export async function loadCflowWorkflows(root: string, dir: string): Promise<Map
         // so letting them diverge would strand every per-asset draft
         if (wf.spec.id != null && wf.spec.id !== id) fail(`workflow file '${f}' declares id '${wf.spec.id}' — the file name IS the id, rename one`)
         wf.spec.id ??= id
-        const vars = varsOf(wf)
-        if (vars.prompt?.kind !== 'prompt' || vars.seed?.kind !== 'seed')
-            fail(`workflow '${id}' must declare vars.prompt (v.prompt) and vars.seed (v.seed) — shipkit drives both`)
         out.set(id, { id, root, file, wf })
     }
     if (out.size === 0) fail(`${dir}/ has no *.cflow.ts workflow modules — seed one from the rv-comfy template`)
     return out
 }
 
-/** Resolve a workflow: explicit id, else the sole loaded workflow. */
-export function workflowFor(workflows: Map<string, LoadedWorkflow>, ref: { workflow?: string; assetId?: string }): LoadedWorkflow {
-    if (ref.workflow != null) {
-        const lw = workflows.get(ref.workflow)
-        if (lw == null) fail(`asset '${ref.assetId ?? '?'}': unknown workflow '${ref.workflow}' (have: ${[...workflows.keys()].join(', ')})`)
-        return lw
-    }
-    if (workflows.size === 1) return [...workflows.values()][0]!
-    return fail(`asset '${ref.assetId ?? '?'}' names no workflow and ${workflows.size} are loaded (${[...workflows.keys()].join(', ')}) — set workflow on the kind`)
+/** Resolve the workflow a kit kind drives: explicit id, else the sole loaded
+ *  workflow. The atelier writes prompt and seed, so the contract binds here,
+ *  never at folder load: a workflow no kind drives names its vars freely. */
+export function workflowFor(workflows: Map<string, LoadedWorkflow>, ref: { workflow?: string; kind?: string; assetId?: string }): LoadedWorkflow {
+    const lw = ref.workflow != null
+        ? (workflows.get(ref.workflow) ?? fail(`asset '${ref.assetId ?? '?'}': unknown workflow '${ref.workflow}' (have: ${[...workflows.keys()].join(', ')})`))
+        : workflows.size === 1
+          ? [...workflows.values()][0]!
+          : fail(`asset '${ref.assetId ?? '?'}' names no workflow and ${workflows.size} are loaded (${[...workflows.keys()].join(', ')}) — set workflow on the kind`)
+    const vars = varsOf(lw.wf)
+    if (vars.prompt?.kind !== 'prompt' || vars.seed?.kind !== 'seed')
+        fail(`kind '${ref.kind ?? '?'}' drives workflow '${lw.id}', which must declare vars.prompt (v.prompt) and vars.seed (v.seed) — the atelier writes both`)
+    return lw
 }
 
 /** Apply a name→value record onto a workflow's vars: strings go through

package/src/assets/gen/generate-roll.ts

@@ -4,9 +4,9 @@
 // in both (before this, canvas draw lived only in the studio and the CLI
 // refused canvas kinds — A30). Comfy context is resolved LAZILY: canvas-only
 // kits never touch a comfy config or the box.
-import { mkdirSync } from 'fs'
+import { mkdirSync, unlinkSync } from 'fs'
 import { join } from 'path'
-import type { FoundAsset } from '../kit-config.ts'
+import type { FoundAsset, RollFormat } from '../kit-config.ts'
 import { generateComfyTs, loadCflowWorkflows, workflowFor, type ComfyTsRuntime, type OnProgress } from './comfyts-gen.ts'
 import { recordParents, type ParentContext } from './derived.ts'
 import { generateGemini } from './gemini-gen.ts'
@@ -16,11 +16,22 @@ export const CANVAS_SIZE = 1024
 
 export type ComfyResolver = () => Promise<ComfyTsRuntime>
 
+/** re-encode freshly written png rolls in the kit's roll format, before any
+ *  sidecar names them. `exact` keeps the colour under transparent pixels */
+async function encodeRolls(saved: string[], format: RollFormat | undefined): Promise<void> {
+    if (format !== 'webp-lossless') return
+    const { default: sharp } = await import('sharp')
+    for (const png of saved.filter((p) => p.endsWith('.png'))) {
+        await sharp(png).webp({ lossless: true, exact: true }).toFile(png.replace(/\.png$/, '.webp'))
+        unlinkSync(png)
+    }
+}
+
 /** Draw/generate one roll for `found` into destDir as v<seed>.png (canvas) or
  *  v<seed>.<ext> (comfy). `resolveComfy` is only awaited for comfy backends. */
 export async function generateRoll(
     found: FoundAsset,
-    args: { prompt: string; seed: number; destDir: string; onProgress?: OnProgress; context?: ParentContext },
+    args: { prompt: string; seed: number; destDir: string; onProgress?: OnProgress; context?: ParentContext; rollFormat?: RollFormat },
     resolveComfy: ComfyResolver,
 ): Promise<void> {
     const gen = found.kind.generate
@@ -31,7 +42,7 @@ export async function generateRoll(
         // resolves them (queue/CLI) so a blocker names the parent, loud
         if ((found.asset.from?.length ?? 0) > 0 && args.context == null)
             throw new Error(`'${found.asset.id}' derives from ${found.asset.from!.join(', ')} — parent context missing (are the parents picked?)`)
-        await generateGemini({}, { prompt: args.prompt, model: gen.model, destDir: args.destDir, name: `v${args.seed}`, context: args.context?.images ?? [] })
+        await encodeRolls(await generateGemini({}, { prompt: args.prompt, model: gen.model, destDir: args.destDir, name: `v${args.seed}`, context: args.context?.images ?? [] }), args.rollFormat)
         if (args.context != null) await recordParents(args.destDir, args.seed, args.context.parents)
         return
     }
@@ -40,12 +51,14 @@ export async function generateRoll(
         const c = createCanvas(CANVAS_SIZE, CANVAS_SIZE)
         await gen.draw(c.getContext('2d'), { ...found.asset, prompt: args.prompt })
         mkdirSync(args.destDir, { recursive: true })
-        await Bun.write(join(args.destDir, `v${args.seed}.png`), c.toBuffer('image/png'))
+        const png = join(args.destDir, `v${args.seed}.png`)
+        await Bun.write(png, c.toBuffer('image/png'))
+        await encodeRolls([png], args.rollFormat)
         return
     }
     const rt = await resolveComfy()
-    const lw = workflowFor(rt.workflows, { workflow: gen.workflow, assetId: found.asset.id })
-    await generateComfyTs(rt, lw, { prompt: args.prompt, seed: args.seed, assetId: found.asset.id, draftId: found.kind.id, destDir: args.destDir, name: `v${args.seed}`, vars: gen.vars, onProgress: args.onProgress })
+    const lw = workflowFor(rt.workflows, { workflow: gen.workflow, kind: found.kind.id, assetId: found.asset.id })
+    await encodeRolls(await generateComfyTs(rt, lw, { prompt: args.prompt, seed: args.seed, assetId: found.asset.id, draftId: found.kind.id, destDir: args.destDir, name: `v${args.seed}`, vars: gen.vars, onProgress: args.onProgress }), args.rollFormat)
 }
 
 /** Memoized lazy comfy runtime for a resolved kit — loads the cflow modules on

package/src/assets/kit-config.ts

@@ -127,14 +127,23 @@ export type KitConfig = {
     /** workflows = dir of comfy-ts .cflow.ts modules (each module owns its
      *  host); heal = shell command shown in error hints, never executed */
     comfy?: { workflows: string; heal?: string }
+    /** absent: an image roll lands in the format its backend produced (png
+     *  from comfy and canvas). 'webp-lossless' re-encodes every new image
+     *  roll as lossless webp, the same pixels at about 60% of the bytes */
+    rollFormat?: RollFormat
     kinds: Kind[]
 }
 
+export const ROLL_FORMATS = ['webp-lossless'] as const
+export type RollFormat = (typeof ROLL_FORMATS)[number]
+
 export type ResolvedKit = KitConfig & { workspace: string }
 
 export function validateKit(k: KitConfig): string[] {
     const errs: string[] = []
     if (!Array.isArray(k.kinds) || k.kinds.length === 0) errs.push('kinds must be a non-empty array')
+    if (k.rollFormat != null && !(ROLL_FORMATS as readonly string[]).includes(k.rollFormat))
+        errs.push(`unknown rollFormat '${String(k.rollFormat)}' (${ROLL_FORMATS.join(' | ')}, or absent for the backend's own format)`)
     for (const key of Object.keys(k.comfy ?? {}))
         if (key !== 'workflows' && key !== 'heal')
             errs.push(`comfy config has unknown key '${key}'${key === 'host' ? " — host is gone, the workflow's _host.ts owns the box (comfy-ts migration)" : ''}`)

package/src/assets/kits/identity-kit.ts

@@ -51,10 +51,16 @@ export function identityKinds(brand: Brand): Kind[] {
     ]
 }
 
+// named faces first: the generic sans-serif can resolve to a face with no
+// Latin-1 accents (macOS). Each family below carries them, and an absent one
+// is skipped (macOS, Windows, then the common Linux faces)
+const OG_FAMILIES = 'Helvetica, Arial, "DejaVu Sans", "Liberation Sans", "Noto Sans", sans-serif'
+export const ogFont = (px: number, bold = false): string => `${bold ? 'bold ' : ''}${px}px ${OG_FAMILIES}`
+
 // shrink px until text fits maxW (og cards must never clip the tagline)
 const fitFont = (ctx: SKRSContext2D, text: string, px: number, maxW: number, bold = false): void => {
     for (; px > 12; px -= 2) {
-        ctx.font = `${bold ? 'bold ' : ''}${px}px sans-serif`
+        ctx.font = ogFont(px, bold)
         if (ctx.measureText(text).width <= maxW) return
     }
 }

package/src/assets/run-assets.ts

@@ -50,7 +50,7 @@ async function rollOnce(root: string, io: AssetsIo, kit: ResolvedKit, resolveCom
     for (let i = 0; i < count; i++) {
         const seed = randomSeed()
         try {
-            await generateRoll(f!, { prompt, seed, destDir: dir, context }, resolveComfy)
+            await generateRoll(f!, { prompt, seed, destDir: dir, context, rollFormat: kit.rollFormat }, resolveComfy)
             io.print(`ok: ${assetId} v${seed}`)
         } catch (e) {
             failed++
@@ -196,7 +196,7 @@ export const runAssetsCheck = (root: string, io: AssetsIo): Promise<number> =>
                     const gen = kind.generate
                     if (gen.backend !== 'comfy') continue
                     try {
-                        const lw = workflowFor(wfs, { workflow: gen.workflow, assetId: kind.assets[0]?.id })
+                        const lw = workflowFor(wfs, { workflow: gen.workflow, kind: kind.id, assetId: kind.assets[0]?.id })
                         if (gen.vars != null) {
                             for (const [, d] of lw.wf.entries()) d.reset()
                             applyVarValues(lw.wf, gen.vars, `kind '${kind.id}'`)
@@ -215,7 +215,7 @@ export const runAssetsCheck = (root: string, io: AssetsIo): Promise<number> =>
                 for (const f of allAssets(kit).filter((x) => x.kind.generate.backend === 'comfy')) {
                     let lw: LoadedWorkflow
                     try {
-                        lw = workflowFor(wfs, { workflow: (f.kind.generate as ComfyGen).workflow, assetId: f.asset.id })
+                        lw = workflowFor(wfs, { workflow: (f.kind.generate as ComfyGen).workflow, kind: f.kind.id, assetId: f.asset.id })
                     } catch {
                         continue // an unresolvable workflow already FAILed on its kind above
                     }

package/src/assets/server/studio-server.ts

@@ -110,7 +110,7 @@ export async function studioRoutes(deps: StudioDeps): Promise<StudioRoutes> {
         for (const f of allAssets(kit).filter((x) => x.kind.generate.backend === 'comfy')) {
             try {
                 const gen = f.kind.generate as { workflow?: string }
-                const lw = workflowFor(workflows, { workflow: gen.workflow, assetId: f.asset.id })
+                const lw = workflowFor(workflows, { workflow: gen.workflow, kind: f.kind.id, assetId: f.asset.id })
                 // the KIND's draft, shared by every asset of that kind
                 if (ensureAssetDraft(lw, f.kind.id, await promptOf(f))) console.log(`ok: draft '${f.kind.id}' seeded → .comfy-ts/drafts/${lw.id}/${f.kind.id}.json`)
             } catch (e) {
@@ -127,7 +127,7 @@ export async function studioRoutes(deps: StudioDeps): Promise<StudioRoutes> {
         return { workflows, heal: kit.comfy.heal }
     }
     const generateOne = deps.generateOne ?? ((found, prompt, seed, destDir, onProgress, context?: ParentContext) =>
-        generateRoll(found, { prompt, seed, destDir, onProgress, context }, resolveComfy))
+        generateRoll(found, { prompt, seed, destDir, onProgress, context, rollFormat: kit.rollFormat }, resolveComfy))
 
     const queue = new StudioQueue(async (job, seed, onProgress) => {
         const found = findAsset(kit, job.assetId)
@@ -388,7 +388,7 @@ export async function studioRoutes(deps: StudioDeps): Promise<StudioRoutes> {
             const rgen = running?.kind.generate
             if (workflows != null && rgen?.backend === 'comfy') {
                 try {
-                    await workflowFor(workflows, { workflow: rgen.workflow, assetId: running!.asset.id }).wf.host.interrupt()
+                    await workflowFor(workflows, { workflow: rgen.workflow, kind: running!.kind.id, assetId: running!.asset.id }).wf.host.interrupt()
                 } catch (e) {
                     queue.pushError(`interrupt: ${(e as Error).message} — current roll will finish, its job is still dropped`)
                 }

package/src/cli/cmd_Ci.ts

@@ -20,7 +20,8 @@ export class CiCommand extends Command {
             ['gate without the repair pass (checks can still write)', 'sk ci --no-fix'],
             ['leave repo config files alone', 'sk ci --no-fix-rules'],
             ['stop at the first failure', 'sk ci --bail'],
-            ['one check + its dep closure', 'sk ci --only typecheck'],
+            ['one check + its dep closure, the tree left alone', 'sk ci --only typecheck'],
+            ['one check, repairing the mechanical slots first', 'sk ci --only typecheck --fix'],
             ['every check declaring one group', 'sk ci --only wiki'],
             ['run everything, take nothing from the cache', 'sk ci --fresh'],
             ['include an opt in check', 'sk ci --with up:itch'],
@@ -31,12 +32,12 @@ export class CiCommand extends Command {
 
     bail = Option.Boolean('--bail', false, { description: 'stop at the first failure' })
     json = Option.Boolean('--json', false, { description: 'machine-readable result instead of wire lines' })
-    fix = Option.Boolean('--fix', true, { description: 'repair the mechanical slots before gating. Default on. --no-fix skips the repair pass, the checks can still write. Under CI the fixers still run but the gate FAILS on any file they rewrite' })
+    fix = Option.Boolean('--fix', { description: 'repair the mechanical slots before gating. Default on for a whole gate and off for a --only run, which leaves the tree alone unless --fix is named. --no-fix skips the repair pass, the checks can still write. Under CI the fixers still run but the gate FAILS on any file they rewrite' })
     fixRules = Option.Boolean('--fix-rules', true, { description: 'apply the structural autofixes of the built-in checks too. Default on. --no-fix-rules leaves repo config alone' })
     frozen = Option.Boolean('--frozen', false, { description: 'report-only mode for self-maintaining checks: SK005 never touches package.json, and generated paths are never untracked. STATUS.md is still refreshed on disk, but it is gitignored, so a run leaves the tree clean' })
     skip = Option.Array('--skip', [], { description: 'skip a check group (repeatable)' })
     withIds = Option.Array('--with', [], { description: 'include a check the quick gate leaves out (repeatable)' })
-    only = Option.Array('--only', [], { description: 'run only this check + its dep closure (repeatable). A group name runs every check declaring that group' })
+    only = Option.Array('--only', [], { description: 'run only this check + its dep closure (repeatable). A group name runs every check declaring that group. No repair pass unless --fix is named' })
     fresh = Option.Boolean('--fresh', false, { description: 'run every check: no answer comes from the cache, and what this run finds is stored fresh' })
     full = Option.Boolean('--full', false, { description: `run the FULL test tier: every suite the repo declares, the slow ones it skips while you work included. What the release path always runs. Same as SHIPKIT_TEST_FULL=1` })
 
@@ -68,7 +69,7 @@ export class CiCommand extends Command {
         return [
             ...(this.bail ? ['--bail'] : []),
             ...(this.json ? ['--json'] : []),
-            ...(this.fix ? [] : ['--no-fix']),
+            ...(this.fix === true ? ['--fix'] : this.fix === false ? ['--no-fix'] : []),
             ...(this.fixRules ? [] : ['--no-fix-rules']),
             ...(this.frozen ? ['--frozen'] : []),
             ...this.skip.flatMap((v) => ['--skip', v]),

package/src/collections/providers.ts

@@ -413,7 +413,7 @@ export function buildCollections(root: string, c: RepoConfig, kit: ResolvedKit |
         contractsCollection(root, c),
         asksCollection(root, c),
         credsCollection(root, c, { verdicts: () => verdictsOf(checks) }),
-        mediaKitCollection(root, kit),
+        mediaKitCollection(root, c.serve?.assets === false ? null : kit),
         socialPostsCollection(root),
         reflectionsCollection(root),
         testsCollection(root, c),

package/src/core/check-runner.ts

@@ -248,6 +248,12 @@ export function testsRan(lastLine: string): number | null {
     return m == null ? null : Number(m[1])
 }
 
+/** the command the suite runner says it ran, read off the same headline
+ *  (`…, as \`bun test --parallel=8\` (added --parallel=8)`, judge-suites ranAs) */
+export function testsCommand(lastLine: string): string | null {
+    return /, (as `[^`]+`(?: \(added [^)]+\))?)/.exec(lastLine)?.[1] ?? null
+}
+
 export type Selection = {
     /** what this run measures */
     selected: RunnableCheck[]
@@ -580,9 +586,12 @@ export async function runChecks(o: RunChecksOpts): Promise<RunChecksSummary> {
         const ran = u.status === 'pass' || u.status === 'warn' ? testsRan(u.lastLine) : null
         const counted = ran != null && head != null && head.kind === 'ok' && (head.text === u.id || head.text.startsWith(`${u.id} (`))
         const id = counted ? `${u.id} ${ran} test${ran === 1 ? '' : 's'}` : u.id
+        // and the command the suite runner ran, which can differ from the script's body
+        const how = counted ? testsCommand(u.lastLine) : null
+        const as = how == null ? '' : ` ${how}`
         const composed = u.synthetic && !u.replayed && head != null
-            ? [{ ...head, text: `${id} ${ranStamp(u.ms)}${u.tail}` }, ...u.lines.slice(1)]
-            : counted ? [{ ...head, text: `${id}${head.text.slice(u.id.length)}` }, ...u.lines.slice(1)] : u.lines
+            ? [{ ...head, text: `${id} ${ranStamp(u.ms)}${u.tail}${as}` }, ...u.lines.slice(1)]
+            : counted ? [{ ...head, text: `${id}${head.text.slice(u.id.length)}${as}` }, ...u.lines.slice(1)] : u.lines
         // every line says where its answer came from: a replay carries its
         // cached stamp already, so one that ran here says so and what it cost
         const shown = u.synthetic || u.replayed || u.attached || u.startedAt === 0 || composed[0] == null
@@ -798,11 +807,11 @@ export async function runChecks(o: RunChecksOpts): Promise<RunChecksSummary> {
         // attached wait runs nothing, so it holds none
         const slot = pool == null ? null : await takeSlot(pool, { repo: o.config.name, check: u.id }, {
             abort: () => interrupted || bailed,
-            onWait: (held) => {
+            onWait: (held, why) => {
                 if (slotWaitSaid) return
                 slotWaitSaid = true
                 const who = held.slice(0, 3).map((h) => `${h.repo}/${h.check} pid ${h.pid}`).join(', ')
-                emit({ kind: 'ok', text: `waiting for a machine slot: ${held.length} of ${pool.size} held${who === '' ? '' : ` (${who}${held.length > 3 ? ', …' : ''})`}` })
+                emit({ kind: 'ok', text: `waiting for a machine slot: ${held.length} held, ${why}${who === '' ? '' : ` (${who}${held.length > 3 ? ', …' : ''})`}` })
             },
         })
         if (pool != null && slot == null) { u.status = 'skip'; u.note = bailed ? 'bailed' : 'interrupted'; u.lines = []; u.unmeasured = true; return }

package/src/core/discover-checks.ts

@@ -158,13 +158,28 @@ function unloadable(path: string, message: string): CheckDef {
     }
 }
 
+/** a built-in that does not load, as a repo that only CONSUMES the toolkit
+ *  sees it: one warning, never a red gate, since only the toolkit's own repo
+ *  can fix the file, and its gate stays red on it */
+function brokenBuiltin(path: string, message: string): CheckDef {
+    return {
+        ...unloadable(path, message),
+        blocking: false,
+        run: (c) => c.warn(`${basename(path)} does not load, so this gate skips it: ${message.replace(`${path}: `, '')}`, 'the toolkit repo owns the file, and its own gate fails on it'),
+    }
+}
+
+const BUILTIN_OWNER = 'build/shipkit/built-in-checks.md'
+
 /** every check this repo can run: its own files, plus the toolkit's. Throws
  *  on a registration nobody can act on (a duplicate id, a repo check squatting
  *  the reserved prefix, a built-in with no owner page), so a broken
- *  declaration dies at load rather than half way through a gate. */
-export async function discoverChecks(root: string): Promise<DiscoveredCheck[]> {
+ *  declaration dies at load rather than half way through a gate. A broken
+ *  built-in is that only in the toolkit's own repo: elsewhere it warns.
+ *  `builtinDir` is the toolkit's checks dir, a parameter for tests only */
+export async function discoverChecks(root: string, builtinDir: string = BUILTIN_CHECK_DIR): Promise<DiscoveredCheck[]> {
     const builtins: string[] = []
-    walk(BUILTIN_CHECK_DIR, builtins)
+    walk(builtinDir, builtins)
     const found: string[] = []
     walk(root, found)
     const units = repoUnitFiles(root)
@@ -173,6 +188,9 @@ export async function discoverChecks(root: string): Promise<DiscoveredCheck[]> {
     // because a consumer reaches the same files through a linked node_modules
     const real = (f: string): string => { try { return realpathSync(f) } catch { return f } }
     const shipped = new Set(builtins.map(real))
+    // its own source, never an install of it
+    const inRoot = relative(real(root), real(builtinDir))
+    const hostsToolkit = !inRoot.startsWith('..') && !inRoot.split(/[\\/]/).includes('node_modules')
     const all = found.filter((f) => !shipped.has(real(f))).sort()
     builtins.sort()
     const names = fallbackNames(root, all)
@@ -185,23 +203,34 @@ export async function discoverChecks(root: string): Promise<DiscoveredCheck[]> {
     for (const f of [...builtins, ...own, ...units]) {
         const isBuiltin = builtins.includes(f)
         let def: CheckDef | null
+        let loadError: string | null = null
         try {
             def = await load(f)
         } catch (e) {
             // a file that does not load is ONE red row, never a dead inventory:
             // every other check still runs, and this one says why in every run
-            def = unloadable(f, (e as Error).message)
+            loadError = (e as Error).message
+            def = unloadable(f, loadError)
         }
         if (def == null) continue
         const rel = isBuiltin ? null : relative(root, f).replace(/\\/g, '/')
         const fallback = isBuiltin
             ? (BUILTIN_ID_RE.exec(base(f))?.[1] ?? base(f))
             : f.endsWith(UNIT_SUFFIX) ? unitBase(f) : names.get(f)!
-        const id = def.id ?? fallback
+        let id = def.id ?? fallback
         if (isBuiltin) {
-            if (id !== fallback) throw new Error(`${f}: declares id '${id}' but its file name says '${fallback}' — a built-in id is its file name`)
-            if ((def.owner ?? '') === '') throw new Error(`${f}: a built-in check names the page that OWNS the invariant`)
-            if (RETIRED_CHECK_IDS[id] != null) throw new Error(`${f}: id '${id}' is retired (${RETIRED_CHECK_IDS[id]}), and an id is never reused`)
+            const refused = loadError != null ? null
+                : id !== fallback ? `${f}: declares id '${id}' but its file name says '${fallback}' — a built-in id is its file name`
+                : (def.owner ?? '') === '' ? `${f}: a built-in check names the page that OWNS the invariant`
+                : RETIRED_CHECK_IDS[id] != null ? `${f}: id '${id}' is retired (${RETIRED_CHECK_IDS[id]}), and an id is never reused`
+                : null
+            // the toolkit's own repo dies on a refused built-in, a consumer
+            // only warns: it cannot fix the file, and must not lose its gate
+            if (refused != null && hostsToolkit) throw new Error(refused)
+            if (refused != null || loadError != null) {
+                def = hostsToolkit ? { ...def, owner: BUILTIN_OWNER } : { ...brokenBuiltin(f, refused ?? loadError!), owner: BUILTIN_OWNER }
+                id = fallback
+            }
         } else if (id.startsWith('SK')) {
             throw new Error(`${rel}: id '${id}' uses the reserved SK prefix — a repo check picks its own (e.g. RV${id.slice(-3)}) or plain words`)
         }

package/src/core/fix-scope.ts

@@ -0,0 +1,5 @@
+// does a gate run its repair pass (core/run-fixers.ts). A leaf, so the hub's
+// run lanes read the same answer the gate acts on without loading the gate.
+
+/** `fix` named wins. Unnamed: a whole gate repairs, a narrowed run does not */
+export const fixPassRuns = (o: { fix?: boolean; onlyIds?: readonly string[] }): boolean => o.fix ?? (o.onlyIds ?? []).length === 0

package/src/core/floor-resolve.ts

@@ -20,6 +20,7 @@ import type { CheckCtx } from './check-ctx.ts'
 import { checkUnitReader, type UnitReader } from '../release/unit-resolve.ts'
 import { parseJsonc } from '../ts/jsonc.ts'
 import { resolveTypecheckProjects } from '../ts/tsconfig-resolve.ts'
+import { gateBuildInfoArgs } from '../ts/typecheck-cache.ts'
 import { parseBunTestScript, suiteFlags } from '../suite/judge-suites.ts'
 import { declaredTestUnits, siblingUnits, testCheckId, unitIgnores, unitTestBody, unitTsconfig, type TestUnitDecl } from '../suite/test-units.ts'
 import { describeFirst, type TaskDef } from '../check.ts'
@@ -194,7 +195,7 @@ function builtinFloorTask(id: string, root: string, io: FloorReader): { task: Ta
             const projects = resolveTypecheckProjects(tsconfig, io, root)
             plain = projects.projects.length === 1 && projects.projects[0] === tsconfig && projects.missing.length === 0
         } catch { plain = false }
-        if (plain) return { task: { id, cmd: [tsc, '--noEmit'] }, source: 'built-in (tsc)' }
+        if (plain) return { task: { id, cmd: [tsc, '--noEmit', ...gateBuildInfoArgs(tsconfig)] }, source: 'built-in (tsc)' }
         const cli = fileURLToPath(import.meta.resolve('rvlib-shipkit/src/ts/typecheck-cli.ts'))
         return { task: { id, cmd: ['bun', cli, tsc, tsconfig] }, source: 'built-in (tsc)' }
     }

package/src/core/git-root.ts

@@ -58,14 +58,23 @@ export function probeGitRoot(at: string): Probe {
     return p
 }
 
-/** the variables that let git find a repo with no `.git` in reach */
+/** the variables that let git find a repo with no `.git` in reach. They name
+ *  ONE repo for the whole process (git sets GIT_DIR for every hook in a linked
+ *  worktree), so they only answer for a directory with no `.git` of its own:
+ *  any other directory is asked with them stripped, or the hook's repo would
+ *  claim the house and every repo the process looks at */
 const LOCATING_ENV = ['GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR']
+const locatingEnvSet = (): boolean => LOCATING_ENV.some((k) => (process.env[k] ?? '') !== '')
+const discoveryEnv = (): Record<string, string | undefined> => {
+    const env = { ...process.env }
+    for (const k of LOCATING_ENV) delete env[k]
+    return env
+}
 
-/** git's discovery walks up looking for `.git`. With none at or above and no
- *  variable pointing elsewhere, its answer is already known, and a gate or a
- *  test suite that probes fresh temp dirs would spawn a process per dir for it */
+/** git's discovery walks up looking for `.git`. With none at or above, its
+ *  answer is already known, and a gate or a test suite that probes fresh temp
+ *  dirs would spawn a process per dir for it */
 function nothingInReach(dir: string): boolean {
-    if (LOCATING_ENV.some((k) => (process.env[k] ?? '') !== '')) return false
     let cur: string
     try {
         cur = realpathSync(dir)
@@ -81,12 +90,11 @@ function nothingInReach(dir: string): boolean {
 }
 
 /** the common case answered from the disk: `.git` is a plain directory right
- *  at `dir`, which git describes as exactly that. Anything unusual (a locating
- *  variable, a gitfile or a symlinked `.git`, a shared common dir, a config
- *  that relocates the work tree, marks it bare or includes another file, a
- *  `.git` owned by someone else) is left to git */
+ *  at `dir`, which git describes as exactly that. Anything unusual (a gitfile
+ *  or a symlinked `.git`, a shared common dir, a config that relocates the
+ *  work tree, marks it bare or includes another file, a `.git` owned by
+ *  someone else) is left to git */
 function plainRoot(dir: string): GitRoot | null {
-    if (LOCATING_ENV.some((k) => (process.env[k] ?? '') !== '')) return null
     try {
         const top = realpathSync(dir)
         const gitDir = join(top, '.git')
@@ -102,8 +110,9 @@ function plainRoot(dir: string): GitRoot | null {
 }
 
 function ask(dir: string): Probe {
-    if (nothingInReach(dir)) return { root: null, error: 'fatal: not a git repository (or any of the parent directories): .git' }
-    const plain = plainRoot(dir)
+    const none = nothingInReach(dir)
+    if (none && !locatingEnvSet()) return { root: null, error: 'fatal: not a git repository (or any of the parent directories): .git' }
+    const plain = none ? null : plainRoot(dir)
     if (plain != null) return { root: plain, error: '' }
     let p: ReturnType<typeof Bun.spawnSync>
     try {
@@ -111,6 +120,7 @@ function ask(dir: string): Probe {
             cwd: dir,
             stdout: 'pipe',
             stderr: 'pipe',
+            env: none ? { ...process.env } : discoveryEnv(),
         })
     } catch (e) {
         return { root: null, error: e instanceof Error ? e.message : String(e) }

package/src/core/one-lib.ts

@@ -119,7 +119,9 @@ export function useOneLib(root: string = LIB_ROOT): void {
             build.onLoad({ filter: /\/(node_modules\/rvlib-shipkit|install\/cache\/rvlib-shipkit@[^/]*)\// }, (a) => {
                 const loader = LOADERS[extname(a.path)] ?? 'ts'
                 const sub = foreignLibPath(a.path, root)
-                if (sub == null) return { contents: readFileSync(a.path, 'utf8'), loader }
+                // the host copy itself lives under node_modules when it is an
+                // install: its path can carry importFresh's `?v=` stamp
+                if (sub == null) return { contents: readFileSync(a.path.replace(/\?.*$/, ''), 'utf8'), loader }
                 return reexport(join(root, sub))
             })
             for (const name of SHARED) {
@@ -131,7 +133,7 @@ export function useOneLib(root: string = LIB_ROOT): void {
                 const skip = [...new Set([host, real(host)])].map((h) => `(?!${esc(h)}/)`).join('')
                 build.onLoad({ filter: new RegExp(`^${skip}.*/node_modules/${esc(name)}/`) }, (a) => {
                     const sub = foreignSharedPath(a.path, name, host)
-                    if (sub == null) return { contents: readFileSync(a.path, 'utf8'), loader: LOADERS[extname(a.path)] ?? 'js' }
+                    if (sub == null) return { contents: readFileSync(a.path.replace(/\?.*$/, ''), 'utf8'), loader: LOADERS[extname(a.path)] ?? 'js' }
                     return reexport(sharedTarget(a.path, sub, name, host))
                 })
             }