@soleur/opencode 0.0.0-stage → 3.354.2

package/skills/verification-scaffold/test/bite-proof.test.sh

@@ -0,0 +1,159 @@
+#!/usr/bin/env bash
+# Bite-proof coverage for verification-scaffold.sh (#10404): installs the v1 set
+# into a fixture repo and drives each emitted guard pass -> fail -> pass —
+# independent of the generator's own internal bite (this suite RE-drives the
+# emitted artifacts as a consumer would). Needs gitleaks on PATH for the
+# secret-scan arm; that arm is skipped loudly when the binary is absent
+# (matching the guard's own contract: a missing scanner is a tool error, not a
+# finding). Runs in the scripts shard. Accumulate-then-exit.
+set -uo pipefail
+export TMPDIR="${TMPDIR:-/var/tmp}"
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../../../.." && pwd)"
+GEN="$REPO_ROOT/plugins/soleur/skills/verification-scaffold/scripts/verification-scaffold.sh"
+
+passes=0; fails=0
+pass() { printf 'ok   - %s\n' "$1"; passes=$((passes + 1)); }
+fail() { printf 'FAIL - %s\n' "$1"; fails=$((fails + 1)); }
+
+TMPROOT="$(mktemp -d)"
+# The body below is the CANONICAL copy of assert_fixture_dir (#7652) — do not reword.
+assert_fixture_dir() {
+  case "${1-}" in
+    "") printf 'FATAL: fixture dir is EMPTY; git -C "" would operate on %s\n' "$PWD" >&2; exit 2 ;;
+    */../*|*/..) printf 'FATAL: fixture dir %s contains ..; refusing\n' "$1" >&2; exit 2 ;;
+    /proc/*|/sys/*|/dev/*) printf 'FATAL: fixture dir %s is a synthetic-fs path; refusing\n' "$1" >&2; exit 2 ;;
+    /|//|/.) printf 'FATAL: fixture dir resolves to the filesystem root; refusing\n' >&2; exit 2 ;;
+    /*) : ;;
+    *)  printf 'FATAL: fixture dir %s is RELATIVE; refusing\n' "$1" >&2; exit 2 ;;
+  esac
+}
+trap 'rm -rf "$TMPROOT"' EXIT
+
+mkrepo() { # mkrepo <name> -> committed fixture repo on main
+  local d="$TMPROOT/$1"
+  mkdir -p "$d"
+  git -C "$d" init -q
+  git -C "$d" config user.email t@t
+  git -C "$d" config user.name t
+  local t c
+  t="$(git -C "$d" write-tree)"
+  c="$(echo init | git -C "$d" commit-tree "$t")"
+  git -C "$d" update-ref refs/heads/main "$c"
+  git -C "$d" symbolic-ref HEAD refs/heads/main
+  printf '%s' "$d"
+}
+
+payload() { jq -nc --arg c "$1" --arg w "$2" '{tool_name:"Bash",tool_input:{command:$c},cwd:$w}'; }
+decide() { sed -n 's/.*"permissionDecision": *"\([a-z]*\)".*/\1/p' | head -n 1; }
+
+# --- install into the fixture ---------------------------------------------------
+FX="$(mkrepo installed)"; assert_fixture_dir "$FX"
+OUT="$(bash "$GEN" --target "$FX" --headless 2>&1)" || { fail "install failed: $OUT"; printf '\n%d pass(es), %d fail(s)\n' "$passes" "$fails"; exit 1; }
+grep -q 'bite-proof' <<<"$OUT" \
+  && pass "install reports the internal bite-proof per guard" \
+  || fail "install output carries no bite-proof lines: $OUT"
+# The internal bite must have run all four arms (a SKIP is a failure HERE —
+# gitleaks is expected on this host; on a host without it the arm prints SKIP).
+for g in secret-scan commit-on-main block-stash orphan-test; do
+  if grep -q "bite-proof $g: pass -> fail" <<<"$OUT"; then
+    pass "internal bite-proof: $g pass -> fail -> pass"
+  elif [[ "$g" == "secret-scan" ]] && ! command -v gitleaks >/dev/null 2>&1 \
+       && grep -q "bite-proof secret-scan: SKIP" <<<"$OUT"; then
+    pass "internal bite-proof: secret-scan SKIP (no gitleaks on PATH — documented)"
+  else
+    fail "internal bite-proof arm missing or failed for $g: $(grep 'bite-proof' <<<"$OUT" | tr '\n' ';')"
+  fi
+done
+
+# --- commit-on-main, re-driven against the emitted pair --------------------------
+HOOK="$FX/.claude/hooks/commit-on-main.sh"
+# A fixture repo ON a feature branch: pass arm.
+F2="$TMPROOT/feat-repo"; assert_fixture_dir "$F2"
+mkdir -p "$F2"
+git -C "$F2" init -q; git -C "$F2" config user.email t@t; git -C "$F2" config user.name t
+git -C "$F2" symbolic-ref HEAD refs/heads/main
+t="$(git -C "$F2" write-tree)"; c="$(echo x | git -C "$F2" commit-tree "$t")"; git -C "$F2" update-ref refs/heads/main "$c"
+git -C "$F2" checkout -qb feat-x
+OUT="$(cd "$FX" && payload "git -C $F2 commit -m x" "$F2" | bash "$HOOK")"
+[[ "$(decide <<<"$OUT")" == "allow" ]] && pass "commit-on-main: feature-branch payload allowed" \
+  || fail "commit-on-main feature branch: $OUT"
+# On main: advisory warn+allow with a refusal WARN on stderr.
+git -C "$F2" checkout -q main
+ERR="$TMPROOT/err"; OUT="$(cd "$FX" && payload "git -C $F2 commit -m x" "$F2" | bash "$HOOK" 2>"$ERR")"
+if [[ "$(decide <<<"$OUT")" == "allow" ]] && grep -qE 'not allowed|refused' "$ERR"; then
+  pass "commit-on-main: main payload warns+allows (advisory)"
+else
+  fail "commit-on-main main arm: out=$OUT err=$(cat "$ERR")"
+fi
+# Enforce flip is one line: MODE=enforce denies.
+sed 's/^MODE="advisory"$/MODE="enforce"/' "$HOOK" > "$TMPROOT/hook-enf.sh"
+OUT="$(cd "$FX" && payload "git -C $F2 commit -m x" "$F2" | bash "$TMPROOT/hook-enf.sh" 2>/dev/null)"
+[[ "$(decide <<<"$OUT")" == "deny" ]] && pass "commit-on-main: MODE=enforce flip denies (one-line promotion)" \
+  || fail "enforce flip did not deny: $OUT"
+
+# --- block-stash ------------------------------------------------------------------
+HOOK="$FX/.claude/hooks/block-stash.sh"
+OUT="$(cd "$FX" && payload "git status" "$FX" | bash "$HOOK")"
+[[ "$(decide <<<"$OUT")" == "allow" ]] && pass "block-stash: git status allowed" \
+  || fail "block-stash status: $OUT"
+ERR="$TMPROOT/err2"; OUT="$(cd "$FX" && payload "git add x && git stash pop" "$FX" | bash "$HOOK" 2>"$ERR")"
+if [[ "$(decide <<<"$OUT")" == "allow" ]] && grep -q 'not allowed' "$ERR"; then
+  pass "block-stash: chained 'git stash pop' warns+allows"
+else
+  fail "block-stash stash arm: out=$OUT err=$(cat "$ERR")"
+fi
+OUT="$(cd "$FX" && payload "git stash list" "$FX" | bash "$HOOK")"
+[[ "$(decide <<<"$OUT")" == "allow" ]] && pass "block-stash: read-only 'git stash list' allowed" \
+  || fail "block-stash stash list: $OUT"
+
+# --- orphan-test ------------------------------------------------------------------
+CHECK="$FX/scripts/verification/orphan-test-check.sh"
+OUT="$(cd "$FX" && bash "$CHECK" 2>&1)" && pass "orphan-test: clean tree passes" \
+  || fail "orphan-test clean tree: $OUT"
+printf '#!/usr/bin/env bash\nexit 0\n' > "$FX/scratch.test.sh"
+git -C "$FX" add scratch.test.sh
+RC=0; OUT="$(cd "$FX" && bash "$CHECK" 2>&1)" || RC=$?
+if [[ "$RC" -ne 0 && "$OUT" == *scratch.test.sh* ]]; then
+  pass "orphan-test: injected unregistered suite named by path"
+else
+  fail "orphan-test injected suite: rc=$RC out=$OUT"
+fi
+# Reason-carrying exclusion registers it.
+printf 'scratch.test.sh # deliberate exclusion for the bite suite\n' >> "$FX/.github/verification-known-orphans.txt"
+OUT="$(cd "$FX" && bash "$CHECK" 2>&1)" && pass "orphan-test: reasoned exclusion passes" \
+  || fail "orphan-test exclusion arm: $OUT"
+# A reasonless exclusion line is itself a finding.
+printf 'scratch.test.sh\n' >> "$FX/.github/verification-known-orphans.txt"
+RC=0; OUT="$(cd "$FX" && bash "$CHECK" 2>&1)" || RC=$?
+[[ "$RC" -ne 0 && "$OUT" == *reasonless* ]] && pass "orphan-test: reasonless exclusion is a finding" \
+  || fail "orphan-test reasonless arm: rc=$RC out=$OUT"
+git -C "$FX" rm -q --cached scratch.test.sh 2>/dev/null; rm -f "$FX/scratch.test.sh"
+git -C "$FX" checkout -q -- .github/verification-known-orphans.txt 2>/dev/null \
+  || git -C "$FX" restore --staged --worktree .github/verification-known-orphans.txt 2>/dev/null || true
+
+# --- secret-scan (skipped without gitleaks) ---------------------------------------
+HOOK="$FX/.claude/hooks/secret-scan.sh"
+if command -v gitleaks >/dev/null 2>&1; then
+  printf 'x\n' > "$FX/clean.txt"; git -C "$FX" add clean.txt
+  OUT="$(cd "$FX" && payload "git commit -m x" "$FX" | bash "$HOOK" 2>/dev/null)"
+  [[ "$(decide <<<"$OUT")" == "allow" ]] && pass "secret-scan: clean staged file allows" \
+    || fail "secret-scan clean arm: $OUT"
+  # Synthetic-but-shaped secret (the AWS docs example key is allowlisted in
+  # gitleaks's default ruleset — this variant keeps the 40-char shape only).
+  printf 'AWS_SECRET_ACCESS_KEY = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYSYNTHETIC0"\n' > "$FX/secret.txt"
+  git -C "$FX" add secret.txt
+  OUT="$(cd "$FX" && payload "git commit -m x" "$FX" | bash "$HOOK" 2>/dev/null)"
+  [[ "$(decide <<<"$OUT")" == "ask" ]] && pass "secret-scan: staged secret surfaces as ask (advisory)" \
+    || fail "secret-scan secret arm: $OUT"
+  git -C "$FX" rm -q --cached secret.txt; rm -f "$FX/secret.txt"
+  OUT="$(cd "$FX" && payload "git commit -m x" "$FX" | bash "$HOOK" 2>/dev/null)"
+  [[ "$(decide <<<"$OUT")" == "allow" ]] && pass "secret-scan: reverted tree allows again" \
+    || fail "secret-scan revert arm: $OUT"
+else
+  pass "secret-scan arms skipped (no gitleaks on PATH — the hook warns+allows per commit)"
+fi
+
+printf '\n%d pass(es), %d fail(s)\n' "$passes" "$fails"
+[[ "$fails" -eq 0 ]]

package/skills/verification-scaffold/test/generator.test.sh

@@ -0,0 +1,319 @@
+#!/usr/bin/env bash
+# Generator coverage for verification-scaffold.sh (#10404) against HERMETIC
+# fixture repos — a throwaway `git init` per arm under a mktemp dir. Covers the
+# flag/exit-matrix paths that need no gitleaks:
+#   64  --mode bogus; unknown guard
+#   65  --target outside a git work tree
+#   66  refuse-if-exists (pre-placed artifact; full second run)
+#   69  malformed .claude/settings.json refused BEFORE any write
+#   settings merge: absent created, unrelated keys preserved, re-run dedupe
+#   --dry-run writes nothing; --uninstall is surgical + idempotent
+#   --guards subset emits only that guard's artifacts
+# Runs in the scripts shard. Accumulate-then-exit.
+set -uo pipefail
+export TMPDIR="${TMPDIR:-/var/tmp}"
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../../../.." && pwd)"
+GEN="$REPO_ROOT/plugins/soleur/skills/verification-scaffold/scripts/verification-scaffold.sh"
+
+passes=0; fails=0
+pass() { printf 'ok   - %s\n' "$1"; passes=$((passes + 1)); }
+fail() { printf 'FAIL - %s\n' "$1"; fails=$((fails + 1)); }
+
+TMPROOT="$(mktemp -d)"
+# The body below is the CANONICAL copy of assert_fixture_dir (#7652) — do not reword.
+assert_fixture_dir() {
+  case "${1-}" in
+    "") printf 'FATAL: fixture dir is EMPTY; git -C "" would operate on %s\n' "$PWD" >&2; exit 2 ;;
+    */../*|*/..) printf 'FATAL: fixture dir %s contains ..; refusing\n' "$1" >&2; exit 2 ;;
+    /proc/*|/sys/*|/dev/*) printf 'FATAL: fixture dir %s is a synthetic-fs path; refusing\n' "$1" >&2; exit 2 ;;
+    /|//|/.) printf 'FATAL: fixture dir resolves to the filesystem root; refusing\n' >&2; exit 2 ;;
+    /*) : ;;
+    *)  printf 'FATAL: fixture dir %s is RELATIVE; refusing\n' "$1" >&2; exit 2 ;;
+  esac
+}
+trap 'rm -rf "$TMPROOT"' EXIT
+
+mkrepo() { # mkrepo <name> -> fixture git repo path (empty tree, one commit)
+  local d="$TMPROOT/$1"
+  mkdir -p "$d"
+  git -C "$d" init -q
+  git -C "$d" config user.email t@t
+  git -C "$d" config user.name t
+  local t c
+  t="$(git -C "$d" write-tree)"
+  c="$(echo init | git -C "$d" commit-tree "$t")"
+  git -C "$d" update-ref refs/heads/main "$c"
+  git -C "$d" symbolic-ref HEAD refs/heads/main
+  printf '%s' "$d"
+}
+
+run_gen() { # run_gen <repo> <args...> -> rc (never aborts the suite)
+  local root="$1"; shift
+  local rc=0
+  bash "$GEN" --target "$root" "$@" >/dev/null 2>&1 || rc=$?
+  printf '%s' "$rc"
+}
+
+run_gen_out() { # run_gen_out <repo> <args...> -> "rc|stdout"
+  local root="$1"; shift
+  local rc=0 out
+  out="$(bash "$GEN" --target "$root" "$@" 2>/dev/null)" || rc=$?
+  printf '%s|%s' "$rc" "$out"
+}
+
+# --- 65: not a git work tree ---------------------------------------------------
+NOTREPO="$TMPROOT/notrepo"; mkdir -p "$NOTREPO"
+RC="$(run_gen "$NOTREPO" --headless)"
+[[ "$RC" == "65" ]] && pass "exit 65: target outside a git work tree refused" \
+  || fail "expected 65 for non-repo target, got $RC"
+
+# --- 64: --mode bogus / unknown guard -------------------------------------------
+FX="$(mkrepo modebogus)"; assert_fixture_dir "$FX"
+RC="$(run_gen "$FX" --mode bogus --headless)"
+[[ "$RC" == "64" ]] && pass "exit 64: --mode bogus refused pre-write" \
+  || fail "expected 64 for --mode bogus, got $RC"
+RC="$(run_gen "$FX" --guards nosuchguard --headless)"
+[[ "$RC" == "64" ]] && pass "exit 64: unknown guard refused" \
+  || fail "expected 64 for unknown guard, got $RC"
+
+# --- 69: malformed settings.json refused BEFORE any write -----------------------
+FX="$(mkrepo badsettings)"; assert_fixture_dir "$FX"
+mkdir -p "$FX/.claude"
+printf '{not json' > "$FX/.claude/settings.json"
+RC="$(run_gen "$FX" --headless)"
+if [[ "$RC" == "69" ]] && [[ ! -e "$FX/.claude/hooks/secret-scan.sh" ]] \
+   && [[ "$(cat "$FX/.claude/settings.json")" == '{not json' ]]; then
+  pass "exit 69: malformed settings.json refused before any write (file untouched)"
+else
+  fail "malformed settings.json arm: rc=$RC settings=$(cat "$FX/.claude/settings.json" 2>/dev/null)"
+fi
+
+# --- 66: pre-existing artifact refuses -------------------------------------------
+FX="$(mkrepo collides)"; assert_fixture_dir "$FX"
+mkdir -p "$FX/.claude/hooks"
+printf '# mine\n' > "$FX/.claude/hooks/secret-scan.sh"
+RC="$(run_gen "$FX" --headless)"
+[[ "$RC" == "66" && "$(cat "$FX/.claude/hooks/secret-scan.sh")" == '# mine' ]] \
+  && pass "exit 66: pre-existing hook refuses, zero writes (file untouched)" \
+  || fail "expected 66 with untouched file, got rc=$RC"
+
+# pre-existing .gitleaks.toml also refuses (AC5)
+FX="$(mkrepo glcollide)"; assert_fixture_dir "$FX"
+printf '[extend]\nuseDefault = false\n' > "$FX/.gitleaks.toml"
+RC="$(run_gen "$FX" --headless)"
+[[ "$RC" == "66" && "$(cat "$FX/.gitleaks.toml")" == "[extend]
+useDefault = false" ]] \
+  && pass "exit 66: pre-existing .gitleaks.toml refuses (never overwrites a user ruleset)" \
+  || fail "expected 66 for pre-existing .gitleaks.toml, got rc=$RC"
+
+# --- --guards subset -------------------------------------------------------------
+FX="$(mkrepo subset)"; assert_fixture_dir "$FX"
+RC="$(run_gen "$FX" --guards block-stash --headless)"
+if [[ "$RC" == "0" && -f "$FX/.claude/hooks/block-stash.sh" \
+   && ! -e "$FX/.claude/hooks/secret-scan.sh" && ! -e "$FX/.github/workflows/verification-gates.yml" ]]; then
+  pass "--guards block-stash emits only that guard's artifacts"
+else
+  fail "subset install wrong: rc=$RC $(ls "$FX/.claude/hooks" 2>/dev/null | tr '\n' ' ')"
+fi
+grep -q 'block-stash' "$FX/.claude/settings.json" 2>/dev/null \
+  && pass "subset install registered the hook in settings.json" \
+  || fail "subset install: no settings.json hook entry"
+
+# --- --dry-run writes nothing ----------------------------------------------------
+FX="$(mkrepo dryrun)"; assert_fixture_dir "$FX"
+OUT="$(run_gen_out "$FX" --dry-run)"
+if [[ "${OUT%%|*}" == "0" && ! -e "$FX/.claude/hooks/secret-scan.sh" && ! -e "$FX/.claude/settings.json" ]]; then
+  pass "--dry-run exits 0 and writes nothing"
+else
+  fail "dry-run arm: rc=${OUT%%|*}"
+fi
+
+# --- full install + advisory markers (AC3) ---------------------------------------
+FX="$(mkrepo full)"; assert_fixture_dir "$FX"
+RC="$(run_gen "$FX" --headless)"
+[[ "$RC" == "0" ]] || fail "advisory install failed rc=$RC"
+G=1
+for p in .claude/hooks/secret-scan.sh .claude/hooks/commit-on-main.sh .claude/hooks/block-stash.sh \
+         scripts/verification/precommit-guard.sh scripts/verification/lib/wrapper-boundary.sh \
+         scripts/verification/orphan-test-check.sh .gitleaks.toml \
+         .github/workflows/verification-gates.yml .github/verification-known-orphans.txt \
+         .claude/settings.json VERIFICATION.md; do
+  [[ -f "$FX/$p" ]] || { G=0; fail "missing emitted artifact: $p"; }
+done
+[[ "$G" == "1" ]] && pass "advisory install emits all v1 artifacts"
+grep -q 'MODE="advisory"' "$FX/.claude/hooks/secret-scan.sh" \
+  && grep -q 'MODE="advisory"' "$FX/.claude/hooks/commit-on-main.sh" \
+  && grep -q 'MODE="advisory"' "$FX/.claude/hooks/block-stash.sh" \
+  && pass "advisory install stamps MODE=advisory in every hook" \
+  || fail "MODE=advisory stamp missing in an emitted hook"
+test "$(grep -c 'continue-on-error: true' "$FX/.github/workflows/verification-gates.yml")" = 2 \
+  && pass "advisory workflow carries continue-on-error: true on both jobs" \
+  || fail "advisory workflow continue-on-error wrong: $(grep -c 'continue-on-error' "$FX/.github/workflows/verification-gates.yml")"
+if grep -rqE '@(MODE|CI_CONTINUE_ON_ERROR|DEFAULT_BRANCHES|GUARD_LIST|GUARD_TABLE|DATE)@' \
+     "$FX/.claude/hooks" "$FX/scripts/verification" "$FX/.github/workflows/verification-gates.yml" "$FX/VERIFICATION.md" 2>/dev/null; then
+  fail "unsubstituted placeholder leaked into emitted artifacts"
+else
+  pass "no unsubstituted @PLACEHOLDER@ leaks into emitted artifacts"
+fi
+grep -q 'verification-scaffold:readme:start' "$FX/VERIFICATION.md" \
+  && pass "VERIFICATION.md created with the marker-keyed doc block" \
+  || fail "VERIFICATION.md doc block missing"
+
+# settings.json: hook entries present, dedupe on command string
+node -e '
+  const d = JSON.parse(require("fs").readFileSync(process.argv[1], "utf8"));
+  const cmds = d.hooks.PreToolUse.flatMap(m => m.hooks.map(h => h.command));
+  for (const n of ["secret-scan", "commit-on-main", "block-stash"])
+    if (!cmds.some(c => c.includes("/.claude/hooks/" + n + ".sh"))) process.exit(3);
+' "$FX/.claude/settings.json" \
+  && pass "settings.json registers all three hook commands" \
+  || fail "settings.json hook entries missing"
+
+# --- enforce mode flips only the decision verb (AC3/Guard 6) ---------------------
+FX="$(mkrepo enforce)"; assert_fixture_dir "$FX"
+RC="$(run_gen "$FX" --mode enforce --headless)"
+if [[ "$RC" == "0" ]]; then
+  grep -q 'MODE="enforce"' "$FX/.claude/hooks/block-stash.sh" \
+    && grep -q 'continue-on-error: false' "$FX/.github/workflows/verification-gates.yml" \
+    && pass "enforce install stamps MODE=enforce + continue-on-error: false" \
+    || fail "enforce stamps wrong"
+else
+  fail "enforce install failed rc=$RC"
+fi
+
+# --- re-run refuses (AC5) ---------------------------------------------------------
+RC="$(run_gen "$FX" --headless)"
+[[ "$RC" == "66" ]] && pass "second full run refuses (66), zero writes" \
+  || fail "expected 66 on second run, got $RC"
+
+# --- idempotent merge: manually re-add the same command -> stays single ----------
+# (The generator refuses before reaching the merge, so prove dedupe via a repo
+# whose ONLY drift is a missing settings entry while artifacts exist is refused
+# anyway — instead assert the emitted file itself: a merge that ran twice would
+# carry two identical command strings.)
+node -e '
+  const d = JSON.parse(require("fs").readFileSync(process.argv[1], "utf8"));
+  const cmds = d.hooks.PreToolUse.flatMap(m => m.hooks.map(h => h.command));
+  if (new Set(cmds).size !== cmds.length) process.exit(3);
+' "$FX/.claude/settings.json" \
+  && pass "settings.json has no duplicate hook commands" \
+  || fail "duplicate hook commands in settings.json"
+
+# --- merge preserves unrelated entries ------------------------------------------
+FX="$(mkrepo preserve)"; assert_fixture_dir "$FX"
+mkdir -p "$FX/.claude"
+printf '%s\n' '{"permissions":{"allow":["Bash(ls:*)"]},"hooks":{"PreToolUse":[{"matcher":"Write","hooks":[{"type":"command","command":"keepme"}]}]}}' > "$FX/.claude/settings.json"
+RC="$(run_gen "$FX" --guards block-stash --headless)"
+if [[ "$RC" == "0" ]]; then
+  node -e '
+    const d = JSON.parse(require("fs").readFileSync(process.argv[1], "utf8"));
+    const ok = d.permissions.allow.includes("Bash(ls:*)")
+      && d.hooks.PreToolUse.some(m => m.hooks.some(h => h.command === "keepme"))
+      && d.hooks.PreToolUse.some(m => m.hooks.some(h => h.command.includes("block-stash")));
+    process.exit(ok ? 0 : 3);
+  ' "$FX/.claude/settings.json" \
+    && pass "merge preserves unrelated permissions + hook entries" \
+    || fail "merge clobbered unrelated settings.json entries"
+else
+  fail "preserve install failed rc=$RC"
+fi
+
+# --- --uninstall: surgical + idempotent (AC5/SpecFlow 5) --------------------------
+RC="$(run_gen "$FX" --uninstall block-stash)"
+if [[ "$RC" == "0" && ! -e "$FX/.claude/hooks/block-stash.sh" ]]; then
+  node -e '
+    const d = JSON.parse(require("fs").readFileSync(process.argv[1], "utf8"));
+    const cmds = d.hooks.PreToolUse.flatMap(m => m.hooks.map(h => h.command));
+    process.exit(cmds.some(c => c.includes("block-stash")) || !cmds.includes("keepme") ? 3 : 0);
+  ' "$FX/.claude/settings.json" \
+    && pass "--uninstall removes the artifact + settings entry, leaves siblings" \
+    || fail "uninstall left a block-stash settings entry or removed keepme"
+else
+  fail "uninstall block-stash: rc=$RC artifact=$(ls "$FX/.claude/hooks" 2>/dev/null | tr '\n' ' ')"
+fi
+RC="$(run_gen "$FX" --uninstall block-stash)"
+[[ "$RC" == "0" ]] && pass "--uninstall on a removed guard is a clean no-op (exit 0)" \
+  || fail "idempotent uninstall expected rc=0, got $RC"
+
+# --- --list ----------------------------------------------------------------------
+OUT="$(run_gen_out "$FX" --list)"
+[[ "${OUT%%|*}" == "0" ]] && grep -q 'secret-scan' <<<"${OUT#*|}" \
+  && pass "--list prints the guard manifest" \
+  || fail "--list failed: ${OUT%%|*}"
+
+# --- 64: a v2-candidate guard is refused (#10759) --------------------------------
+FX="$(mkrepo v2refuse)"; assert_fixture_dir "$FX"
+RC="$(run_gen "$FX" --guards block-rm-rf --headless)"
+[[ "$RC" == "64" && ! -e "$FX/.claude/hooks/block-rm-rf.sh" ]] \
+  && pass "exit 64: v2-candidate guard refused, nothing emitted" \
+  || fail "expected 64 for v2-tier guard, got $RC"
+
+# --- 69: TMPDIR resolving inside the repo is refused pre-write (#10759) ----------
+FX="$(mkrepo tmpinside)"; assert_fixture_dir "$FX"
+mkdir -p "$FX/tmp"
+RC=0; TMPDIR="$FX/tmp" bash "$GEN" --target "$FX" --headless >/dev/null 2>&1 || RC=$?
+if [[ "$RC" == "69" && ! -e "$FX/.claude/hooks/secret-scan.sh" && ! -e "$FX/.claude/settings.json" ]]; then
+  pass "exit 69: TMPDIR inside the target repo refused before any artifact"
+else
+  fail "TMPDIR-inside-repo arm: expected 69, got rc=$RC"
+fi
+
+# --- --uninstall secret-scan: strip only its job from the shared workflow --------
+FX="$(mkrepo jobstrip)"; assert_fixture_dir "$FX"
+RC="$(run_gen "$FX" --guards secret-scan,orphan-test --headless)"
+[[ "$RC" == "0" ]] || fail "secret-scan+orphan-test install failed rc=$RC"
+OUT="$(run_gen_out "$FX" --uninstall secret-scan)"
+if [[ "${OUT%%|*}" == "0" && "${OUT#*|}" == *job-stripped* \
+   && -f "$FX/.github/workflows/verification-gates.yml" \
+   && -f "$FX/scripts/verification/orphan-test-check.sh" \
+   && ! -e "$FX/.claude/hooks/secret-scan.sh" && ! -e "$FX/.gitleaks.toml" ]]; then
+  pass "--uninstall secret-scan strips only its job block from the shared workflow"
+else
+  fail "shared-artifact uninstall arm: rc=${OUT%%|*} out=${OUT#*|}"
+fi
+WF="$FX/.github/workflows/verification-gates.yml"
+if grep -qF '# verification-scaffold:begin:orphan-test' "$WF" \
+   && ! grep -qF 'verification-scaffold:begin:secret-scan' "$WF"; then
+  pass "shared workflow keeps the orphan-test job, drops secret-scan's"
+else
+  fail "shared workflow job blocks wrong after strip: $(grep -c 'begin:' "$WF" 2>/dev/null)"
+fi
+
+# --- --uninstall of a never-installed ci guard: no phantom job-strip (#10759) -----
+FX="$(mkrepo neverci)"; assert_fixture_dir "$FX"
+RC="$(run_gen "$FX" --guards secret-scan --headless)"
+[[ "$RC" == "0" ]] || fail "secret-scan-only install failed rc=$RC"
+OUT="$(run_gen_out "$FX" --uninstall orphan-test)"
+if [[ "${OUT%%|*}" == "0" && "${OUT#*|}" == *"not installed"* && "${OUT#*|}" != *"job-stripped"* ]]; then
+  pass "--uninstall of a never-installed ci guard reports not-installed (no phantom job-strip)"
+else
+  fail "never-installed ci guard arm: rc=${OUT%%|*} out=${OUT#*|}"
+fi
+grep -qF 'verification-scaffold:begin:secret-scan' "$FX/.github/workflows/verification-gates.yml" \
+  && pass "shared workflow untouched by the never-installed guard's uninstall" \
+  || fail "workflow lost its secret-scan block on a phantom uninstall"
+
+# --- doc block is pruned once no v1 artifact remains (#10759) --------------------
+OUT="$(run_gen_out "$FX" --uninstall secret-scan)"
+if [[ "${OUT%%|*}" == "0" && ! -e "$FX/VERIFICATION.md" \
+   && ! -e "$FX/.github/workflows/verification-gates.yml" ]]; then
+  pass "last-guard uninstall prunes the stale VERIFICATION.md marker block"
+else
+  fail "doc-block prune arm: rc=${OUT%%|*} VERIFICATION.md=$(ls "$FX/VERIFICATION.md" 2>/dev/null || echo absent)"
+fi
+
+# --- default branch named a&b still emits a working regex (#10759) ----------------
+FX="$(mkrepo ampbranch)"; assert_fixture_dir "$FX"
+git -C "$FX" update-ref refs/remotes/origin/a\&b "$(git -C "$FX" rev-parse HEAD)"
+git -C "$FX" symbolic-ref refs/remotes/origin/HEAD refs/remotes/origin/a\&b
+RC="$(run_gen "$FX" --guards commit-on-main --mode enforce --headless)"
+if [[ "$RC" == "0" ]] && ! grep -qF '@DEFAULT_BRANCHES@' "$FX/scripts/verification/precommit-guard.sh"; then
+  pass "default branch 'a&b': emitted regex is literal — enforce install + bite green"
+else
+  fail "a&b default-branch arm: rc=$RC"
+fi
+
+printf '\n%d pass(es), %d fail(s)\n' "$passes" "$fails"
+[[ "$fails" -eq 0 ]]

package/skills/verification-scaffold/test/manifest.test.sh

@@ -0,0 +1,144 @@
+#!/usr/bin/env bash
+# Manifest consistency for verification-scaffold (#10404):
+#   1. every guards.tsv v1 row's templates exist under references/, and every
+#      references/guards/*.template is named by some v1 row (no orphans either way);
+#   2. every audit corpus member (.claude/hooks/**/*.sh non-test + scripts/lint-*
+#      minus .test.sh/.baseline.txt/.highwater) appears in guardrail-audit.md —
+#      the census is git-ls-files driven, so a NEW unclassified member reds CI;
+#   3. one-hunk parity (AC11): precommit-guard.sh.template renders byte-identical
+#      to plugins/soleur/scripts/precommit-guard.sh under the default
+#      main|master substitution and the VERIFICATION_->SOLEUR_ rename; the
+#      wrapper-boundary pair is the same rename-normalized cmp;
+#   4. emitted-content hygiene (AC8): zero SOLEUR_/knowledge-base//plugins/soleur
+#      refs and zero curl|wget|https?:// tokens outside comments in templates;
+#   5. portability floor: no GNU-only tokens (sed -i, readlink -f, stat -c,
+#      date -d, bc, /usr/bin/time, unguarded `timeout`) in emitted templates;
+#   6. the emitted verification-gates.yml renders actionlint-clean (when
+#      actionlint is on PATH).
+# Runs in the scripts shard. Accumulate-then-exit.
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../../../.." && pwd)"
+SKILL="$REPO_ROOT/plugins/soleur/skills/verification-scaffold"
+TSV="$SKILL/references/guards.tsv"
+AUDIT="$SKILL/references/guardrail-audit.md"
+
+passes=0; fails=0
+pass() { printf 'ok   - %s\n' "$1"; passes=$((passes + 1)); }
+fail() { printf 'FAIL - %s\n' "$1"; fails=$((fails + 1)); }
+
+# --- 1. guards.tsv v1 rows <-> templates -----------------------------------------
+missing=0
+while IFS=$'\t' read -r name verdict surfaces templates dmode deps src emits tier; do
+  case "$name" in \#*|name) continue ;; esac
+  [[ "$tier" == "v1" ]] || continue
+  [[ -n "$name" && -n "$templates" && -n "$emits" ]] || { fail "guards.tsv row malformed: $name"; missing=1; continue; }
+  IFS=';' read -ra tp <<<"$templates"
+  for t in "${tp[@]}"; do
+    [[ -f "$SKILL/$t" ]] || { fail "guards.tsv $name names missing template: $t"; missing=1; }
+  done
+done < "$TSV"
+[[ "$missing" -eq 0 ]] && pass "every v1 row's templates exist"
+
+orphaned=0
+while IFS= read -r t; do
+  rel="${t#"$SKILL/"}"
+  # A template is owned by a guards.tsv row (guard artifacts) or by the
+  # generator itself (the doc block: verification-readme.template).
+  grep -qF "$rel" "$TSV" || grep -qF "$rel" "$SKILL/scripts/verification-scaffold.sh" \
+    || { fail "orphaned template (named by nothing): $rel"; orphaned=1; }
+done < <(find "$SKILL/references" -name '*.template' | sort)
+[[ "$orphaned" -eq 0 ]] && pass "every template is named by a guards.tsv row or the generator"
+
+# --- 2. audit census over the live tree -------------------------------------------
+# The producer is git ls-files — identical to this file's own corpus definition,
+# so a new member lacking an audit row is caught here, not by review.
+uncov=0
+while IFS= read -r f; do
+  base="$(basename "$f")"
+  grep -qF "$base" "$AUDIT" || { fail "audit has no row for $f"; uncov=1; }
+done < <(git -C "$REPO_ROOT" ls-files '.claude/hooks/*.sh' | grep -v '\.test\.sh$' | grep -v '/test/')
+while IFS= read -r f; do
+  base="$(basename "$f")"
+  grep -qF "$base" "$AUDIT" || { fail "audit has no row for $f"; uncov=1; }
+done < <(git -C "$REPO_ROOT" ls-files 'scripts/lint-*' | grep -v '\.test\.sh$\|\.baseline\.txt$\|\.highwater')
+[[ "$uncov" -eq 0 ]] && pass "audit covers every corpus member (git ls-files census)"
+
+# --- 3. one-hunk parity (AC11) ------------------------------------------------------
+SRC_GUARD="$REPO_ROOT/plugins/soleur/scripts/precommit-guard.sh"
+SRC_WRAP="$REPO_ROOT/plugins/soleur/scripts/lib/wrapper-boundary.sh"
+rendered="$(mktemp)"; trap 'rm -f "$rendered"' EXIT
+sed -e 's/VERIFICATION_/SOLEUR_/g' -e 's/@DEFAULT_BRANCHES@/main|master/g' \
+    "$SKILL/references/guards/precommit-guard.sh.template" > "$rendered"
+cmp -s "$rendered" "$SRC_GUARD" \
+  && pass "precommit-guard template renders byte-identical to source under main|master" \
+  || fail "precommit-guard template/source drifted (run: diff <(sed -e s/VERIFICATION_/SOLEUR_/g -e s/@DEFAULT_BRANCHES@/main\\\\|master/g .../precommit-guard.sh.template) plugins/soleur/scripts/precommit-guard.sh)"
+sed 's/VERIFICATION_/SOLEUR_/g' "$SKILL/references/guards/wrapper-boundary.sh.template" > "$rendered"
+cmp -s "$rendered" "$SRC_WRAP" \
+  && pass "wrapper-boundary template is rename-normalized byte-identical to source" \
+  || fail "wrapper-boundary template/source drifted"
+
+# --- 4. emitted-content hygiene (AC8) ----------------------------------------------
+# Templates contain @PLACEHOLDER@ markers; the runtime text must carry zero
+# Soleur couplings and zero network egress.
+hyg=0
+while IFS= read -r t; do
+  if grep -nE 'SOLEUR_|knowledge-base/|plugins/soleur' "$t" >/dev/null; then
+    fail "Soleur coupling in template $(basename "$t"): $(grep -nE 'SOLEUR_|knowledge-base/|plugins/soleur' "$t" | head -3 | tr '\n' ';')"
+    hyg=1
+  fi
+  # egress tokens outside comments: strip comment lines then grep.
+  if grep -vE '^[[:space:]]*#' "$t" | grep -nE 'curl|wget|https?://' >/dev/null; then
+    fail "network egress token in template $(basename "$t")"
+    hyg=1
+  fi
+done < <(find "$SKILL/references" -name '*.template' | sort)
+[[ "$hyg" -eq 0 ]] && pass "zero Soleur couplings + zero egress tokens in emitted templates"
+
+# --- 5. portability floor ----------------------------------------------------------
+# GNU-only forms banned in emitted templates (stock macOS must run them).
+port=0
+while IFS= read -r t; do
+  case "$t" in *.yml.template) continue ;; esac
+  if grep -nE 'sed -i|readlink -f|realpath|stat -c|date -d|/usr/bin/time|(^|[;&| ]|^[^#]*[;&| ])bc |mapfile' "$t" | grep -vE '^[0-9]+:[[:space:]]*#' >/dev/null; then
+    fail "GNU-only token in template $(basename "$t"): $(grep -nE 'sed -i|readlink -f|realpath|stat -c|date -d|/usr/bin/time|bc |mapfile' "$t" | grep -vE '^[0-9]+:[[:space:]]*#' | head -3 | tr '\n' ';')"
+    port=1
+  fi
+  if grep -nE '(^|[^_a-zA-Z])timeout [0-9]' "$t" | grep -v 'command -v timeout\|gtimeout' >/dev/null; then
+    fail "unguarded timeout invocation in $(basename "$t")"
+    port=1
+  fi
+done < <(find "$SKILL/references" -name '*.template' | sort)
+[[ "$port" -eq 0 ]] && pass "portability floor: no GNU-only forms in emitted templates"
+
+# --- 6. actionlint on the RENDERED workflow ------------------------------------------
+if command -v actionlint >/dev/null 2>&1; then
+  WF="$(mktemp -d)"
+  # Render like the generator does: keep both job blocks, stamp continue-on-error.
+  awk '{print}' "$SKILL/references/guards/verification-gates.yml.template" \
+    | sed 's/@CI_CONTINUE_ON_ERROR@/true/g' > "$WF/verification-gates.yml"
+  if actionlint -oneline "$WF/verification-gates.yml" >"$WF/lint.log" 2>&1; then
+    pass "rendered verification-gates.yml is actionlint-clean"
+  else
+    fail "actionlint reds on rendered workflow: $(cat "$WF/lint.log" | head -5 | tr '\n' ';')"
+  fi
+  rm -rf "$WF"
+else
+  pass "actionlint not on PATH — workflow lint arm skipped (CI must provide it)"
+fi
+
+# --- 7. SKILL.md + audit + tsv exist and are non-empty -------------------------------
+for f in "$SKILL/SKILL.md" "$AUDIT" "$TSV" "$SKILL/references/verification-readme.template" "$SKILL/references/gitleaks.toml.template"; do
+  [[ -s "$f" ]] || fail "missing/empty: ${f#"$REPO_ROOT"/}"
+done
+pass "required skill files exist (SKILL.md presence asserted by the file list)"
+
+# guards.tsv: the emitted .gitleaks.toml is a default-ruleset pointer (Guard 1
+# mutation-6 anchor — the template's declared ruleset shape is pinned here).
+grep -q 'useDefault = true' "$SKILL/references/gitleaks.toml.template" \
+  && pass "gitleaks.toml.template is the default-ruleset pointer guards.tsv declares" \
+  || fail "gitleaks.toml.template lost its useDefault=true ruleset shape"
+
+printf '\n%d pass(es), %d fail(s)\n' "$passes" "$fails"
+[[ "$fails" -eq 0 ]]