rvlib-shipkit 1.8.0 → 2.0.0

package/src/home/attach.ts

@@ -1,10 +1,8 @@
 // `shipkit serve` while a home runs: the hub itself runs in the home, and
-// this process only streams its lines. So the VS Code folder-open task keeps its
-// problem matcher and its clickable url, with no change to any repo's
-// tasks.json, and closing VS Code no longer stops the hub.
+// this process only streams its lines, so stopping it never stops the hub.
 //
-// the log is what the home prints for that hub, so the frames the matcher
-// reads arrive as the hub prints them. On attach, the last complete frame is replayed first,
+// the log is what the home prints for that hub, so the frames arrive as the
+// hub prints them. On attach, the last complete frame is replayed first,
 // so the problems pane fills at once instead of at the next run.
 import { closeSync, existsSync, openSync, readSync, statSync } from 'fs'
 import { FRAME_BEGIN, FRAME_END_HEAD } from '../problems/problem-line.ts'

package/src/home/gui-app/ShipkitGui.swift

@@ -130,6 +130,7 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
 
     func applicationDidFinishLaunching(_ note: Notification) {
         if CommandLine.arguments.contains("--self-test-find") { return selfTestFind() }
+        if CommandLine.arguments.contains("--self-test-panels") { return selfTestPanels() }
         buildMenu()
         // esc closes the find bar of the key window, and reaches the page otherwise
         NSEvent.addLocalMonitorForEvents(matching: .keyDown) { e in
@@ -267,6 +268,61 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         web.loadHTMLString("<p>one needle, two needle</p>", baseURL: nil)
     }
 
+    /** hears every js panel once it shows: the self test answers it */
+    var onPanel: ((NSAlert) -> Void)?
+
+    // `--self-test-panels`: a page in an offscreen window calls prompt, confirm
+    // and alert, answered OK after typing over the prompt's text, then again,
+    // answered with esc. What the page got printed, exit 0 only when every
+    // answer reached it. Return is checked as OK being the sheet's default
+    // button: a synthetic return reaches it only in a key window, and the test
+    // must not take the focus
+    func selfTestPanels() {
+        let web = WKWebView(frame: .zero, configuration: WKWebViewConfiguration())
+        web.navigationDelegate = self
+        web.uiDelegate = self
+        let win = NSWindow(contentRect: NSRect(x: -4000, y: -4000, width: 600, height: 400), styleMask: [.titled], backing: .buffered, defer: false)
+        win.contentView = Pane(web: web)
+        win.orderFrontRegardless()
+        windows.append(win)
+        var accept = true
+        var panels = 0
+        var returnIsOK = true
+        var escHeard = true
+        onPanel = { alert in
+            panels += 1
+            DispatchQueue.main.async {
+                if alert.window.defaultButtonCell !== alert.buttons[0].cell { returnIsOK = false }
+                if accept {
+                    // typing replaces the default text only when it is selected in an active editor
+                    if let field = alert.accessoryView as? NSTextField { (field.currentEditor() as? NSTextView)?.insertText("typed", replacementRange: NSRange(location: NSNotFound, length: 0)) }
+                    return alert.buttons[0].performClick(nil)
+                }
+                if alert.buttons.count == 1 { return alert.buttons[0].performClick(nil) }
+                let esc = NSEvent.keyEvent(with: .keyDown, location: .zero, modifierFlags: [], timestamp: 0, windowNumber: alert.window.windowNumber, context: nil, characters: "\u{1b}", charactersIgnoringModifiers: "\u{1b}", isARepeat: false, keyCode: 53)
+                if let esc, alert.window.performKeyEquivalent(with: esc) { return }
+                escHeard = false
+                alert.buttons[1].performClick(nil)
+            }
+        }
+        let js = "JSON.stringify([prompt('name', 'x'), confirm('ok?'), (alert('hi'), 'alerted')])"
+        onLoad = { _ in
+            web.evaluateJavaScript(js) { a, _ in
+                accept = false
+                web.evaluateJavaScript(js) { b, _ in
+                    let ok = (a as? String) ?? "none", cancel = (b as? String) ?? "none"
+                    print("panels=\(panels)")
+                    print("return-is-ok=\(returnIsOK)")
+                    print("esc-heard=\(escHeard)")
+                    print("ok=\(ok)")
+                    print("cancel=\(cancel)")
+                    exit(panels == 6 && returnIsOK && escHeard && ok == "[\"typed\",true,\"alerted\"]" && cancel == "[null,false,\"alerted\"]" ? 0 : 1)
+                }
+            }
+        }
+        web.loadHTMLString("<p>panels</p>", baseURL: nil)
+    }
+
     func windowWillClose(_ note: Notification) {
         windows.removeAll { $0 === note.object as? NSWindow }
     }
@@ -293,6 +349,46 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         return nil
     }
 
+    // alert, confirm and prompt: without these WebKit answers each one at once
+    // (no panel, confirm false, prompt null), so a page's dialogs do nothing.
+    // WebKit throws when a handler is dropped or called twice: `panel` calls
+    // `done` exactly once on every path
+
+    /** one js panel: a sheet on the page's window, a modal where there is
+     *  none. Return is OK, esc is Cancel; `done` hears whether OK was pressed */
+    func panel(_ web: WKWebView, _ message: String, cancel: Bool, field: NSTextField? = nil, done: @escaping (Bool) -> Void) {
+        let alert = NSAlert()
+        alert.messageText = message
+        alert.addButton(withTitle: "OK").keyEquivalent = "\r"
+        if cancel { alert.addButton(withTitle: "Cancel").keyEquivalent = "\u{1b}" }
+        if let field {
+            alert.accessoryView = field
+            alert.window.initialFirstResponder = field
+        }
+        guard let win = web.window else {
+            onPanel?(alert)
+            return done(alert.runModal() == .alertFirstButtonReturn)
+        }
+        alert.beginSheetModal(for: win) { r in done(r == .alertFirstButtonReturn) }
+        // first responder selects the whole default text, so typing replaces it
+        if let field { alert.window.makeFirstResponder(field) }
+        onPanel?(alert)
+    }
+
+    func webView(_ web: WKWebView, runJavaScriptAlertPanelWithMessage message: String, initiatedByFrame frame: WKFrameInfo, completionHandler: @escaping () -> Void) {
+        panel(web, message, cancel: false) { _ in completionHandler() }
+    }
+
+    func webView(_ web: WKWebView, runJavaScriptConfirmPanelWithMessage message: String, initiatedByFrame frame: WKFrameInfo, completionHandler: @escaping (Bool) -> Void) {
+        panel(web, message, cancel: true) { ok in completionHandler(ok) }
+    }
+
+    func webView(_ web: WKWebView, runJavaScriptTextInputPanelWithPrompt prompt: String, defaultText: String?, initiatedByFrame frame: WKFrameInfo, completionHandler: @escaping (String?) -> Void) {
+        let field = NSTextField(string: defaultText ?? "")
+        field.frame = NSRect(x: 0, y: 0, width: 300, height: 24)
+        panel(web, prompt, cancel: true, field: field) { ok in completionHandler(ok ? field.stringValue : nil) }
+    }
+
     func item(_ menu: NSMenu, _ title: String, _ action: Selector, _ key: String, _ mods: NSEvent.ModifierFlags = [.command], tag: Int = 0) {
         let i = menu.addItem(withTitle: title, action: action, keyEquivalent: key)
         i.keyEquivalentModifierMask = mods

package/src/home/insights.ts

@@ -11,6 +11,8 @@ import { homedir } from 'os'
 import { join } from 'path'
 import { gitBin } from '../core/git-bin.ts'
 import { boxesOf, type InsightsAnswer, type Manifest, type Scope } from './insights-shape.ts'
+import { isVendored } from '../core/vendored.ts'
+import { readVendored } from '../core/vendored-read.ts'
 
 export * from './insights-shape.ts'
 
@@ -40,7 +42,10 @@ async function manifestPaths(dir: string): Promise<string[]> {
     const p = Bun.spawn([gitBin(), 'ls-files', '-z', '--', 'package.json', '**/package.json'], { cwd: dir, stdout: 'pipe', stderr: 'ignore', env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' } })
     const [out, code] = await Promise.all([new Response(p.stdout).text(), p.exited])
     if (code !== 0) return existsSync(join(dir, 'package.json')) ? ['package.json'] : []
-    return out.split('\0').filter(Boolean)
+    // a vendored library's manifest is its upstream's, not a package this repo uses
+    let vendored: string[] = []
+    try { vendored = readVendored(dir) } catch { /* a config the repo cannot read is its own gate's failure */ }
+    return out.split('\0').filter((f) => f !== '' && !isVendored(f, vendored))
 }
 
 /** one repo's manifests, read; a file that does not parse is an error line */

package/src/home/pm-config.ts

@@ -30,9 +30,9 @@ if (import.meta.main) {
     const out: PmConfig = { index: house.index, processes: [], errors: [], inputs, stamp: stampOf(inputs) }
     if (house.index != null) {
         // a unit file imports the lib by name: this copy, like the daemon's
-        const { useOneLib } = await import('../core/one-lib.ts')
+        const { installOneLib } = await import('../core/one-lib.ts')
         const { scanGlobalUnits } = await import('./global-units.ts')
-        useOneLib()
+        installOneLib()
         const u = await scanGlobalUnits(repos.map((r) => ({ name: r.name, path: r.path })), { files: (r) => files.get(r) ?? [] })
         out.processes = u.processes
         out.errors = u.errors

package/src/home/resources.ts

@@ -285,6 +285,9 @@ export class Resource {
      *  while it answers, else it starts and opens once it does */
     async open(how: OpenHow): Promise<void> {
         if (this.decl.url == null) throw new Error(`${this.decl.id} declares no url to open`)
+        // the status is the last tick's: a process that died since would get
+        // a window on a dead port and never start
+        await this.tick()
         if (this.status === 'up') {
             this.show(how, this.decl.url)
             return

package/src/home/run-daemon.ts

@@ -7,7 +7,7 @@
 // at once (lib-watch.ts): the new image follows the jobs still running. The
 // machine resources are pm's.
 import { fileURLToPath } from 'url'
-import { useOneLib } from '../core/one-lib.ts'
+import { installOneLib } from '../core/one-lib.ts'
 import { reclaimPreviousImage } from '../core/instance.ts'
 import { reloadOnOwnCode } from './lib-watch.ts'
 import { loadHub } from '../serve/hub-runtime.ts'
@@ -47,7 +47,7 @@ export async function runDaemon(root: string, io: HomeIo, o: { port?: number } =
     }
     // before the first repo config loads: every one of them, and every check
     // file, then imports this copy of the lib
-    useOneLib()
+    installOneLib()
     // a process this one starts runs its gate and its hub in process
     process.env[WORKER_ENV] = '1'
     // a restart in place keeps the pid: the check children its previous

package/src/home/run-unit-action.ts

@@ -12,8 +12,8 @@ if (import.meta.main) {
         console.error('usage: bun run-unit-action.ts <unit file> <action id>')
         process.exit(2)
     }
-    const { useOneLib } = await import('../core/one-lib.ts')
-    useOneLib()
+    const { installOneLib } = await import('../core/one-lib.ts')
+    installOneLib()
     const u = ((await import(file)) as { default?: GlobalProcessUnit }).default
     const run = u?.actions?.[id]?.run
     if (run == null) {

package/src/hooks/commit-message.ts

@@ -1,9 +1,7 @@
 // the commit-message predicate of the commit-msg hook, which blocks at write
-// time: the one guard against AI attribution (SK009 checks it is armed).
-//
-// mechanical text rules only, so this stays publishable.
+// time. mechanical text rules only, so this stays publishable.
 
-export type OffenseKind = 'dash' | 'attribution' | 'language'
+export type OffenseKind = 'dash' | 'language'
 export type Offense = { line: number; text: string; kind: OffenseKind; why: string }
 
 /** git surfaces are English, always (identity/writing-voice.md). cheap French
@@ -34,13 +32,6 @@ export function frenchHits(line: string, languageAllow: string[] = []): boolean
     return words.size >= 2
 }
 
-/** trailers and footers that name an assistant, assistant session trailers,
- *  assistant share-domain urls (a session link is a louder tell than any
- *  trailer), plus the robot emoji. the session/url family lists every
- *  assistant, not just the one that bit first. */
-export const AI_ATTRIBUTION =
-    /(?:co-authored-by|assisted-by|signed-off-by):[^\n]*\b(?:claude|anthropic|copilot|chatgpt|openai|cursor|aider|devin|gemini)\b|generated with[^\n]*\b(?:claude|copilot|chatgpt|gemini)\b|\b(?:claude|chatgpt|copilot|cursor|aider|devin|gemini|codex)-session:|\b(?:claude\.(?:ai|com)|chatgpt\.com|chat\.openai\.com)\b|🤖/i
-
 /** everything below git's scissors line is the verbose-mode diff, which git
  *  strips before committing, diff content is not ours to police. */
 export function stripNonMessage(message: string): string {
@@ -62,8 +53,6 @@ export function commitMessageOffenses(message: string, opts?: { languageAllow?:
         const body = raw.replace(/^\s*[-*] /, '')
         if (body.includes(' - '))
             offenses.push({ line: i + 1, text: raw, kind: 'dash', why: 'inline " - " separator: same fix' })
-        if (AI_ATTRIBUTION.test(raw))
-            offenses.push({ line: i + 1, text: raw, kind: 'attribution', why: 'AI attribution: no assistant trailer, session trailer, claude.ai/chatgpt.com url, "Generated with" footer, or robot emoji' })
         if (frenchHits(raw, opts?.languageAllow))
             offenses.push({ line: i + 1, text: raw, kind: 'language', why: 'French: git surfaces are English, always (identity/writing-voice.md); quote product copy in "…" or `…` to exempt it' })
     })
@@ -71,4 +60,3 @@ export function commitMessageOffenses(message: string, opts?: { languageAllow?:
 }
 
 export const hasDashPunctuation = (message: string): boolean => commitMessageOffenses(message).some((o) => o.kind === 'dash')
-export const hasAiAttribution = (message: string): boolean => commitMessageOffenses(message).some((o) => o.kind === 'attribution')

package/src/hooks/hook-gates.ts

@@ -0,0 +1,38 @@
+// THE COMMIT GATES the git hooks run, as an inventory. They run from
+// hooks/run-hooks.ts, never through the runner, so the hook stays a leaf that
+// loads no check discovery. This list is what every other surface reads to
+// show them beside the checks (`shipkit checks`, `shipkit when`, the hub) and
+// what `off` names to turn one off. Type imports only: the hook loads it.
+import type { RepoConfig } from '../repo-config.ts'
+import { repoOff, type RepoOff } from '../core/when.ts'
+
+/** which git hook runs the gate */
+export type HookName = 'pre-commit' | 'commit-msg' | 'both'
+
+export type HookGate = { id: string; hook: HookName; title: string; description: string }
+
+export const HOOK_GATES = [
+    { id: 'tree-shrink', hook: 'pre-commit', title: 'tree shrink', description: 'the commit keeps at least half of the files HEAD tracks' },
+    { id: 'leak-guard', hook: 'both', title: 'leak guard', description: 'no staged added line, staged path or commit message matches a banned keyword' },
+    { id: 'blocked-paths', hook: 'pre-commit', title: 'blocked paths', description: 'nothing under a hooks.blockedPaths prefix is staged' },
+    { id: 'root-identity', hook: 'pre-commit', title: 'root identity', description: 'the repo name in package.json and repo.config.ts holds, and no scratch file is staged' },
+    { id: 'commit-message', hook: 'commit-msg', title: 'commit message', description: 'the commit message carries no dash punctuation and no French' },
+    { id: 'commit-language', hook: 'commit-msg', title: 'commit language', description: 'the commit message carries no French, the half of commit-message that off lifts alone' },
+] as const satisfies readonly HookGate[]
+
+export type HookGateId = (typeof HOOK_GATES)[number]['id']
+
+/** the page that owns every commit gate */
+export const HOOK_GATES_OWNER = 'build/shipkit/commit-gates.md'
+
+/** the whole pre-commit hook, boot included, past which it warns */
+export const HOOK_BUDGET_MS = 1_000
+
+/** the repo turned this gate off, and why. commit-language is the French half
+ *  of commit-message, so turning commit-message off turns it off too */
+export function hookGateOff(c: RepoConfig, id: HookGateId): RepoOff | null {
+    const own = repoOff(c, id)
+    if (own != null || id !== 'commit-language') return own
+    const parent = repoOff(c, 'commit-message')
+    return parent == null ? null : { ...parent, reason: `commit-message is off: ${parent.reason}` }
+}

package/src/hooks/leak-guard.ts

@@ -285,6 +285,8 @@ export type LeakGuardOpts = {
     allow?: LeakAllowEntry[]
     /** override the machine-global allowlist path; null reads none */
     allowFile?: string | null
+    /** the staged paths, when the caller already listed them (hooks/staged.ts) */
+    stagedNames?: string[]
 }
 
 /** git c-quotes a path that carries a space or a non-ascii byte. */
@@ -368,13 +370,16 @@ export function runLeakGuard(root: string, o: LeakGuardOpts = {}): LeakGuardResu
     }
 
     const targets: ScanTarget[] = []
-    if (o.staged !== false) {
+    if (o.staged !== false && o.stagedNames?.length !== 0) {
         const diff = Bun.spawnSync([gitBin(), 'diff', '--cached'], { cwd: root, maxBuffer: 256 * 1024 * 1024 })
         if (diff.exitCode === 0)
             for (const f of addedLinesByFile(diff.stdout.toString())) targets.push({ where: 'staged content', file: f.file, content: f.content })
         // a filename can leak as loudly as a line of code
-        const names = Bun.spawnSync([gitBin(), 'diff', '--cached', '--name-only'], { cwd: root })
-        if (names.exitCode === 0) for (const n of names.stdout.toString().split('\n')) if (n.trim() !== '') targets.push({ where: 'staged path', file: n, content: n })
+        const names = o.stagedNames ?? (() => {
+            const p = Bun.spawnSync([gitBin(), 'diff', '--cached', '--name-only'], { cwd: root })
+            return p.exitCode === 0 ? p.stdout.toString().split('\n') : []
+        })()
+        for (const n of names) if (n.trim() !== '') targets.push({ where: 'staged path', file: n, content: n })
     }
     for (const t of o.text ?? []) targets.push({ where: t.label, content: t.content })
 

package/src/hooks/one-way-in-guard.ts

@@ -4,14 +4,15 @@
 // type instead: `permissions.deny` already blocks these, but a bare deny tells
 // the model only that it was denied, and a refusal with no replacement just
 // sends it looking for another way in. It also refuses a gate piped into
-// another command, whose exit code the pipe hides.
+// another command, whose exit code the pipe hides, and a `git stash` in the
+// forms the deny row cannot see.
 //
 // It runs before EVERY Bash call, so it stays a leaf: one tiny import, one
 // small json read, no clipanion, no repo config. Anything it cannot decide it
 // waves through, because a guard that fails closed on its own bugs would wedge
 // a repo with no way to tell why, and `permissions.deny` is still the floor
 // underneath it. Measured at ~10ms per call.
-import { deniedHeads, pipedGateIn, pipedGateRefusal, rawRunnerHit, refusal } from '../core/one-way-in-policy.ts'
+import { deniedHeads, GIT_STASH_HEAD, pipedGateIn, pipedGateRefusal, rawRunnerHit, refusal, stashCallIn, stashRefusal } from '../core/one-way-in-policy.ts'
 
 const input = await Bun.stdin.text()
 let command = ''
@@ -38,6 +39,11 @@ try {
 } catch {
     process.exit(0)
 }
+const stash = command !== '' && denied.has(GIT_STASH_HEAD) ? stashCallIn(command) : null
+if (stash != null) {
+    console.error(stashRefusal(stash))
+    process.exit(2)
+}
 const hit = command === '' || denied.size === 0 ? null : rawRunnerHit(command, denied)
 if (hit == null) process.exit(0)
 // exit 2 is the block: stderr becomes the reason the model reads

package/src/hooks/root-identity.ts

@@ -8,6 +8,7 @@
 import { existsSync } from 'fs'
 import { join } from 'path'
 import { gitBin } from '../core/git-bin.ts'
+import { readStaged, type Staged } from './staged.ts'
 
 export type IdentityOutcome =
     | { status: 'skipped'; reason: string }
@@ -47,19 +48,21 @@ function identityDrift(root: string, path: string, read: (s: string) => string |
     return `${path}: name '${before}' → '${after}'`
 }
 
-export function runRootIdentity(root: string): IdentityOutcome {
-    if (git(root, ['rev-parse', '--verify', 'HEAD']).code !== 0)
+export function runRootIdentity(root: string, staged: Staged = readStaged(root)): IdentityOutcome {
+    if (!staged.head)
         return { status: 'skipped', reason: 'no HEAD yet — nothing to compare the first commit against' }
     if (process.env['SHIPKIT_ALLOW_IDENTITY_CHANGE'] === '1')
         return { status: 'skipped', reason: 'SHIPKIT_ALLOW_IDENTITY_CHANGE=1' }
 
+    // a file the commit does not stage is the same blob in the index and in
+    // HEAD, so only a staged one is worth reading
+    const touched = new Set(staged.names)
     const changes = [
-        identityDrift(root, 'package.json', packageName),
-        ...(existsSync(join(root, 'repo.config.ts')) ? [identityDrift(root, 'repo.config.ts', configName)] : []),
+        touched.has('package.json') ? identityDrift(root, 'package.json', packageName) : null,
+        touched.has('repo.config.ts') && existsSync(join(root, 'repo.config.ts')) ? identityDrift(root, 'repo.config.ts', configName) : null,
     ].filter((c): c is string => c != null)
 
-    const added = git(root, ['diff', '--cached', '--name-only', '--diff-filter=A'])
-    const scratch = added.out.split('\n').map((l) => l.trim()).filter((l) => l !== '' && SCRATCH.test(l))
+    const scratch = staged.entries.filter((e) => e.status === 'A' && SCRATCH.test(e.path)).map((e) => e.path)
 
     return changes.length === 0 && scratch.length === 0 ? { status: 'clean' } : { status: 'changed', changes, scratch }
 }

package/src/hooks/run-hooks.ts

@@ -4,20 +4,24 @@
 // while its next commit is already doomed, and nothing can enumerate what
 // the hooks enforce. `shipkit hooks list` answers that without reading shell.
 import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'fs'
-import { dirname, join } from 'path'
+import { dirname, join, relative } from 'path'
 import { fileURLToPath } from 'url'
 import { KEYWORD_FILE, LAYOUT } from '../core/layout.ts'
 import { commitMessageOffenses } from './commit-message.ts'
 import { globalAllowFile, globalKeywordFile, maskPattern, patternFingerprint, runLeakGuard, SK_KEY_ROW, type LeakAllowEntry, type LeakHit, type LeakWaiver } from './leak-guard.ts'
 import { runRootIdentity } from './root-identity.ts'
+import { readStaged } from './staged.ts'
+import { ALLOW_MASS_DELETE, runTreeShrink } from './tree-shrink.ts'
 import { gitRoot } from '../core/git-root.ts'
 import { spawnWithTimeout } from '../core/spawn-timeout.ts'
 import type { RepoConfig } from '../repo-config.ts'
 import { gitBin } from '../core/git-bin.ts'
-import { discoverChecks } from '../core/discover-checks.ts'
+import { discoverPreCommit, SLOW_IMPORT_MS } from '../core/pre-commit-discovery.ts'
 import { CheckCtx } from '../core/check-ctx.ts'
+import { CheckPass } from '../core/check-pass.ts'
 import { runCheckBody, type CheckDef } from '../check.ts'
 import { repoOff } from '../core/when.ts'
+import { HOOK_BUDGET_MS, hookGateOff, type HookGateId } from './hook-gates.ts'
 import { formatLine } from '../core/wire.ts'
 
 export type HooksConfig = {
@@ -56,11 +60,11 @@ export type HooksConfig = {
     /** words the commit-message language gate never counts as French
      *  (proper nouns that carry accents without being a language choice) */
     languageAllow?: string[]
-    /** disable a built-in gate, visible in `hooks list`, never silent.
-     *  'commit-language' lifts ONLY the French check, keeping the dash and
-     *  AI-attribution guards armed. 'commit-message' lifts the dash and French
-     *  checks; the AI-attribution guard is never lifted. */
-    disable?: ('leak-guard' | 'commit-message' | 'root-identity' | 'commit-language')[]
+    /** RETIRED, read as `off` while SK029 ports it there: a commit gate is
+     *  turned off like any check, `off: { <gate id>: '<why>' }`
+     *  (build/shipkit/runs.md). Dies once `shipkit fleet` shows no repo
+     *  carrying it */
+    disable?: HookGateId[]
 }
 
 const HOOK_DIR = LAYOUT.hooks
@@ -220,9 +224,26 @@ const draftsOpen = (c: RepoConfig): boolean => c.visibility === 'private'
 export async function runPreCommit(root: string, config: RepoConfig): Promise<GateOutcome[]> {
     const started = performance.now()
     const h = config.hooks ?? {}
+    const off = (id: HookGateId): boolean => hookGateOff(config, id) != null
     const out: GateOutcome[] = []
-    if (!(h.disable ?? []).includes('leak-guard')) {
-        const r = runLeakGuard(root, { keywordFile: h.keywordFile, allow: h.leakAllow })
+    const staged = readStaged(root)
+    if (!off('tree-shrink')) {
+        const r = runTreeShrink(root, staged)
+        if (r.status === 'skipped') out.push({ id: 'tree-shrink', ok: true, lines: [`skip: tree-shrink (${r.reason})`] })
+        else if (r.status === 'clean') out.push({ id: 'tree-shrink', ok: true, lines: ['ok: tree-shrink, the commit keeps the tree'] })
+        else if (r.status === 'shrunk') out.push({
+            id: 'tree-shrink',
+            ok: false,
+            lines: [
+                `FAIL: this commit keeps ${r.stagedFiles} of HEAD's ${r.headFiles} files (${r.deleted} deleted), under half the tree`,
+                `      a commit from a private GIT_INDEX_FILE that was never filled with \`git read-tree HEAD\` deletes every file it did not stage`,
+                `      fix: commit from the real index by pathspec (git commit -m … -- <paths>), or fill the private index first`,
+                `      a deliberate mass delete: ${ALLOW_MASS_DELETE}=1 git commit ...`,
+            ],
+        })
+    }
+    if (!off('leak-guard')) {
+        const r = runLeakGuard(root, { keywordFile: h.keywordFile, allow: h.leakAllow, stagedNames: staged.names })
         if (r.status === 'skipped') out.push({ id: 'leak-guard', ok: true, lines: [`skip: leak-guard (${r.reason})`] })
         else if (r.status === 'clean') out.push({
             id: 'leak-guard',
@@ -246,10 +267,8 @@ export async function runPreCommit(root: string, config: RepoConfig): Promise<Ga
             ],
         })
     }
-    if ((h.blockedPaths ?? []).length > 0) {
-        const names = Bun.spawnSync([gitBin(), 'diff', '--cached', '--name-only'], { cwd: root })
-        const staged = names.stdout.toString().split('\n').filter(Boolean)
-        const blocked = blockedStaged(staged, config)
+    if ((h.blockedPaths ?? []).length > 0 && !off('blocked-paths')) {
+        const blocked = blockedStaged(staged.names, config)
         out.push(blocked.length === 0
             ? { id: 'blocked-paths', ok: true, lines: [`ok: blocked-paths clean (${h.blockedPaths!.join(', ')})`] }
             : {
@@ -262,8 +281,8 @@ export async function runPreCommit(root: string, config: RepoConfig): Promise<Ga
                 ],
             })
     }
-    if (!(h.disable ?? []).includes('root-identity')) {
-        const r = runRootIdentity(root)
+    if (!off('root-identity')) {
+        const r = runRootIdentity(root, staged)
         if (r.status === 'skipped') out.push({ id: 'root-identity', ok: true, lines: [`skip: root-identity (${r.reason})`] })
         else if (r.status === 'clean') out.push({ id: 'root-identity', ok: true, lines: ['ok: root-identity unchanged'] })
         else out.push({
@@ -297,15 +316,19 @@ export async function runPreCommit(root: string, config: RepoConfig): Promise<Ga
     return out
 }
 
-/** the whole hook, boot included, past which it warns */
-export const HOOK_BUDGET_MS = 1_000
+export { HOOK_BUDGET_MS }
 
 /** the checks that declare `onPreCommit` and apply here, with their budget */
 export type PreCommitCheck = { id: string; title: string; owner: string; budgetMs: number; run: NonNullable<CheckDef['run']>; repair: unknown }
 
 export async function preCommitChecks(root: string, config: RepoConfig): Promise<PreCommitCheck[]> {
+    return (await preCommitDiscovery(root, config)).checks
+}
+
+async function preCommitDiscovery(root: string, config: RepoConfig): Promise<{ checks: PreCommitCheck[]; slow: { path: string; ms: number }[] }> {
+    const found = await discoverPreCommit(root)
     const out: PreCommitCheck[] = []
-    for (const u of await discoverChecks(root)) {
+    for (const u of found.checks) {
         const p = u.def.runs.onPreCommit
         if (p === false || u.def.run == null) continue
         if (repoOff(config, u.id) != null) continue
@@ -314,16 +337,25 @@ export async function preCommitChecks(root: string, config: RepoConfig): Promise
         }
         out.push({ id: u.id, title: u.title, owner: u.owner, budgetMs: p.budgetMs, run: u.def.run, repair: u.def.repair })
     }
-    return out
+    return { checks: out, slow: found.slow }
 }
 
 /** every `onPreCommit` check, run RAW on the working tree: no ledger, no
  *  cache, no repair. A failure refuses the commit, a pass over its budget
- *  warns by name and never blocks on time */
+ *  warns by name and never blocks on time. One pass for all of them, and one
+ *  that records no config reads, since nothing stores these answers */
 async function runPreCommitChecks(root: string, config: RepoConfig): Promise<GateOutcome[]> {
     const out: GateOutcome[] = []
-    for (const k of await preCommitChecks(root, config)) {
-        const c = CheckCtx.open({ root, config })
+    const found = await preCommitDiscovery(root, config)
+    for (const s of found.slow)
+        out.push({
+            id: 'slow-import',
+            ok: true,
+            lines: [`WARN ${relative(root, s.path)} took ${Math.round(s.ms)}ms to import, over ${SLOW_IMPORT_MS}ms: every surface that lists the checks pays it, so move its heavy imports inside \`run\` (build/shipkit/writing-a-check.md)`],
+        })
+    const pass = new CheckPass(root, config, undefined, false)
+    for (const k of found.checks) {
+        const c = new CheckCtx(pass)
         const t = performance.now()
         await runCheckBody({ id: k.id, title: k.title, owner: k.owner, run: k.run, fix: k.repair }, c)
         const ms = performance.now() - t
@@ -339,12 +371,12 @@ export async function runCommitMsg(root: string, config: RepoConfig, messageFile
     const h = config.hooks ?? {}
     const out: GateOutcome[] = []
     const message = readFileSync(messageFile, 'utf8')
-    if (!(h.disable ?? []).includes('commit-message')) {
-        const languageOff = (h.disable ?? []).includes('commit-language')
+    if (hookGateOff(config, 'commit-message') == null) {
+        const languageOff = hookGateOff(config, 'commit-language') != null
         const offenses = commitMessageOffenses(message, { languageAllow: h.languageAllow })
             .filter((o) => o.kind !== 'language' || !languageOff)
         out.push(offenses.length === 0
-            ? { id: 'commit-message', ok: true, lines: [`ok: commit message clean (no dash punctuation, no AI attribution${languageOff ? '' : ', English'})`] }
+            ? { id: 'commit-message', ok: true, lines: [`ok: commit message clean (no dash punctuation${languageOff ? '' : ', English'})`] }
             : {
                 id: 'commit-message',
                 ok: false,
@@ -353,17 +385,10 @@ export async function runCommitMsg(root: string, config: RepoConfig, messageFile
                     ...offenses.map((o) => `      line ${o.line}: ${o.text.slice(0, 100)}\n        ${o.why}`),
                 ],
             })
-    } else {
-        // AI attribution is the one message rule no config lifts: this hook is
-        // the guard against it in every repo (identity/how-we-commit.md)
-        const offenses = commitMessageOffenses(message).filter((o) => o.kind === 'attribution')
-        out.push(offenses.length === 0
-            ? { id: 'ai-attribution', ok: true, lines: ['ok: no AI attribution in the commit message'] }
-            : { id: 'ai-attribution', ok: false, lines: [`FAIL: commit message carries AI attribution`, ...offenses.map((o) => `      line ${o.line}: ${o.text.slice(0, 100)}\n        ${o.why}`)] })
     }
     // the leak guard also reads the MESSAGE, a private name pasted into a
     // commit body is as public as one pasted into a file
-    if (!(h.disable ?? []).includes('leak-guard')) {
+    if (hookGateOff(config, 'leak-guard') == null) {
         const r = runLeakGuard(root, { keywordFile: h.keywordFile, staged: false, allow: h.leakAllow, text: [{ label: 'commit message', content: message }] })
         if (r.status === 'hit')
             out.push({ id: 'leak-guard', ok: false, lines: [`FAIL: leak-guard matched in the commit message`, ...r.hits.map(hitLine), ...waivedLines(r.waived)] })
@@ -381,27 +406,33 @@ export async function runCommitMsg(root: string, config: RepoConfig, messageFile
     return out
 }
 
-/** what blocks a commit here, the enumeration hand-rolled hooks never had. */
+/** what blocks a commit here, the enumeration hand-rolled hooks never had.
+ *  A gate the repo turned off stays listed, with the reason `off` gives it */
 export function listGates(config: RepoConfig, root = process.cwd(), checks: { id: string; budgetMs: number }[] = []): string[] {
     const h = config.hooks ?? {}
-    const off = new Set(h.disable ?? [])
+    const offWord = (id: HookGateId): string => {
+        const o = hookGateOff(config, id)
+        return o == null ? '' : ` (OFF: ${o.reason})`
+    }
     const kw = h.keywordFile ?? KEYWORD_FILE
     // a gate listed as active but unable to fire is worse than no listing:
     // this surface exists so nobody has to guess
-    const leakState = off.has('leak-guard') ? ' (DISABLED by config)' : existsSync(join(root, kw)) || globalKeywordFile() != null ? '' : ` (INACTIVE, ${kw} absent and no ~/.shipkit/private list)`
+    const leakState = offWord('leak-guard') !== '' ? offWord('leak-guard') : existsSync(join(root, kw)) || globalKeywordFile() != null ? '' : ` (INACTIVE, ${kw} absent and no ~/.shipkit/private list)`
     // a waiver nobody can enumerate is a hole nobody can audit: the count of
     // declared exemptions belongs on the same surface as the gate itself
     const waivers = (h.leakAllow ?? []).length + (globalAllowFile() != null ? 1 : 0)
     const leakAllowState = waivers === 0 ? '' : `, ${(h.leakAllow ?? []).length} repo waiver(s)${globalAllowFile() == null ? '' : ' + ~/.shipkit/private/leak-allow.json'}`
+    const messageOff = offWord('commit-message')
     return [
         `pre-commit  leak-guard${leakState} — staged added lines + paths vs ${kw} + ~/.shipkit/private/banned-keywords.txt${leakAllowState}`,
-        ...((h.blockedPaths ?? []).length > 0 ? [`pre-commit  blocked-paths — nothing under ${h.blockedPaths!.join(', ')} enters git${draftsOpen(config) && blockedStaged([COMFY_DRAFTS], config).length === 0 && h.blockedPaths!.some((p) => COMFY_DRAFTS.startsWith(p)) ? `, except ${COMFY_DRAFTS} (declared private)` : ''}`] : []),
-        `pre-commit  root-identity${off.has('root-identity') ? ' (DISABLED by config)' : ''} — the repo's own name in package.json + repo.config.ts, and scratch files`,
+        ...((h.blockedPaths ?? []).length > 0 ? [`pre-commit  blocked-paths${offWord('blocked-paths')} — nothing under ${h.blockedPaths!.join(', ')} enters git${draftsOpen(config) && blockedStaged([COMFY_DRAFTS], config).length === 0 && h.blockedPaths!.some((p) => COMFY_DRAFTS.startsWith(p)) ? `, except ${COMFY_DRAFTS} (declared private)` : ''}`] : []),
+        `pre-commit  root-identity${offWord('root-identity')} — the repo's own name in package.json + repo.config.ts, and scratch files`,
+        `pre-commit  tree-shrink${offWord('tree-shrink')} — the commit keeps at least half of HEAD's files (${ALLOW_MASS_DELETE}=1 lifts it for one commit)`,
         ...checks.map((c) => `pre-commit  ${c.id} — the check, onPreCommit, budget ${c.budgetMs}ms`),
         ...(h.preCommit ?? []).map((c) => `pre-commit  ${c.id} — ${c.cmd.join(' ')}`),
-        off.has('commit-message')
-            ? `commit-msg  commit-message (DISABLED by config) — dash punctuation + French; ai-attribution stays on, never disabled`
-            : `commit-msg  commit-message — dash punctuation + AI attribution (never disabled) + French${off.has('commit-language') ? ' (commit-language DISABLED by config)' : ''}`,
+        messageOff !== ''
+            ? `commit-msg  commit-message${messageOff} — dash punctuation + French`
+            : `commit-msg  commit-message — dash punctuation + French${offWord('commit-language') === '' ? '' : ` (commit-language${offWord('commit-language')})`}`,
         `commit-msg  leak-guard${leakState} — the message text`,
         ...(h.commitMsg ?? []).map((c) => `commit-msg  ${c.id} — ${c.cmd.join(' ')}`),
     ]