no-yolo-commits 1.0.3 → 1.2.0

package/README.md

@@ -11,12 +11,13 @@ This stops that.
 npx no-yolo-commits init
 ```
 
-One command. Two things happen on every commit from now on:
+One command. On every commit from now on:
 
-1. **An AI actually reads your diff** (via the [`claude`](https://claude.com/claude-code) CLI) and blocks the commit — but only for real, high-confidence problems. Not vibes, not "you could refactor this." Type-safety holes, bugs that will actually bite, broken framework patterns. If the reviewer is missing, slow, or having a bad day, it fails **open** — a flaky linter should never be the reason your commit is stuck.
-2. **`main` and `master` become look-but-don't-touch.** Try to commit straight there and instead of yelling at you, it just... makes you a branch. `ACME-1788716508-fix-the-thing-you-were-actually-fixing`, ready to go, commit already on it. You didn't even have to think of a branch name — the AI wrote that from your diff too.
+1. **A secret scan runs first, always.** Private keys, AWS/Slack-shaped tokens, a staged `.env` — caught with plain regex, zero dependency on any AI CLI being installed or working. Blocks by default; a leaked credential isn't the kind of mistake you want an "unavailable reviewer" to quietly let through.
+2. **An AI actually reads your diff** (via the [`claude`](https://claude.com/claude-code) CLI) and blocks the commit — but only for real, high-confidence problems. Not vibes, not "you could refactor this." If the reviewer is missing, slow, or having a bad day, it fails **open** — a flaky reviewer should never be the reason your commit is stuck. Skipped automatically when everything staged is a lockfile or generated asset, so bumping `package-lock.json` doesn't cost you a 2-minute wait.
+3. **`main`/`master` become look-but-don't-touch.** Commit straight there and instead of yelling at you, it just makes you a branch — `ACME-1788716508-fix-the-thing-you-were-actually-fixing`, ready to go, commit already on it. It even wrote the branch name from your diff.
 
-No dashboard. No config file to argue with. No dependencies at runtime — it's a ~150-line shell script wearing a `husky` trenchcoat.
+No dashboard. No config file to argue with. No runtime dependencies — it's shell scripts wearing a [husky](https://typicode.github.io/husky/) trenchcoat.
 
 ## Install
 
@@ -24,27 +25,64 @@ No dashboard. No config file to argue with. No dependencies at runtime — it's
 npx no-yolo-commits init
 ```
 
-That's the whole install. It will, in order:
+That's the whole install, per project. It will, in order:
 
 - add `husky` as a devDependency (if you don't have it)
 - set `"scripts.prepare": "husky"` in `package.json`
 - drop `.husky/pre-commit` into your repo
 
+### Or install it once, everywhere
+
+If you're the "I have thirty repos and I am not doing this thirty times" type:
+
+```bash
+npx no-yolo-commits init --global
+```
+
+This wires up git's own [hook template mechanism](https://git-scm.com/docs/git-init#_template_directory) (`git config --global init.templateDir`) — every `git init` and `git clone` from then on gets the hook automatically, no husky, no per-project npm install. The branch prefix is derived per-repo at commit time (since one script now serves every project you touch): the first 3 letters of `package.json`'s `name` (scope dropped, e.g. `@acme/widgets` → `WID`) if there is one, otherwise the repo's folder name.
+
+Already-cloned repos won't retroactively pick it up — re-run `git init` inside one (safe, doesn't touch history or remotes) to copy it in. A project that later runs the regular per-project `init` gets its own `.husky/pre-commit`, which takes precedence over the global hook.
+
 ## Make it yours
 
 ```bash
 npx no-yolo-commits init \
   --prefix=ACME \
   --stack="Next.js + TypeScript + Postgres" \
-  --protect=main,master,release
+  --protect=main,master,release \
+  --model=haiku
 ```
 
 | Flag | Default | Does what it says |
 |---|---|---|
-| `--prefix` | your `package.json` name, shouted in caps | prefix for the auto-branch name |
+| `--prefix` | your `package.json` name, shouted in caps (or `AUTO`, per-repo, in `--global` mode) | prefix for the auto-branch name |
 | `--stack` | `TypeScript` | tells the reviewer what it's actually looking at, so findings are relevant instead of generic |
 | `--protect` | `main,master` | which branches you're not allowed to just casually commit to |
-| `--force`, `-f` | off | steamroll an existing `.husky/pre-commit` |
+| `--model` | claude's default | passed through as `--model <name>` to every `claude` call — point it at a cheaper/faster model if you commit a lot |
+| `--global`, `-g` | off | install into git's global hook template instead of this one project |
+| `--force`, `-f` | off | steamroll an existing hook |
+
+## Also enforce it in CI
+
+A local hook is a courtesy, not a wall — `--no-verify` exists, and a fresh clone hasn't run `npm install` yet. For the same checks on every pull request regardless of what happened locally:
+
+```yaml
+# .github/workflows/no-yolo-commits.yml
+on: pull_request
+jobs:
+  review:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: ataztech910/no-yolo-commits@main
+        with:
+          anthropic-api-key: ${{ secrets.ANTHROPIC_API_KEY }}
+          stack: "Next.js + TypeScript + Postgres"
+```
+
+Same secret scan, same AI review, run against the PR's diff against its base branch — annotated inline on the PR, fails the check on real findings.
 
 ## The eject button
 
@@ -58,7 +96,7 @@ No questions asked. No shame either — that's what it's there for.
 
 ## Why this exists
 
-Because I kept copy-pasting the same `.husky/pre-commit` into every new project and hand-editing the branch prefix like some kind of caveman. Now it's `npx` and thirty seconds.
+Because I kept copy-pasting the same `.husky/pre-commit` into every new project and hand-editing the branch prefix like some kind of caveman. Now it's `npx` and thirty seconds — and it reviews its own commits, because it would be pretty funny if it didn't.
 
 ## License
 

package/bin/cli.js

@@ -3,7 +3,8 @@
 
 const fs = require('fs');
 const path = require('path');
-const { execSync, spawnSync } = require('child_process');
+const os = require('os');
+const { spawnSync } = require('child_process');
 
 const CWD = process.cwd();
 
@@ -13,14 +14,24 @@ function fail(msg) {
 }
 
 function parseArgs(argv) {
-  const args = { command: 'init', prefix: null, stack: 'TypeScript', protect: 'main,master', force: false };
+  const args = {
+    command: 'init',
+    prefix: null,
+    stack: 'TypeScript',
+    protect: 'main,master',
+    model: null,
+    global: false,
+    force: false,
+  };
   const rest = [];
   for (const a of argv) {
     if (a === '--force' || a === '-f') args.force = true;
+    else if (a === '--global' || a === '-g') args.global = true;
     else if (a === '--help' || a === '-h') args.command = 'help';
     else if (a.startsWith('--prefix=')) args.prefix = a.slice('--prefix='.length);
     else if (a.startsWith('--stack=')) args.stack = a.slice('--stack='.length);
     else if (a.startsWith('--protect=')) args.protect = a.slice('--protect='.length);
+    else if (a.startsWith('--model=')) args.model = a.slice('--model='.length);
     else rest.push(a);
   }
   if (rest[0]) args.command = rest[0];
@@ -31,58 +42,89 @@ function printHelp() {
   console.log(`no-yolo-commits — an AI pre-commit reviewer + "no direct commits to main" guard
 
 Usage:
-  npx no-yolo-commits init [options]
+  npx no-yolo-commits init [options]          per-project install (via husky)
+  npx no-yolo-commits init --global [options]  install once, applies to every
+                                                new \`git init\`/\`git clone\`
 
 Options:
-  --prefix=NAME      Branch prefix used when auto-creating a branch off a
-                      protected branch, e.g. --prefix=ACME -> ACME-<ts>-<slug>
-                      (default: derived from package.json "name")
+  --prefix=NAME      Branch prefix for auto-created branches, e.g.
+                      --prefix=ACME -> ACME-<ts>-<slug>. In --global mode
+                      this defaults to AUTO (derived from each repo's
+                      directory name at commit time, since one global script
+                      serves many repos); per-project it defaults to your
+                      package.json "name".
   --stack=TEXT        One-line description of the project handed to the AI
                       reviewer, e.g. --stack="Next.js + TypeScript + Postgres"
                       (default: "TypeScript")
   --protect=a,b,c     Comma-separated branch names that block direct commits
                       (default: "main,master")
-  --force, -f         Overwrite an existing .husky/pre-commit
+  --model=NAME        Pass --model NAME through to every \`claude\` invocation
+                      (cost/speed control — e.g. --model=haiku)
+  --global, -g        Install into git's global hook template
+                      (~/.git-templates by default, or your existing
+                      \`git config --global init.templateDir\`) instead of
+                      this one project. Existing repos need \`git init\`
+                      re-run inside them to pick it up; a project that later
+                      runs the per-project \`init\` (husky) takes precedence
+                      over the global hook.
+  --force, -f         Overwrite an existing hook
   --help, -h          Show this help
 
+Every commit also gets a zero-dependency secret scan (private keys, AWS/Slack
+tokens, staged .env files, etc.) that blocks regardless of whether \`claude\`
+is installed.
+
 Requires the \`claude\` CLI on PATH to actually run the AI review — if it's
 missing, the hook warns and lets the commit through (fails open).`);
 }
 
-function readPackageJson() {
-  const pkgPath = path.join(CWD, 'package.json');
-  if (!fs.existsSync(pkgPath)) {
-    fail('No package.json in the current directory — run this from your project root.');
-  }
-  return { pkgPath, pkg: JSON.parse(fs.readFileSync(pkgPath, 'utf8')) };
+function slugifyPrefix(name) {
+  return (
+    (name || 'wip')
+      .replace(/^@[^/]+\//, '') // drop npm scope
+      .toUpperCase()
+      .replace(/[^A-Z0-9]+/g, '')
+      .slice(0, 12) || 'WIP'
+  );
 }
 
-function ensureGitRepo() {
-  const result = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: CWD, stdio: 'pipe' });
-  if (result.status !== 0) {
-    fail('Not a git repository — run `git init` first.');
-  }
-}
+function buildHookScript(args, defaultPrefixSource) {
+  const prefix = args.prefix ? slugifyPrefix(args.prefix) : args.global ? 'AUTO' : slugifyPrefix(defaultPrefixSource);
+  const protectedBranches = args.protect
+    .split(',')
+    .map((b) => b.trim())
+    .filter(Boolean)
+    .join(' ');
+  const modelArgs = args.model ? `--model ${args.model}` : '';
 
-function slugifyPrefix(name) {
-  return (name || 'wip')
-    .replace(/^@[^/]+\//, '') // drop npm scope
-    .toUpperCase()
-    .replace(/[^A-Z0-9]+/g, '')
-    .slice(0, 12) || 'WIP';
+  const templatePath = path.join(__dirname, '..', 'templates', 'pre-commit.sh');
+  let hookScript = fs.readFileSync(templatePath, 'utf8');
+  hookScript = hookScript
+    .replace(/__STACK__/g, args.stack.replace(/"/g, '\\"'))
+    .replace(/__PREFIX__/g, prefix)
+    .replace(/__PROTECTED__/g, protectedBranches)
+    .replace(/__MODEL_ARGS__/g, modelArgs);
+
+  return { hookScript, prefix, protectedBranches };
 }
 
-function run(cmd, args) {
-  console.log(`  $ ${cmd} ${args.join(' ')}`);
-  const result = spawnSync(cmd, args, { cwd: CWD, stdio: 'inherit' });
+function run(cmd, cmdArgs) {
+  console.log(`  $ ${cmd} ${cmdArgs.join(' ')}`);
+  const result = spawnSync(cmd, cmdArgs, { cwd: CWD, stdio: 'inherit' });
   if (result.status !== 0) {
-    fail(`\`${cmd} ${args.join(' ')}\` failed (exit ${result.status}).`);
+    fail(`\`${cmd} ${cmdArgs.join(' ')}\` failed (exit ${result.status}).`);
   }
 }
 
-function init(args) {
-  ensureGitRepo();
-  const { pkgPath, pkg } = readPackageJson();
+function initProject(args) {
+  const gitCheck = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: CWD, stdio: 'pipe' });
+  if (gitCheck.status !== 0) fail('Not a git repository — run `git init` first.');
+
+  const pkgPath = path.join(CWD, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    fail('No package.json in the current directory — run this from your project root (or use --global).');
+  }
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
 
   const huskyDir = path.join(CWD, '.husky');
   const hookPath = path.join(huskyDir, 'pre-commit');
@@ -91,9 +133,7 @@ function init(args) {
     fail(`${hookPath} already exists — pass --force to overwrite it.`);
   }
 
-  const hasHusky =
-    (pkg.devDependencies && pkg.devDependencies.husky) || (pkg.dependencies && pkg.dependencies.husky);
-
+  const hasHusky = (pkg.devDependencies && pkg.devDependencies.husky) || (pkg.dependencies && pkg.dependencies.husky);
   if (!hasHusky) {
     console.log('→ Installing husky (devDependency)...');
     run('npm', ['install', '--save-dev', 'husky']);
@@ -112,33 +152,63 @@ function init(args) {
   console.log('→ Wiring up husky (git hooksPath)...');
   run('npx', ['husky']);
 
-  const prefix = slugifyPrefix(args.prefix || freshPkg.name);
-  const protectedBranches = args.protect
-    .split(',')
-    .map((b) => b.trim())
-    .filter(Boolean)
-    .join(' ');
-
-  const templatePath = path.join(__dirname, '..', 'templates', 'pre-commit.sh');
-  let hookScript = fs.readFileSync(templatePath, 'utf8');
-  hookScript = hookScript
-    .replace(/__STACK__/g, args.stack.replace(/"/g, '\\"'))
-    .replace(/__PREFIX__/g, prefix)
-    .replace(/__PROTECTED__/g, protectedBranches);
+  const { hookScript, prefix, protectedBranches } = buildHookScript(args, freshPkg.name);
 
   fs.mkdirSync(huskyDir, { recursive: true });
   fs.writeFileSync(hookPath, hookScript);
   fs.chmodSync(hookPath, 0o755);
 
   console.log(`✓ wrote ${path.relative(CWD, hookPath)}`);
+  printSummary(prefix, protectedBranches);
+}
+
+function initGlobal(args) {
+  const configuredDir = spawnSync('git', ['config', '--global', 'init.templateDir'], { stdio: 'pipe' });
+  const templateDir =
+    configuredDir.status === 0 && configuredDir.stdout.toString().trim()
+      ? configuredDir.stdout.toString().trim()
+      : path.join(os.homedir(), '.git-templates');
+
+  const hooksDir = path.join(templateDir, 'hooks');
+  const hookPath = path.join(hooksDir, 'pre-commit');
+
+  if (fs.existsSync(hookPath) && !args.force) {
+    fail(`${hookPath} already exists — pass --force to overwrite it.`);
+  }
+
+  const { hookScript, prefix, protectedBranches } = buildHookScript(args, null);
+
+  fs.mkdirSync(hooksDir, { recursive: true });
+  fs.writeFileSync(hookPath, hookScript);
+  fs.chmodSync(hookPath, 0o755);
+  console.log(`✓ wrote ${hookPath}`);
+
+  run('git', ['config', '--global', 'init.templateDir', templateDir]);
+
+  console.log('');
+  console.log(`Every \`git init\` and \`git clone\` from now on picks this up automatically.`);
+  console.log(`Already-existing local repos won't retroactively get it — re-run \`git init\``);
+  console.log(`inside one (safe, doesn't touch history/remotes) to copy it in, or run`);
+  console.log(`\`npx no-yolo-commits init\` there for the per-project (husky) version, which`);
+  console.log(`takes precedence over this global hook if both are present.`);
+  printSummary(prefix, protectedBranches);
+}
+
+function printSummary(prefix, protectedBranches) {
   console.log('');
   console.log('Done. New behavior on `git commit`:');
-  console.log(`  - AI review of staged changes (needs \`claude\` on PATH) — blocks only on high-confidence issues`);
+  console.log('  - secret scan on staged changes (private keys, tokens, .env files) — always on');
+  console.log('  - AI review of staged changes (needs `claude` on PATH) — blocks only on high-confidence issues');
   console.log(`  - direct commits to [${protectedBranches}] auto-branch instead, as ${prefix}-<timestamp>-<slug>`);
   console.log('');
   console.log('Bypass for one commit: git commit --no-verify');
 }
 
+function init(args) {
+  if (args.global) return initGlobal(args);
+  return initProject(args);
+}
+
 function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === 'help') return printHelp();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-yolo-commits",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "description": "AI pre-commit review (via the claude CLI) + a guard that auto-branches you off main/master instead of letting a direct commit land there.",
   "keywords": [
     "husky",

package/templates/ci-review.sh

@@ -0,0 +1,113 @@
+#!/usr/bin/env sh
+# Runs in GitHub Actions on a pull_request event. Reviews the PR's diff
+# against its base branch: same secret scan + AI review the local pre-commit
+# hook does, as a defense-in-depth check that isn't bypassable with
+# `git commit --no-verify` or simply not having the hook installed locally.
+
+STACK="${STACK:-TypeScript}"
+MODEL_ARGS=""
+if [ -n "${MODEL:-}" ]; then MODEL_ARGS="--model $MODEL"; fi
+
+base_ref="${GITHUB_BASE_REF:-}"
+if [ -z "$base_ref" ]; then
+  echo "GITHUB_BASE_REF is empty — this action is meant to run on pull_request events. Skipping."
+  exit 0
+fi
+
+git fetch --no-tags --depth=1 origin "$base_ref" >/dev/null 2>&1
+merge_base="$(git merge-base "origin/$base_ref" HEAD 2>/dev/null)"
+if [ -z "$merge_base" ]; then
+  # Shallow fetch didn't reach a common ancestor — try a full fetch once
+  # before giving up and diffing straight against the base branch tip.
+  git fetch --no-tags origin "$base_ref" >/dev/null 2>&1
+  merge_base="$(git merge-base "origin/$base_ref" HEAD 2>/dev/null)"
+fi
+merge_base="${merge_base:-origin/$base_ref}"
+
+echo "Reviewing $merge_base...HEAD"
+
+# --- secret scan (same patterns as the local pre-commit hook) ---
+secret_hits="$(git diff "$merge_base"...HEAD -U0 -- . 2>/dev/null | grep -E '^\+[^+]' | grep -E -i \
+  -e '-----BEGIN (RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----' \
+  -e 'AKIA[0-9A-Z]{16}' \
+  -e 'xox[baprs]-[0-9A-Za-z-]{10,}' \
+  -e '(api[_-]?key|secret|access[_-]?token|password|passwd)["'"'"']?[[:space:]]*[:=][[:space:]]*["'"'"'][A-Za-z0-9_/+=-]{16,}["'"'"']' \
+  2>/dev/null || true)"
+env_files="$(git diff "$merge_base"...HEAD --name-only -- . 2>/dev/null | grep -E '(^|/)\.env(\.[^.]+)?$' | grep -v -E '\.(example|sample|template|dist)$' || true)"
+
+if [ -n "$secret_hits" ] || [ -n "$env_files" ]; then
+  echo "::error::Possible secret(s) found in this PR's diff"
+  if [ -n "$env_files" ]; then
+    echo "$env_files" | while IFS= read -r f; do [ -n "$f" ] && echo "::error::staged env file: $f"; done
+  fi
+  if [ -n "$secret_hits" ]; then
+    echo "$secret_hits" | cut -c1-200 | while IFS= read -r l; do [ -n "$l" ] && echo "::error::$l"; done
+  fi
+  exit 1
+fi
+
+review_diff="$(git diff "$merge_base"...HEAD -- . ':(exclude)package-lock.json' ':(exclude)yarn.lock' ':(exclude)pnpm-lock.yaml' ':(exclude)composer.lock' ':(exclude)Gemfile.lock' ':(exclude)*.svg' ':(exclude)*.png' ':(exclude)*.jpg' ':(exclude)*.jpeg' ':(exclude)*.gif' ':(exclude)*.webp' ':(exclude)*.ico' 2>/dev/null)"
+
+if [ -z "$review_diff" ]; then
+  echo "Nothing to review (lockfile/generated-asset-only diff)."
+  exit 0
+fi
+
+if ! command -v claude >/dev/null 2>&1; then
+  echo "::warning::claude CLI not found on PATH — skipping AI review"
+  exit 0
+fi
+
+review_prompt="You are reviewing a pull request's diff before merge, for a $STACK project. Inspect the diff (run \`git diff ${merge_base}...HEAD\` yourself; read full files with the Read tool when a hunk needs more context) and flag ONLY real, high-confidence problems: type-safety holes, missing error handling at real failure points, obvious bugs, broken framework patterns, dead/unused code introduced by this diff, and any secret/API key/credential that looks like it's being committed.
+
+Do NOT flag stylistic preferences. Do NOT flag pre-existing patterns already used elsewhere in this codebase. Do NOT invent issues — if you are not confident something is a real problem, leave it out. Respond with ONLY JSON matching the schema, nothing else."
+
+review_tmpfile="$(mktemp)"
+
+# Background claude directly (no subshell wrapper) so $! is its real PID and
+# the timeout watcher below can actually kill it — see the local hook's
+# comment on this for the failure mode this avoids.
+claude -p "$review_prompt" \
+  --output-format json \
+  --json-schema '{"type":"object","properties":{"blocking_issues":{"type":"array","items":{"type":"string"}}},"required":["blocking_issues"]}' \
+  --allowedTools "Bash(git diff*)" "Bash(git show*)" "Bash(git log*)" "Read" "Grep" "Glob" \
+  --disallowedTools "Write" "Edit" "MultiEdit" "NotebookEdit" \
+  --permission-mode bypassPermissions \
+  $MODEL_ARGS \
+  >"$review_tmpfile" 2>/dev/null &
+review_pid=$!
+(sleep 180; kill "$review_pid" >/dev/null 2>&1; exit 0) >/dev/null 2>&1 &
+watcher_pid=$!
+disown "$watcher_pid" >/dev/null 2>&1 || true
+
+wait "$review_pid" >/dev/null 2>&1 || true
+kill "$watcher_pid" >/dev/null 2>&1 || true
+wait "$watcher_pid" >/dev/null 2>&1 || true
+
+node -e '
+  const fs = require("fs")
+  try {
+    const data = JSON.parse(fs.readFileSync(process.argv[1], "utf-8"))
+    if (data.is_error || !data.structured_output) process.exit(2)
+    const issues = data.structured_output.blocking_issues || []
+    if (issues.length > 0) {
+      for (const i of issues) console.log("::error::" + i)
+      process.exit(1)
+    }
+    process.exit(0)
+  } catch (e) {
+    process.exit(2)
+  }
+' "$review_tmpfile" && status=0 || status=$?
+rm -f "$review_tmpfile" 2>/dev/null || true
+
+if [ "$status" = "1" ]; then
+  echo "AI review found blocking issues (see annotations above)."
+  exit 1
+elif [ "$status" = "2" ]; then
+  echo "::warning::AI review unavailable or timed out — not blocking the PR."
+  exit 0
+else
+  echo "AI review found no blocking issues."
+  exit 0
+fi

package/templates/pre-commit.sh

@@ -1,13 +1,50 @@
 #!/usr/bin/env sh
 
+# --- Secret scan on staged changes ---
+# Cheap, deterministic, no dependency on `claude` being installed or
+# working — runs regardless, so a leaked key doesn't slip through just
+# because the AI reviewer below is unavailable. Blocks by default since
+# a leaked credential is a different class of mistake than a code-quality
+# nit; bypass with `git commit --no-verify` for a confirmed false positive.
+if ! git diff --cached --quiet 2>/dev/null; then
+  secret_hits="$(git diff --cached -U0 -- . 2>/dev/null | grep -E '^\+[^+]' | grep -E -i \
+    -e '-----BEGIN (RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----' \
+    -e 'AKIA[0-9A-Z]{16}' \
+    -e 'xox[baprs]-[0-9A-Za-z-]{10,}' \
+    -e '(api[_-]?key|secret|access[_-]?token|password|passwd)["'"'"']?[[:space:]]*[:=][[:space:]]*["'"'"'][A-Za-z0-9_/+=-]{16,}["'"'"']' \
+    2>/dev/null || true)"
+
+  env_files="$(git diff --cached --name-only -- . 2>/dev/null | grep -E '(^|/)\.env(\.[^.]+)?$' | grep -v -E '\.(example|sample|template|dist)$' || true)"
+
+  if [ -n "$secret_hits" ] || [ -n "$env_files" ]; then
+    echo ""
+    echo "⛔ Possible secret(s) in staged changes:"
+    if [ -n "$env_files" ]; then
+      echo "$env_files" | while IFS= read -r f; do [ -n "$f" ] && echo "  - staged env file: $f"; done
+    fi
+    if [ -n "$secret_hits" ]; then
+      echo "$secret_hits" | cut -c1-120 | while IFS= read -r l; do [ -n "$l" ] && echo "  - $l"; done
+    fi
+    echo ""
+    echo "If this is a false positive: git commit --no-verify"
+    exit 1
+  fi
+fi
+
 # --- AI code review on staged changes ---
 # Fails the commit only on real, high-confidence findings. If Claude is
 # missing, times out, or errors, this fails OPEN (warns, does not block) —
 # a broken/unavailable review must never be the only thing stopping commits.
-if command -v claude >/dev/null 2>&1 && ! git diff --cached --quiet; then
+#
+# Skipped entirely when every staged file is a lockfile/generated asset —
+# nothing there for a code reviewer to usefully say, and it's the case
+# most likely to be a large, slow diff to hand an LLM for zero benefit.
+review_diff_probe="$(git diff --cached -- . ':(exclude)package-lock.json' ':(exclude)yarn.lock' ':(exclude)pnpm-lock.yaml' ':(exclude)composer.lock' ':(exclude)Gemfile.lock' ':(exclude)*.svg' ':(exclude)*.png' ':(exclude)*.jpg' ':(exclude)*.jpeg' ':(exclude)*.gif' ':(exclude)*.webp' ':(exclude)*.ico' 2>/dev/null)"
+
+if command -v claude >/dev/null 2>&1 && [ -n "$review_diff_probe" ]; then
   echo "→ Running AI code review on staged changes..."
 
-  review_prompt="You are reviewing staged git changes before they are committed, for a __STACK__ project. Inspect the staged changes (run \`git diff --cached\` yourself; read full files with the Read tool when a diff hunk needs more surrounding context) and flag ONLY real, high-confidence problems: type-safety holes (any/unsafe casts), missing error handling at real failure points, obvious bugs, broken framework patterns, dead or unused code introduced by this diff.
+  review_prompt="You are reviewing staged git changes before they are committed, for a __STACK__ project. Inspect the staged changes (run \`git diff --cached\` yourself; read full files with the Read tool when a diff hunk needs more surrounding context) and flag ONLY real, high-confidence problems: type-safety holes (any/unsafe casts), missing error handling at real failure points, obvious bugs, broken framework patterns, dead or unused code introduced by this diff, and any secret/API key/credential that looks like it's being committed.
 
 Do NOT flag stylistic preferences. Do NOT flag pre-existing patterns already used elsewhere in this codebase (check before flagging). Do NOT invent issues — if you are not confident something is a real problem, leave it out. Respond with ONLY JSON matching the schema, nothing else."
 
@@ -23,7 +60,7 @@ Do NOT flag stylistic preferences. Do NOT flag pre-existing patterns already use
     --json-schema '{"type":"object","properties":{"blocking_issues":{"type":"array","items":{"type":"string"}}},"required":["blocking_issues"]}' \
     --allowedTools "Bash(git diff*)" "Bash(git show*)" "Bash(git log*)" "Read" "Grep" "Glob" \
     --disallowedTools "Write" "Edit" "MultiEdit" "NotebookEdit" \
-    --permission-mode bypassPermissions \
+    --permission-mode bypassPermissions __MODEL_ARGS__ \
     >"$review_tmpfile" 2>/dev/null &
   review_pid=$!
   (sleep 120; kill "$review_pid" >/dev/null 2>&1; exit 0) >/dev/null 2>&1 &
@@ -67,10 +104,19 @@ Do NOT flag stylistic preferences. Do NOT flag pre-existing patterns already use
   else
     echo "✓ AI review found no blocking issues."
   fi
+elif command -v claude >/dev/null 2>&1; then
+  echo "→ Skipping AI review (only lockfile/generated-asset changes staged)."
 fi
 
 # --- Block direct commits to protected branches ---
-branch="$(git rev-parse --abbrev-ref HEAD 2>/dev/null || true)"
+# symbolic-ref first: on a brand-new repo's very first commit (no HEAD
+# commit exists yet — an "unborn" branch) rev-parse --abbrev-ref HEAD
+# fails and prints the literal string "HEAD" to stdout before erroring,
+# which silently bypassed protection entirely on repo #1's commit #1.
+# symbolic-ref resolves the branch name in that state; it only fails on
+# a genuinely detached HEAD, where falling back to "HEAD" is correct
+# (you can't be "on" a protected branch while detached).
+branch="$(git symbolic-ref --short HEAD 2>/dev/null || git rev-parse --abbrev-ref HEAD 2>/dev/null || true)"
 
 case " __PROTECTED__ " in
   *" $branch "*) ;;
@@ -95,7 +141,7 @@ if command -v claude >/dev/null 2>&1; then
 
     # Same reasoning as the review call above: background claude directly,
     # no subshell wrapper, so $! is the real PID the timeout can kill.
-    printf '%s' "$diff" | claude -p "$prompt" >"$tmpfile" 2>/dev/null &
+    printf '%s' "$diff" | claude -p "$prompt" __MODEL_ARGS__ >"$tmpfile" 2>/dev/null &
     claude_pid=$!
     (sleep 25; kill "$claude_pid" >/dev/null 2>&1; exit 0) >/dev/null 2>&1 &
     watcher_pid=$!
@@ -121,8 +167,36 @@ if [ -z "$slug" ]; then
   slug="$(fallback_slug)"
 fi
 
+# The configured prefix is the literal word AUTO for global (git-template)
+# installs, which serve many unrelated repos from one script — derive the
+# prefix per-repo at commit time instead of baking one in at install time.
+configured_prefix="__PREFIX__"
+if [ "$configured_prefix" = "AUTO" ]; then
+  toplevel="$(git rev-parse --show-toplevel 2>/dev/null)"
+  prefix=""
+  # Prefer package.json's name (first 3 letters, scope dropped) when there
+  # is one — falls back to the repo directory name for non-Node projects,
+  # or if package.json has no usable "name".
+  if [ -n "$toplevel" ] && [ -f "$toplevel/package.json" ] && command -v node >/dev/null 2>&1; then
+    prefix="$(node -e '
+      try {
+        const pkg = require(process.argv[1]);
+        const name = String(pkg.name || "").replace(/^@[^/]+\//, "");
+        process.stdout.write(name.slice(0, 3).toUpperCase());
+      } catch (e) {}
+    ' "$toplevel/package.json" 2>/dev/null)"
+  fi
+  if [ -z "$prefix" ]; then
+    prefix="$(basename "$toplevel" 2>/dev/null \
+      | tr '[:lower:]' '[:upper:]' | tr -cs 'A-Z0-9' '-' | sed -e 's/^-*//' -e 's/-*$//' | cut -c1-20)"
+  fi
+  prefix="${prefix:-WIP}"
+else
+  prefix="$configured_prefix"
+fi
+
 timestamp="$(date +%s)"
-new_branch="__PREFIX__-${timestamp}-${slug}"
+new_branch="${prefix}-${timestamp}-${slug}"
 new_branch="$(printf '%s' "$new_branch" | cut -c1-100)"
 
 branch_err_file="$(mktemp)"