@spardutti/claude-skills 2.45.0 → 2.47.0

package/README.md

@@ -137,6 +137,7 @@ Portable slash commands installed to `.claude/commands/`. Some orchestrate paral
 | `/optimize` | Make one measured job faster without changing what it proves — fixes a benchmark and a result that must not move, sends 4 read-only subagents to find suspects, then changes one thing per round with a prediction written first, keeping only what beats the noise. Profiles after every wrong prediction, reruns before judging a result that flipped, and ends by writing the cause as a skill rule for you |
 | `/handoff` | Write a handoff doc so a fresh session picks the work up — captures what auto-compaction loses: decisions made and rejected, dead ends already ruled out, why the tree is dirty, and the one next step |
 | `/lockdown` | Per-repo supply-chain hardening — detects the package managers, Dockerfiles, and CI in use, then guides you through and applies install-time, deploy, and pipeline hardening for npm/pnpm, pip/uv, Docker, and GitHub Actions |
+| `/skill-report` | Which installed skills earn their place in this repo — every `/ship` skills audit is logged by a hook, and this tallies it: how often each skill applied, how often it caught a violation, and the rule it catches most. Names rules that break often enough to become a script check, and skills that never flag and may be dead weight |
 
 ## How It Works
 
@@ -193,6 +194,7 @@ scripts/       validate-skills.mjs — checks skill length caps and reference in
                ship-gate.sh — /ship's file-length, folder-structure and mutation checks, behind an exit code
                ship-gate-hook.sh — refuses gh pr create/merge without a ship-gate receipt
                version-check.sh — SessionStart nudge when a newer catalog is published
+               skill-flags-record.sh — logs each /ship skills-audit verdict; skill-report.mjs tallies it
                gauntlet-selftest.sh — behavioural tests for the hooks (runs on pre-push)
                gauntlet-survey.sh — what the hook would do in every repo under a directory
                preflight.sh — everything that must pass before a release

package/hooks/ship-gate-files.sh

@@ -0,0 +1,112 @@
+#!/usr/bin/env bash
+# Sourced by ship-gate.sh: which changed files a Stryker run can skip, and what its output says.
+
+TEST_RE='(\.|_)(test|spec)\.[^.]+$|(^|/)tests?/'
+
+stryker_owner() {  # stryker_owner <owner> <owned files>
+  b=""; [ "$1" != "." ] && b="$1/"
+  [ -z "$GAUNTLET_MUTATE" ] && ! grep -q '\.py$' <<< "$2" \
+    && grep -qs '@stryker-mutator/core' "${b}package.json"
+}
+
+changed_tests() {  # changed_tests <family>
+  printf '%s\n' "$CHANGED" | grep -E "$TEST_RE" | while IFS= read -r t; do
+    [ -n "$t" ] && [ "$(family_of "$t")" = "$1" ] && printf '%s\n' "$t"
+  done
+}
+
+# Everything a file's verdict rests on besides the file itself and the tests.
+# Tests are left out: adding to them can only kill more, so only a lost line counts.
+files_context() {  # files_context <owner> <owned files>
+  fam=$(family_of "$1/.")
+  { printf '%s\n' "$PROJECT_DIR" "$1" "$(git rev-parse "$BASE" 2>/dev/null)"
+    cat "$HERE/ship-gate.sh" "$HERE/ship-gate-projects.sh" "$HERE/ship-gate-files.sh"
+    printf '%s\n' "$CHANGED" | grep -vE '\.(md|mdx|txt|rst|adoc)$' | grep -vE "$TEST_RE" \
+      | grep -vxF -f <(printf '%s\n' "$2") | while IFS= read -r f; do
+      [ -n "$f" ] || continue
+      case "$(family_of "$f")" in "$fam"|any) printf '%s\n' "$f"; [ -f "$f" ] && cat "$f" ;; esac
+    done; } | git hash-object --stdin
+}
+
+file_receipt() {  # file_receipt <context> <file>
+  printf '/tmp/claude-shipgate-file-%s\n' "$({ printf '%s\n' "$1" "$2"; cat "$2"; } | git hash-object --stdin)"
+}
+
+test_then() {  # test_then <snapshot> <test>: its content when the snapshot was taken
+  if grep -qxF "$2" "$1/manifest"; then cat "$1/files/$2" 2>/dev/null
+  else git show "$BASE:$2" 2>/dev/null; fi
+}
+
+# Never `| grep -q` under pipefail: diff exits 1 on any difference, and an early
+# grep exit fails the writer, so a match reads as none.
+tests_lost_lines() {  # tests_lost_lines <snapshot> <family>
+  [ -f "$1/manifest" ] || return 0
+  while IFS= read -r t; do
+    [ -n "$t" ] || continue
+    case "$(diff <(test_then "$1" "$t") <(cat "$t" 2>/dev/null))" in *$'\n<'*) return 0 ;; esac
+  done <<< "$({ cat "$1/manifest"; changed_tests "$2"; } | sort -u)"
+  return 1
+}
+
+# Sets OWNED to the files that still need mutating.
+files_split() {  # files_split <context> <owner> <label>
+  fam=$(family_of "$2/."); kept=""; rest=""
+  while IFS= read -r f; do
+    [ -n "$f" ] || continue
+    r=$(file_receipt "$1" "$f")
+    if [ -f "$r" ] && ! tests_lost_lines "$(cat "$r")" "$fam"; then kept="$kept ${f#"$2"/}"
+    else rest="$rest$f"$'\n'; fi
+  done <<< "$OWNED"
+  OWNED=${rest%$'\n'}
+  [ -n "$kept" ] || return 0
+  echo "  $3 stryker — ok, not re-run: passed and unchanged since:$kept"
+  echo "      A change in a file they call is not re-checked."
+  b=""; [ "$2" != "." ] && b="$2/"
+  [ -z "$OWNED" ] && stryker_page_tests "$b" "$3"
+  return 0
+}
+
+# A finding with no location cannot be pinned on one file, so it keeps none.
+files_record() {  # files_record <context> <owner> <findings>
+  [ -n "$(printf '%s\n' "$3" | grep . | grep -vE ':[0-9]+:[0-9]+$')" ] && return 0
+  fam=$(family_of "$2/.")
+  snap="/tmp/claude-shipgate-tests-$({ printf '%s\n' "$1"; changed_tests "$fam" \
+    | while IFS= read -r t; do printf '%s\n' "$t"; cat "$t" 2>/dev/null; done; } | git hash-object --stdin)"
+  mkdir -p "$snap/files"; changed_tests "$fam" > "$snap/manifest"
+  while IFS= read -r t; do
+    [ -f "$t" ] && mkdir -p "$snap/files/$(dirname "$t")" && cp "$t" "$snap/files/$t"
+  done < "$snap/manifest"
+  while IFS= read -r f; do
+    [ -n "$f" ] || continue
+    grep -qF "  ${f#"$2"/}:" <<< "$3" && continue
+    printf '%s\n' "$snap" > "$(file_receipt "$1" "$f")"
+  done <<< "$OWNED"
+}
+
+# Match a finding, never a summary row. Stryker prints a `# survived` COLUMN
+# HEADER every run and repeats the word in its table, so a bare grep reports
+# survivors on a clean run — worse than not running at all. Stryker marks each
+# real finding `[Survived]`; table and border lines are excluded outright.
+# NoCoverage is printed exactly like Survived and means something worse: not
+# "a test missed this mutation" but "no test executes this line at all". The
+# gate matched only [Survived], so a diff whose files have no tests came back
+# PASS — 306 uncovered mutants reported as proven on one commit. It is judged
+# only for files that went in WITH a range: a glob-shaped path is mutated
+# whole, so its untouched lines would report uncovered forever, and a finding
+# nobody can close is what teaches people to --force.
+#
+# The status line carries no file name; the line under it does, as
+# file:line:column. They are paired here rather than grepped separately.
+stryker_findings() {  # stryker_findings <output> <globbed paths, comma-wrapped>
+  printf '%s\n' "$1" | awk -v globbed="$2" '
+    /^\[Survived\]/   { pend = $0; kind = "s"; next }
+    /^\[NoCoverage\]/ { pend = $0; kind = "n"; next }
+    pend != "" {
+      file = $0; sub(/:[0-9]+:[0-9]+$/, "", file)
+      if (kind == "s" || index(globbed, "," file ",") == 0) print pend "  " $0
+      pend = ""
+    }
+    # A survivor with no location under it is still a survivor, never dropped.
+    END { if (pend != "" && kind == "s") print pend }
+  '
+}

package/hooks/ship-gate-projects.sh

@@ -25,6 +25,18 @@ py_mutmut() {
   command -v mutmut >/dev/null 2>&1 && printf 'mutmut\n'
 }
 
+# Node that lives only in Docker leaves no Stryker on the host. An executable
+# .stryker-run runs it there instead, taking the arguments stryker would.
+stryker_bin() { if [ -x "$1.stryker-run" ]; then echo ./.stryker-run; else echo npx --no-install stryker; fi; }
+stryker_elsewhere() {  # stryker_elsewhere <tool> <base>: after a failed run, say where Stryker could run
+  [ "$1" = stryker ] && [ ! -x "$2.stryker-run" ] || return 0
+  d=$(cd "${2:-.}" && pwd)
+  while [ "$d" != / ]; do [ -d "$d/node_modules/@stryker-mutator/core" ] && return 0; d=$(dirname "$d"); done
+  echo "      Stryker is not installed on this machine. If Node runs only in Docker, add an"
+  echo "      executable $2.stryker-run that runs it there and passes on its arguments:"
+  echo "        docker compose run --rm -T <service> nice -n 19 npx stryker \"\$@\""
+}
+
 owner_of() {
   d=$(dirname "$1")
   while :; do
@@ -127,7 +139,7 @@ project_key() {  # project_key <owner> <tool>
   fam=$(family_of "$1/.")
   { printf '%s\n' "$PROJECT_DIR" "$1" "$2" "$(git rev-parse "$BASE" 2>/dev/null)" \
       "$GAUNTLET_NO_MUTATE" "$GAUNTLET_IGNORE_FILES"
-    cat "$HERE/ship-gate.sh" "$HERE/ship-gate-projects.sh"
+    cat "$HERE/ship-gate.sh" "$HERE/ship-gate-projects.sh" "$HERE/ship-gate-files.sh"
     printf '%s\n' "$CHANGED" | grep -vE '\.(md|mdx|txt|rst|adoc)$' | while IFS= read -r f; do
       [ -n "$f" ] || continue
       case "$(family_of "$f")" in "$fam"|any) printf '%s\n' "$f"; [ -f "$f" ] && cat "$f" ;; esac

package/hooks/ship-gate.sh

@@ -46,7 +46,7 @@
 set -uo pipefail
 
 HERE=$(cd "$(dirname "$0")" && pwd)
-. "$HERE/ship-gate-projects.sh" && . "$HERE/ship-gate-structure.sh" || { echo "ship-gate: cannot read its helpers in $HERE"; exit 1; }
+. "$HERE/ship-gate-projects.sh" && . "$HERE/ship-gate-structure.sh" && . "$HERE/ship-gate-files.sh" || { echo "ship-gate: cannot read its helpers in $HERE"; exit 1; }
 
 MODE=""
 case "${1:-}" in
@@ -122,7 +122,7 @@ if [ "$MODE" = force ]; then
 fi
 gate_report "$RECEIPT_KEY"
 SOURCED=$(printf '%s\n' "$CHANGED" | grep -E "\.($GAUNTLET_SOURCE_EXT)$" \
-        | grep -vE '(\.|_)(test|spec)\.[^.]+$|(^|/)tests?/|(^|/)\.stryker-tmp/' | while read -r f; do
+        | grep -vE "$TEST_RE|(^|/)\.stryker-tmp/" | while read -r f; do
           [ -f "$f" ] && printf '%s\n' "$f"
         done)
 
@@ -223,6 +223,7 @@ for owner in $OWNERS; do
   OWNED=$(while IFS= read -r f; do
             [ "$(owner_of "$f")" = "$owner" ] && printf '%s\n' "$f"
           done <<< "$FILES" | grep -vE "$GAUNTLET_NO_MUTATE" || true)
+  FCTX=""; if stryker_owner "$owner" "$OWNED"; then FCTX=$(files_context "$owner" "$OWNED"); files_split "$FCTX" "$owner" "$label"; fi
   [ -z "$OWNED" ] && continue
 
   # ONE comma-joined --mutate value, never a flag per range. Stryker's CLI
@@ -271,7 +272,7 @@ for owner in $OWNERS; do
     # 8 of them on one commit, all long since killed. --mutate already scopes
     # the run to the changed hunks, so incremental buys nothing here and costs
     # a cache that goes stale exactly the way mutmut's did.
-    CMD="${RUN}npx --no-install stryker run --concurrency $(gate_workers) --mutate '${FLAGS#,}'"; stryker_page_tests "$base" "$label"
+    CMD="${RUN}$(stryker_bin "$base") run --concurrency $(gate_workers) --mutate '${FLAGS#,}'"; stryker_page_tests "$base" "$label"
   elif [ -z "$PY" ] && [ -f "$base"package.json ]; then
     MISSING="$MISSING  $label needs Stryker:
       npm --prefix ${owner} i -D @stryker-mutator/core @stryker-mutator/vitest-runner
@@ -324,32 +325,9 @@ for owner in $OWNERS; do
   T0=$SECONDS; OUT=$(export FILES="$(printf '%s' "$OWNED" | tr '\n' ' ')" MUTATE_FLAGS="--mutate ${FLAGS#,}"; eval "$CMD" 2>&1); RC=$?; T=$((SECONDS - T0))
   [ "$TOOL" = mutmut ] && [ $RC -eq 0 ] && { printf '%s\n' "$OUT" > "$PKEY.out"; cp "$MLOG" "$PKEY.log" 2>/dev/null; }
   [ -n "$SCOPE_RE" ] && [ $RC -eq 0 ] && OUT=$(printf '%s\n' "$OUT" | grep -E "^[[:space:]]*($SCOPE_RE)\.x")
-  # Match a finding, never a summary row. Stryker prints a `# survived` COLUMN
-  # HEADER every run and repeats the word in its table, so a bare grep reports
-  # survivors on a clean run — worse than not running at all. Stryker marks each
-  # real finding `[Survived]`; table and border lines are excluded outright.
-  # NoCoverage is printed exactly like Survived and means something worse: not
-  # "a test missed this mutation" but "no test executes this line at all". The
-  # gate matched only [Survived], so a diff whose files have no tests came back
-  # PASS — 306 uncovered mutants reported as proven on one commit. It is judged
-  # only for files that went in WITH a range: a glob-shaped path is mutated
-  # whole, so its untouched lines would report uncovered forever, and a finding
-  # nobody can close is what teaches people to --force.
-  #
-  # The status line carries no file name; the line under it does, as
-  # file:line:column. They are paired here rather than grepped separately.
   if [ "$TOOL" = stryker ]; then
-    ALL=$(printf '%s\n' "$OUT" | awk -v globbed="$GLOBBED" '
-      /^\[Survived\]/   { pend = $0; kind = "s"; next }
-      /^\[NoCoverage\]/ { pend = $0; kind = "n"; next }
-      pend != "" {
-        file = $0; sub(/:[0-9]+:[0-9]+$/, "", file)
-        if (kind == "s" || index(globbed, "," file ",") == 0) print pend "  " $0
-        pend = ""
-      }
-      # A survivor with no location under it is still a survivor, never dropped.
-      END { if (pend != "" && kind == "s") print pend }
-    ')
+    ALL=$(stryker_findings "$OUT" "$GLOBBED")
+    [ -n "$FCTX" ] && [ $RC -eq 0 ] && files_record "$FCTX" "$owner" "$ALL"
   else
     ALL=$(printf '%s\n' "$OUT" | grep -E '[Ss]urvived' \
           | grep -vE '^[[:space:]]*[#│|+-]|# *surviv')
@@ -433,7 +411,7 @@ for owner in $OWNERS; do
     STATUS=1
   elif [ $RC -ne 0 ]; then
     echo "  $label $TOOL (${T}s) — the run failed:"
-    printf '%s\n' "$OUT" | tail -12 | sed 's/^/      /'
+    printf '%s\n' "$OUT" | tail -12 | sed 's/^/      /'; stryker_elsewhere "$TOOL" "$base"
     [ "$STATUS" = 0 ] && STATUS=2
   elif [ -n "$NOTE" ]; then
     printf '%s\n' "$NOTE"

package/hooks/skill-flags-record.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# SubagentStop: appends each gauntlet-skills verdict to .claude/skill-flags.jsonl.
+
+INPUT=$(cat | tr -d '\n')
+
+case "$INPUT" in
+  *'"agent_type":"gauntlet-skills"'*) ;;
+  *) exit 0 ;;
+esac
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(dirname "$(dirname "$SCRIPT_DIR")")"
+
+# Kept JSON-escaped as it arrived, so the line stays valid JSON without a parser.
+REPLY=$(printf '%s' "$INPUT" | sed -nE 's/.*"last_assistant_message":"(([^"\\]|\\.)*)".*/\1/p')
+[ -z "$REPLY" ] && exit 0
+
+TRANSCRIPT=$(printf '%s' "$INPUT" | grep -o '"agent_transcript_path":"[^"]*"' | head -1 | sed 's/.*:"//; s/"$//')
+MODEL=""
+[ -f "$TRANSCRIPT" ] && MODEL=$(grep -o '"model":"[^"]*"' "$TRANSCRIPT" | tail -1 | sed 's/.*:"//; s/"$//')
+
+printf '{"ts":"%s","model":"%s","reply":"%s"}\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$MODEL" "$REPLY" \
+  >> "$PROJECT_DIR/.claude/skill-flags.jsonl"
+
+exit 0

package/hooks/skill-report.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+// Prints, per skill, how often the /ship skills audit applied it and flagged a violation.
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const DEFAULT_LOG = fileURLToPath(new URL("../skill-flags.jsonl", import.meta.url));
+
+function parseVerdict(line) {
+  try {
+    const { model, reply } = JSON.parse(line);
+    return { model, verdict: JSON.parse(reply.slice(reply.indexOf("{"), reply.lastIndexOf("}") + 1)) };
+  } catch {
+    return null;
+  }
+}
+
+function tally(lines) {
+  const skills = new Map();
+  const models = new Map();
+  let unreadable = 0;
+  for (const line of lines) {
+    const parsed = parseVerdict(line);
+    if (!parsed?.verdict?.skill) { unreadable++; continue; }
+    const { model, verdict } = parsed;
+    if (!(verdict.checked > 0)) continue;
+    const s = skills.get(verdict.skill) ?? { audits: 0, flagged: 0, rules: new Map() };
+    s.audits++;
+    const violations = Array.isArray(verdict.violations) ? verdict.violations : [];
+    if (violations.length) s.flagged++;
+    for (const v of violations) s.rules.set(v.rule, (s.rules.get(v.rule) ?? 0) + 1);
+    skills.set(verdict.skill, s);
+    if (model) models.set(model, (models.get(model) ?? 0) + 1);
+  }
+  return { skills, models, unreadable };
+}
+
+function topRule(rules) {
+  const [rule] = [...rules].sort((a, b) => b[1] - a[1])[0] ?? ["-"];
+  return rule.length > 60 ? rule.slice(0, 57) + "..." : rule;
+}
+
+function render({ skills, models, unreadable }) {
+  if (!skills.size) return "No skill audits recorded yet. Run /ship to record some.";
+  const rows = [...skills].sort((a, b) => b[1].flagged - a[1].flagged || a[0].localeCompare(b[0]));
+  const width = Math.max(5, ...rows.map(([name]) => name.length));
+  const out = [`${"skill".padEnd(width)}  audits  flagged  top rule broken`];
+  for (const [name, s] of rows) {
+    out.push(`${name.padEnd(width)}  ${String(s.audits).padStart(6)}  ${String(s.flagged).padStart(7)}  ${topRule(s.rules)}`);
+  }
+  if (models.size) out.push("", "models: " + [...models].map(([m, n]) => `${m} (${n})`).join(", "));
+  if (unreadable) out.push(`unreadable lines: ${unreadable}`);
+  return out.join("\n");
+}
+
+let text = "";
+try {
+  text = readFileSync(process.argv[2] ?? DEFAULT_LOG, "utf-8");
+} catch {
+  // no log yet
+}
+console.log(render(tally(text.split("\n").filter(Boolean))));

package/lib/hook-settings.mjs

@@ -11,6 +11,7 @@ const GAUNTLET_FILENAME = "gauntlet.sh";
 const SHIP_GATE_FILENAME = "ship-gate.sh";
 const SHIP_GATE_HOOK_FILENAME = "ship-gate-hook.sh";
 const VERSION_CHECK_FILENAME = "version-check.sh";
+const SKILL_FLAGS_FILENAME = "skill-flags-record.sh";
 const LEGACY_EVAL_FILENAME = "skill-forced-eval-hook.sh";
 const LEGACY_AUDIT_RUNNER_FILENAME = "skill-audit-runner.sh";
 
@@ -116,6 +117,16 @@ export async function registerHooks(settingsPath) {
     settings.hooks.Stop = [gauntletEntry];
   }
 
+  // No matcher: the script filters on agent_type itself.
+  const skillFlagsCommand = `$CLAUDE_PROJECT_DIR/.claude/hooks/${SKILL_FLAGS_FILENAME}`;
+  const skillFlagsEntry = { hooks: [{ type: "command", command: skillFlagsCommand }] };
+
+  if (Array.isArray(settings.hooks.SubagentStop)) {
+    upsert(settings.hooks.SubagentStop, SKILL_FLAGS_FILENAME, skillFlagsEntry);
+  } else {
+    settings.hooks.SubagentStop = [skillFlagsEntry];
+  }
+
   // Both gates clear by touching a marker under /tmp. The hook scripts let those
   // commands through themselves, but auto mode's permission classifier does not:
   // a touch whose only purpose is to unlock a gate is exactly what it refuses.

package/lib/setup-hook.mjs

@@ -20,6 +20,8 @@ import { homedir } from "node:os";
 //   ship-gate-projects.sh     sourced by ship-gate.sh — project detection, reuse
 //   ship-gate-hook.sh         PreToolUse on Bash — no commit without a receipt
 //   version-check.sh          SessionStart — a line when a newer catalog exists
+//   skill-flags-record.sh     SubagentStop — logs each skills-audit verdict
+//   skill-report.mjs          read by /skill-report — tallies that log
 
 const GATE_FILENAME = "skill-gate.sh";
 const AUTO_MARK_FILENAME = "skill-gate-automark.sh";
@@ -28,8 +30,11 @@ const GAUNTLET_FILENAME = "gauntlet.sh";
 const SHIP_GATE_FILENAME = "ship-gate.sh";
 const SHIP_GATE_PROJECTS_FILENAME = "ship-gate-projects.sh";
 const SHIP_GATE_STRUCTURE_FILENAME = "ship-gate-structure.sh";
+const SHIP_GATE_FILES_FILENAME = "ship-gate-files.sh";
 const SHIP_GATE_HOOK_FILENAME = "ship-gate-hook.sh";
 const VERSION_CHECK_FILENAME = "version-check.sh";
+const SKILL_FLAGS_FILENAME = "skill-flags-record.sh";
+const SKILL_REPORT_FILENAME = "skill-report.mjs";
 const LEGACY_EVAL_FILENAME = "skill-forced-eval-hook.sh";
 const LEGACY_AUDIT_RUNNER_FILENAME = "skill-audit-runner.sh";
 
@@ -108,8 +113,11 @@ export async function setupHook(targetDir = process.cwd()) {
     SHIP_GATE_FILENAME,
     SHIP_GATE_PROJECTS_FILENAME,
     SHIP_GATE_STRUCTURE_FILENAME,
+    SHIP_GATE_FILES_FILENAME,
     SHIP_GATE_HOOK_FILENAME,
     VERSION_CHECK_FILENAME,
+    SKILL_FLAGS_FILENAME,
+    SKILL_REPORT_FILENAME,
   ]) {
     const dest = join(hooksDir, name);
     await writeFile(dest, await readHookSource(name), { mode: 0o755 });
@@ -131,5 +139,6 @@ export async function setupHook(targetDir = process.cwd()) {
   console.log(`  Hook installed: .claude/hooks/${GAUNTLET_FILENAME}`);
   console.log(`  Installed: .claude/hooks/${SHIP_GATE_FILENAME} (used by /ship)`);
   console.log(`  Hook installed: .claude/hooks/${SHIP_GATE_HOOK_FILENAME}`);
+  console.log(`  Hook installed: .claude/hooks/${SKILL_FLAGS_FILENAME}`);
   console.log(`  Settings updated: .claude/settings.json`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spardutti/claude-skills",
-  "version": "2.45.0",
+  "version": "2.47.0",
   "description": "Guardrails for Claude Code — best-practice skills, planning commands, and delivery gates.",
   "type": "module",
   "repository": {
@@ -11,7 +11,7 @@
     "claude-skills": "bin/cli.mjs"
   },
   "scripts": {
-    "prepack": "cp ../README.md README.md && mkdir -p hooks && cp ../scripts/skill-gate.sh ../scripts/skill-gate-automark.sh ../scripts/skill-application-gate.sh ../scripts/gauntlet.sh ../scripts/ship-gate.sh ../scripts/ship-gate-projects.sh ../scripts/ship-gate-structure.sh ../scripts/ship-gate-hook.sh ../scripts/version-check.sh hooks/",
+    "prepack": "cp ../README.md README.md && mkdir -p hooks && cp ../scripts/skill-gate.sh ../scripts/skill-gate-automark.sh ../scripts/skill-application-gate.sh ../scripts/gauntlet.sh ../scripts/ship-gate.sh ../scripts/ship-gate-projects.sh ../scripts/ship-gate-structure.sh ../scripts/ship-gate-files.sh ../scripts/ship-gate-hook.sh ../scripts/version-check.sh ../scripts/skill-flags-record.sh ../scripts/skill-report.mjs hooks/",
     "postpack": "git checkout -- README.md && rm -rf hooks"
   },
   "engines": {