rvlib-shipkit 0.18.0 → 0.19.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.19.0
+
+- **The attribution tell list covers session trailers and assistant share urls.** `<assistant>-Session:` trailers (claude, chatgpt, copilot, cursor, aider, devin, gemini, codex) and claude.ai/claude.com/chatgpt.com/chat.openai.com urls now trip the shared predicate (commit-msg hook + SK009 history scan). Field case: 162 session links sat in a history both gates called clean.
+- **SK009 scans ref names too**, local and remote-tracking. A checkpoint tag named after an assistant (`FABLE-checkpoint-3`) outs the agent as loudly as a trailer. Bare match only for names with no other meaning (claude, chatgpt, copilot, aider, devin); vendor and codename words (cursor, openai, gemini, fable, sonnet, haiku, opus) name legitimate branches, so they only match in a `-checkpoint`/`-session` shape.
+- **The leak guard reads a machine-global list.** Every run also scans `~/.rv-private/banned-keywords.txt` when it exists: one private list per machine, armed in every repo at once, never copied into a repo (a copy rots and a copy can leak). `hooks install` seeds the repo's own configured keyword file with generic secret-shape starters, never touching an existing one. Both files absent stays a loud skip.
+- **The itch listing answered-check catches empty fields.** A `## field` heading with no body line under it is an unanswered field wearing no `<placeholder>`; the contract names it now. Prose-level open decisions stay a human read.
+
 ## 0.18.0
 
 - **The comfy backend runs on comfy-ts.** `.rv-comfy/workflows/` holds `*.cflow.ts` workflow modules (one `host.defineWorkflow` per graph family, plus a `_host.ts` the modules import). Exported json graphs and `.ts` sidekick pairs are gone, and the raw HTTP engine (`comfy-gen.ts`) and pair loader (`workflow-loader.ts`) are deleted with them. Every module must declare `vars.prompt` (`v.prompt`) and `vars.seed` (`v.seed`), shipkit drives both.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rvlib-shipkit",
-    "version": "0.18.0",
+    "version": "0.19.0",
     "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",
     "type": "module",

package/src/cli/cmd_Hooks.ts

@@ -20,7 +20,8 @@ export class HooksInstallCommand extends Command {
     bin = Option.String('--bin', 'bunx rvlib-shipkit', { description: 'how the hook body invokes shipkit (in-repo consumers pass `bun <path to cli.ts>`)' })
 
     async execute(): Promise<number> {
-        const r = installHooks(process.cwd(), this.bin)
+        const config = await loadRepoConfig(process.cwd()).catch(() => null)
+        const r = installHooks(process.cwd(), this.bin, config?.hooks?.keywordFile)
         for (const w of r.written) this.context.stdout.write(`ok: wrote ${w}\n`)
         if (r.written.length === 0) this.context.stdout.write('ok: hook bodies already current\n')
         this.context.stdout.write(`${r.note.startsWith('WARN') ? r.note : `ok: ${r.note}`}\n`)

package/src/contracts/manifests/itch.contract.ts

@@ -21,8 +21,24 @@ export default defineContract({
         custom('.rv-itch/listing.md answered', (env) => {
             const p = join(env.root, '.rv-itch/listing.md')
             if (!existsSync(p)) return []
-            const left = [...readFileSync(p, 'utf8').matchAll(/<[a-z][^<>\n]{2,60}>/g)].map((m) => m[0])
-            return left.length === 0 ? [] : [`.rv-itch/listing.md still holds ${left.length} unanswered placeholder(s): ${[...new Set(left)].slice(0, 3).join(' ')} — it is pasted into the store form as-is`]
+            const text = readFileSync(p, 'utf8')
+            const out: string[] = []
+            const left = [...text.matchAll(/<[a-z][^<>\n]{2,60}>/g)].map((m) => m[0])
+            if (left.length > 0) out.push(`.rv-itch/listing.md still holds ${left.length} unanswered placeholder(s): ${[...new Set(left)].slice(0, 3).join(' ')} — it is pasted into the store form as-is`)
+            // a heading with an EMPTY body is an unanswered field wearing no
+            // placeholder (prose-level open decisions stay a human read).
+            // fenced blocks stripped first (a ## inside one is not a field),
+            // and an inline `## Field: answer` heading counts as answered
+            const sections = text.replace(/^```[\s\S]*?^```/gm, '').split(/^## /m).slice(1)
+            const empty = sections
+                .filter((s) => {
+                    const [head = '', ...body] = s.split('\n')
+                    const inline = head.includes(':') && head.slice(head.indexOf(':') + 1).trim() !== ''
+                    return !inline && body.every((l) => l.trim() === '')
+                })
+                .map((s) => s.split('\n')[0]!.trim())
+            if (empty.length > 0) out.push(`.rv-itch/listing.md field(s) with no answer under the heading: ${empty.slice(0, 3).join(', ')}${empty.length > 3 ? ' …' : ''}`)
+            return out
         }),
         // itch DISPLAYS 630x500 and accepts larger — atLeast, never exact-size
         png('.rv-itch/cover.png', 630, 500, { atLeast: true }),

package/src/hooks/commit-message.ts

@@ -7,9 +7,12 @@
 export type OffenseKind = 'dash' | 'attribution'
 export type Offense = { line: number; text: string; kind: OffenseKind; why: string }
 
-/** trailers and footers that name an assistant, plus the robot emoji. */
+/** 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|🤖/i
+    /(?: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. */
@@ -33,7 +36,7 @@ export function commitMessageOffenses(message: string): Offense[] {
         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, "Generated with" footer, or robot emoji' })
+            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' })
     })
     return offenses
 }

package/src/hooks/leak-guard.ts

@@ -46,13 +46,24 @@ export type LeakGuardOpts = {
     staged?: boolean
 }
 
+/** the machine-global list every repo's guard also reads: one private list
+ *  per machine, never copied into a repo (a copy rots, and a not-yet-ignored
+ *  .rv-private/ would make the list itself committable). */
+export function globalKeywordFile(): string | null {
+    const home = process.env.HOME ?? ''
+    if (home === '') return null
+    const p = join(home, '.rv-private', 'banned-keywords.txt')
+    return existsSync(p) ? p : null
+}
+
 export function runLeakGuard(root: string, o: LeakGuardOpts = {}): LeakGuardResult {
     const rel = o.keywordFile ?? '.rv-private/banned-keywords.txt'
     const file = join(root, rel)
-    if (!existsSync(file)) return { status: 'skipped', reason: `${rel} not found — no keyword list, no leak guard` }
-    const patterns = parsePatterns(readFileSync(file, 'utf8'))
+    const sources = [existsSync(file) ? file : null, globalKeywordFile()].filter((f): f is string => f != null)
+    if (sources.length === 0) return { status: 'skipped', reason: `${rel} not found and no ~/.rv-private/banned-keywords.txt — no keyword list, no leak guard` }
+    const patterns = parsePatterns(sources.map((f) => readFileSync(f, 'utf8')).join('\n'))
     const count = patterns.substrings.length + patterns.regexes.length
-    if (count === 0) return { status: 'skipped', reason: `${rel} has no patterns` }
+    if (count === 0) return { status: 'skipped', reason: `keyword file(s) have no patterns (${sources.join(', ')})` }
 
     const hits: LeakHit[] = []
     if (o.staged !== false) {

package/src/hooks/run-hooks.ts

@@ -4,9 +4,9 @@
 // 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, writeFileSync } from 'fs'
-import { join } from 'path'
+import { dirname, join } from 'path'
 import { commitMessageOffenses } from './commit-message.ts'
-import { runLeakGuard } from './leak-guard.ts'
+import { globalKeywordFile, runLeakGuard } from './leak-guard.ts'
 import { runRootIdentity } from './root-identity.ts'
 import { spawnWithTimeout } from '../core/spawn-timeout.ts'
 import type { RepoConfig } from '../repo-config.ts'
@@ -30,8 +30,9 @@ export type HooksConfig = {
 const HOOK_DIR = 'hooks'
 const HOOKS = ['pre-commit', 'commit-msg'] as const
 
-/** wire `core.hooksPath` and write the two hook bodies. Idempotent. */
-export function installHooks(root: string, binInvocation: string): { written: string[]; note: string } {
+/** wire `core.hooksPath` and write the two hook bodies. Idempotent.
+ *  `keywordFile` = the repo's configured leak-guard file, seeding target. */
+export function installHooks(root: string, binInvocation: string, keywordFile?: string): { written: string[]; note: string } {
     const dir = join(root, HOOK_DIR)
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
     const written: string[] = []
@@ -44,12 +45,41 @@ export function installHooks(root: string, binInvocation: string): { written: st
         if (prev !== body) { writeFileSync(path, body, { mode: 0o755 }); written.push(`${HOOK_DIR}/${h}`) }
     }
     const cfg = Bun.spawnSync(['git', 'config', 'core.hooksPath', HOOK_DIR], { cwd: root })
+    const seeded = seedKeywordFile(root, keywordFile)
+    if (seeded != null) written.push(seeded)
     return {
         written,
         note: cfg.exitCode === 0 ? `core.hooksPath=${HOOK_DIR}` : `WARN could not set core.hooksPath (exit ${cfg.exitCode}) — hooks will not fire`,
     }
 }
 
+// a starter so the leak guard bites from day one instead of skipping forever:
+// generic secret shapes only. private names live in the machine-global
+// ~/.rv-private/banned-keywords.txt, which the guard reads on every run
+// (never copied into a repo: a copy rots and a copy can leak)
+const KEYWORD_STARTER = `# banned-keywords — the leak guard greps every commit (added lines, paths,
+# message) for these rows. one row = one case-insensitive substring, or
+# re:<regex>. add repo-specific names here; machine-wide private names go in
+# ~/.rv-private/banned-keywords.txt, read automatically alongside this file.
+# this file is gitignored on purpose: the list itself is private.
+re:-----BEGIN [A-Z ]*PRIVATE KEY-----
+re:AKIA[0-9A-Z]{16}
+re:sk-[A-Za-z0-9_-]{20,}
+re:ghp_[A-Za-z0-9]{36}
+re:xox[baprs]-[A-Za-z0-9-]{10,}
+`
+
+/** seed the configured keyword file with the generic starter so the guard is
+ *  ARMED, not a skip. an existing file is never touched. */
+function seedKeywordFile(root: string, keywordFile?: string): string | null {
+    const rel = keywordFile ?? '.rv-private/banned-keywords.txt'
+    const dest = join(root, rel)
+    if (existsSync(dest)) return null
+    mkdirSync(dirname(dest), { recursive: true })
+    writeFileSync(dest, KEYWORD_STARTER)
+    return `${rel} (starter shapes)`
+}
+
 export type GateOutcome = { id: string; ok: boolean; lines: string[] }
 
 /** the pre-commit gate: built-in leak guard, then the repo's own commands. */
@@ -156,9 +186,9 @@ export function listGates(config: RepoConfig, root = process.cwd()): string[] {
     const kw = h.keywordFile ?? '.rv-private/banned-keywords.txt'
     // 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)) ? '' : ` (INACTIVE, ${kw} absent)`
+    const leakState = off.has('leak-guard') ? ' (DISABLED by config)' : existsSync(join(root, kw)) || globalKeywordFile() != null ? '' : ` (INACTIVE, ${kw} absent and no ~/.rv-private list)`
     return [
-        `pre-commit  leak-guard${leakState} — staged content + paths vs ${kw}`,
+        `pre-commit  leak-guard${leakState} — staged added lines + paths vs ${kw} + ~/.rv-private/banned-keywords.txt`,
         ...((h.blockedPaths ?? []).length > 0 ? [`pre-commit  blocked-paths — nothing under ${h.blockedPaths!.join(', ')} enters git`] : []),
         `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.preCommit ?? []).map((c) => `pre-commit  ${c.id} — ${c.cmd.join(' ')}`),

package/src/rules/SK009-commit-ai-tells.ts

@@ -53,14 +53,25 @@ export const commitAiTells: Rule = {
         const sample = (hits: { hash: string }[]): string => hits.slice(0, 5).map((h) => h.hash).join(' ') + (hits.length > 5 ? ' …' : '')
         const attributed = commits.filter((c) => hasAiAttribution(c.body))
         const dashed = commits.filter((c) => hasDashPunctuation(c.body))
+        // ref NAMES tell too (a FABLE-checkpoint-3 tag outs the agent as
+        // loudly as a trailer). bare match only for names with no other
+        // meaning; vendor and codename words (cursor, openai, gemini, opus,
+        // fable, …) name legitimate branches and features, they only match in
+        // a checkpoint/session shape
+        const refTell = /\b(?:claude|chatgpt|copilot|aider|devin)\b|(?:^|[-_/])(?:fable|sonnet|haiku|opus|gemini|codex)[-_](?:checkpoint|session|ckpt)/i
+        const refs = await t.exec(['git', 'for-each-ref', '--format=%(refname:short)', 'refs/tags', 'refs/heads', 'refs/remotes'], { cwd: env.root, timeoutMs: 30_000 })
+        if (refs.code !== 0) t.lines.push({ kind: 'skip', text: `ref names unverifiable — git for-each-ref exit ${refs.code}` })
+        const tellRefs = refs.code === 0 ? refs.out.split('\n').map((r) => r.trim()).filter((r) => r !== '' && refTell.test(r)) : []
+        if (tellRefs.length > 0)
+            t.fail(`${tellRefs.length} ref name(s) carry an AI tell in a declared-public repo (${tellRefs.slice(0, 5).join(' ')}${tellRefs.length > 5 ? ' …' : ''}) — rename or delete the refs before the flip; a pushed tag also needs the remote delete`)
         if (attributed.length > 0)
-            t.fail(`${attributed.length}/${commits.length} commits carry AI attribution (a trailer naming an assistant / "Generated with" / 🤖) in a declared-public repo — e.g. ${sample(attributed)}; ${remedy}`)
+            t.fail(`${attributed.length}/${commits.length} commits carry AI attribution (a trailer naming an assistant / a session trailer or claude.ai url / "Generated with" / 🤖) in a declared-public repo — e.g. ${sample(attributed)}; ${remedy}`)
         if (dashed.length > 0)
             t.fail(`${dashed.length}/${commits.length} commit messages carry dash punctuation (em/en dash or inline " - ") in a declared-public repo — e.g. ${sample(dashed)}; ${remedy} (identity/writing-voice.md owns the punctuation rule)`)
         const silenced = attributionSilenced(env.root)
         if (!silenced)
             t.fail(`.claude/settings.json does not silence AI attribution — track it with {"attribution": {"commit": "", "pr": ""}} so no agent's harness ever writes the trailer or the PR footer`)
-        if (attributed.length === 0 && dashed.length === 0 && silenced)
-            t.ok(`${commits.length} commits scanned, attribution silenced in .claude/settings.json — no AI tells`)
+        if (attributed.length === 0 && dashed.length === 0 && tellRefs.length === 0 && silenced)
+            t.ok(`${commits.length} commits + ${refs.code === 0 ? refs.out.split('\n').filter((r) => r.trim() !== '').length : 0} ref names scanned, attribution silenced in .claude/settings.json — no AI tells`)
     },
 }