rvlib-shipkit 1.9.0 → 2.0.1

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(' ')}`),
     ]

package/src/hooks/staged.ts

@@ -0,0 +1,49 @@
+// what this commit changes against HEAD, listed ONCE for every git based
+// step of the pre-commit gate: each step spawning its own `git diff --cached`
+// costs a process start per step on every commit. Every call inherits the
+// environment, so a commit made under a private GIT_INDEX_FILE is read from
+// that same index, which is the one git is about to commit.
+import { gitBin } from '../core/git-bin.ts'
+import { gitRoot } from '../core/git-root.ts'
+
+/** one staged change: git's status letter (A, M, D, R, C, T, U), the path as
+ *  `--name-only` prints it, and for a rename or a copy the path it came from */
+export type StagedEntry = { status: string; path: string; from?: string }
+
+export type Staged = {
+    /** HEAD resolves: false on the first commit of a repo */
+    head: boolean
+    entries: StagedEntry[]
+    /** every staged path, in git's order */
+    names: string[]
+}
+
+/** `git diff --cached --name-status -z`: a status field, then one path, or
+ *  two for a rename or a copy. NUL separated, so no path is ever quoted */
+export function parseNameStatus(out: string): StagedEntry[] {
+    const f = out.split('\0')
+    const entries: StagedEntry[] = []
+    for (let i = 0; i < f.length; ) {
+        const status = f[i++] ?? ''
+        if (status === '') break
+        const letter = status[0]!
+        if (letter === 'R' || letter === 'C') {
+            const from = f[i++] ?? ''
+            entries.push({ status: letter, path: f[i++] ?? '', from })
+        } else entries.push({ status: letter, path: f[i++] ?? '' })
+    }
+    return entries
+}
+
+export function readStaged(root: string): Staged {
+    if (gitRoot(root) == null) return { head: false, entries: [], names: [] }
+    // the env is passed on purpose: Bun's default is the environment the
+    // process started with, never one a caller set since
+    const head = Bun.spawnSync([gitBin(), 'rev-parse', '--verify', '-q', 'HEAD'], { cwd: root, env: process.env, stdout: 'ignore', stderr: 'ignore' }).exitCode === 0
+    const p = Bun.spawnSync([gitBin(), 'diff', '--cached', '--name-status', '-z'], { cwd: root, env: process.env, maxBuffer: 64 * 1024 * 1024 })
+    // an unreadable index is no answer, and every gate below would read it as
+    // "nothing staged" and pass
+    if (p.exitCode !== 0) throw new Error(`git diff --cached exited ${p.exitCode}: ${p.stderr.toString().trim().split('\n')[0] ?? ''}`)
+    const entries = parseNameStatus(p.stdout.toString())
+    return { head, entries, names: entries.map((e) => e.path) }
+}

package/src/hooks/tree-shrink.ts

@@ -0,0 +1,41 @@
+// a commit must not drop most of the tree.
+//
+// the failure this exists for: a commit made from a private GIT_INDEX_FILE
+// that was never filled with `git read-tree HEAD` holds only the files staged
+// into it, so git records every other file as deleted and the tree comes out
+// near empty. Every other gate passes, because nothing it reads is wrong.
+import type { Staged } from './staged.ts'
+import { gitBin } from '../core/git-bin.ts'
+
+export const ALLOW_MASS_DELETE = 'SHIPKIT_ALLOW_MASS_DELETE'
+
+export type ShrinkOutcome =
+    | { status: 'skipped'; reason: string }
+    | { status: 'clean' }
+    | { status: 'shrunk'; headFiles: number; stagedFiles: number; deleted: number }
+
+/** the decision, with no git in it. `headFiles` is asked for only when the
+ *  commit removes more files than it adds, so an ordinary commit pays nothing */
+export function shrinkVerdict(staged: Staged, headFiles: () => number): ShrinkOutcome {
+    if (!staged.head) return { status: 'skipped', reason: 'no HEAD yet, nothing to shrink' }
+    let deleted = 0
+    let added = 0
+    for (const e of staged.entries) {
+        if (e.status === 'D') deleted++
+        else if (e.status === 'A' || e.status === 'C') added++
+    }
+    if (deleted <= added) return { status: 'clean' }
+    const before = headFiles()
+    const after = before - deleted + added
+    if (after * 2 >= before) return { status: 'clean' }
+    if (process.env[ALLOW_MASS_DELETE] === '1') return { status: 'skipped', reason: `${ALLOW_MASS_DELETE}=1` }
+    return { status: 'shrunk', headFiles: before, stagedFiles: after, deleted }
+}
+
+export function headFileCount(root: string): number {
+    const p = Bun.spawnSync([gitBin(), 'ls-tree', '-r', '-z', '--name-only', '--full-tree', 'HEAD'], { cwd: root, env: process.env, maxBuffer: 256 * 1024 * 1024 })
+    if (p.exitCode !== 0) throw new Error(`git ls-tree HEAD exited ${p.exitCode}: ${p.stderr.toString().trim().split('\n')[0] ?? ''}`)
+    return p.stdout.toString().split('\0').filter(Boolean).length
+}
+
+export const runTreeShrink = (root: string, staged: Staged): ShrinkOutcome => shrinkVerdict(staged, () => headFileCount(root))

package/src/init-repo.ts

@@ -17,9 +17,6 @@ import { reportToMotherhome } from './core/motherhome.ts'
 import { ensureGitRepo, publishRepo, type Run } from './git-bootstrap.ts'
 import { defineRepo, loadRepoConfig, resolveFloor } from './repo-config.ts'
 import { gitignorePolicy } from './checks/SK004-gitignore-policy.check.ts'
-import { vscodeHubTask } from './checks/SK017-vscode-hub-task.check.ts'
-import { editorErgonomics } from './scaffold/project-scaffold.ts'
-import { defaultHubPort } from './serve/hub-port.ts'
 
 // This lands as SOURCE in the repo being wired, so its comments answer to that
 // repo's comment style, not to this file's. Dash punctuation is banned there
@@ -105,7 +102,6 @@ export async function initRepo(root: string, opts: InitOpts = {}): Promise<numbe
         // the repos that need ONE WAY IN most are the ones that already exist,
         // so a re-run REPAIRS rather than only seeding a fresh checkout
         await repairOneWayIn(root, cfg, p)
-        await furnishEditor(root, cfg, p)
         const mh = reportToMotherhome(root, cfg)
         if (mh.note != null) p(mh.note)
         if (wired && opts.noPublish !== true) await publishRepo(root, { github: opts.github, gh: opts.gh, print: p })
@@ -139,7 +135,6 @@ export async function initRepo(root: string, opts: InitOpts = {}): Promise<numbe
     const g = await gitignorePolicy.repair!(CheckCtx.open({ root, config: defineRepo({ name }) }))
     p(`ok: .gitignore policy block ${g.changed ? 'written' : 'already current'}`)
     await repairOneWayIn(root, defineRepo({ name }), p)
-    await furnishEditor(root, { name }, p)
     // what the gate actually runs, in ONE line: a thin floor must be seen at
     // init time rather than discovered after a bad commit slipped through.
     // The per-task resolution is diagnostics, and a `skip:` naming a script
@@ -170,43 +165,6 @@ export async function initRepo(root: string, opts: InitOpts = {}): Promise<numbe
     return 0
 }
 
-/** the folder-open story, on the adopt path as well as the start one.
- *
- *  `start` scaffolds the whole day-one shape, but only for a dir with no
- *  commit history, so every repo that already existed when it was wired got
- *  repo.config.ts and the scripts and no .vscode/ at all: opening the folder
- *  started nothing, and the hub the config advertises had no way in. These two
- *  files are the only half of that scaffold an adopted repo can be handed
- *  unasked, because they change no output of any command (project-scaffold.ts
- *  owns the line). Create-only, so a .vscode/ the repo brought with it wins. */
-async function furnishEditor(root: string, cfg: { name?: string; serve?: { port?: number } }, p: (line: string) => void): Promise<void> {
-    // the least important thing init does, and it runs AFTER repo.config.ts is
-    // on disk: an unwritable .vscode (a read-only tree, a path that is a file),
-    // or a config with no name at all, must not abort the run before the
-    // publish chain, and must not pass in silence either. The port resolution
-    // is INSIDE the try for that reason: it reads a config nothing validates
-    try {
-        const name = repoName(root, undefined, cfg.name)
-        const port = cfg.serve?.port ?? defaultHubPort(name)
-        if (editorErgonomics(root, { name, port }).length === 0) {
-            // the repo's own file stays its own, except the hub task, which
-            // rule SK017 keeps feeding the problems pane
-            // a file SK017 cannot read is still the repo's own: it is never
-            // reported as missing, and it is never rewritten
-            let hub: { changed: boolean; summary: string }
-            try { hub = await vscodeHubTask.repair!(CheckCtx.open({ root, config: defineRepo({ name }) })) } catch (e) {
-                p('ok: .vscode/ is this repo\'s own, left untouched')
-                return void p(`WARN .vscode/tasks.json does not parse (${e instanceof Error ? e.message : String(e)}): the hub task gets no problem matcher until it does`)
-            }
-            return void p(hub.changed ? `ok: ${hub.summary}` : 'ok: .vscode/ is this repo\'s own, left untouched')
-        }
-        p(`ok: .vscode/tasks.json written — opening the folder starts the hub on ${port}`)
-        p('      next: add this stack\'s own watchers (dev server, css) — build/vscode-tasks.md carries the shapes')
-    } catch (e) {
-        p(`WARN no .vscode/tasks.json here: ${e instanceof Error ? e.message : String(e)} — opening the folder starts nothing, everything else landed`)
-    }
-}
-
 /** ONE WAY IN, both halves, through the SAME fixers `shipkit check --fix` runs
  *  (build/shipkit/one-way-in.md). Nothing here is a second implementation: rule SK001
  *  routes the package.json scripts, rule SK013 writes the harness policy, and

package/src/ledger/check-table.ts

@@ -87,7 +87,7 @@ export function renderCheckTable(input: CheckTableInput): string {
     body.push('')
     body.push(`Everything \`shipkit ci\` and \`shipkit check\` know how to run: ${builds} build step(s) the gate alone runs, ${rows.length - builds} the health pass reports too. ${shipped} ship with the toolkit, ${rows.length - shipped} belong to this repo.`)
     body.push('')
-    body.push('- **runs in** — `always` means every `shipkit ci` runs it, so a red one says THIS change is broken. `release` means the quick gate leaves it out and `shipkit ci --full` plus the release path run it. `health` means only the health pass (`shipkit check`) runs it: it reports the world (a box that is off, a cred nobody minted, a page nobody refreshed), it can sit red for months with nothing wrong, and it never stands between you and a commit. `off` means this repo turned it off on purpose, and the reason is in `repo.config.ts when`.')
+    body.push('- **runs in** — `always` means every `shipkit ci` runs it, so a red one says THIS change is broken. `release` means the quick gate leaves it out and `shipkit ci --full` plus the release path run it. `health` means only the health pass (`shipkit check`) runs it: it reports the world (a box that is off, a cred nobody minted, a page nobody refreshed), it can sit red for months with nothing wrong, and it never stands between you and a commit. `commit` means a git hook runs it on every commit (`shipkit hooks list`). `off` means this repo turned it off on purpose, and the reason is in `repo.config.ts off`.')
     body.push('- **build** — `yes` means the gate alone runs it: it BUILDS (a compiler, a test suite, a bundler), so `shipkit check` leaves it out and reports everything else. A floor slot derives it from the package.json script behind it, and a `*.check.ts` declares it with `build: true`.')
     body.push('- **on failure** — `blocks` stops the run. `warns` prints and carries on. `UNDECLARED` is a defect, not a setting: the check never said and the repo set no default, so the runner treats it as fatal by guess.')
     body.push('- **cache** — `content` is cached while the files it reads are untouched. `world` is cached for its TTL, and a RED that ran is cached too, capped at one hour so the run after a fix sees the fix. `never` runs every time and somebody wrote down why. `UNDECLARED` runs every time and nobody has looked yet, which is the burn-down (`shipkit keys --burn-down`). `SHIPKIT_FRESH=1` busts all of it.')