@chrono-meta/fh-gate 1.4.87 → 1.4.88

package/.claude-plugin/marketplace.json

@@ -11,13 +11,13 @@
   "plugins": [
     {
       "name": "fh-meta",
-      "version": "1.4.87",
+      "version": "1.4.88",
       "description": "Hub meta-operations toolkit — 35 skills + 7 agents. New in 1.4.53: `fh-codex-doctor` (npm bin) — Codex adapter drift scanner; reads the documented M1/M2/M3 skill tier map + skill/agent source and reports codex-native/adapter-required/claude-native/unclassified per unit, wired into `npm test`/`prepublishOnly` (fail-closed on unclassified Claude-native primitives). New in 1.4.49: steel-quench gains Step 0.6 Verdict-Invariance Probe (groundedness axis — a load-bearing judged gate's verdict must track behavior, not rubric phrasing; measured flip-count over cross-family paraphrases; arXiv:2605.06161 Policy Invariance anchor); multi_model_sidecar_strategy §Vendor-native harness (a model is strongest in its own vendor CLI — Claude/CC, GPT/codex, Gemini/Antigravity; a universal router degrades all of them, so it stays an autocomplete/QA sidecar, never orchestration); predelete_check.sh fail-closed rewrite; memory-hygiene A-TMA anchor. New in 1.4.48: phantom-quench + steel-quench gain external frontier anchors (arXiv:2607.02052 package-hallucination; arXiv:2607.02057 prompt-coverage-adequacy); README model-flat claim reframed from a per-release point-curve to structural invariants (operation flattens across tiers; depth tier-order fixed within a generation). New in 1.4.47: onboarding step ① surfaces the Mode D companion-store session-start load in the auto-read salience anchor (previously only in the local binding + rules, so a greeting could skip the load). New in 1.4.46: context-doctor command-output axis (route to rtk/proxy for verbose CLI stdout, complementing .claudeignore; risk-gated to token-scarce envs). New in 1.4.41: context-doctor 2026 trigger vocab (context engineering/rot/collapse) + phantom-citation hardening; hub measurement-integrity-checklist (cross-model measurement pre-flight: display-name pin/reps≥3/discriminating probe). New in 1.4.40: install-wizard queryable-wiki scaffold (INDEX + session-start read + R/W/C ingest). New in 1.4.39: auto-decorrelation (cross-family verifier sidecar recruitment) + video-ingest (capability-routed video ingestion). New in 1.4.x: verify-axis check-class taxonomy (mandatory-pass/measured/judged), no-reinvention Tier-0 inventory, 7-class failure taxonomy, Destructive-Op Gate, Wave-T (Temper), tier-floor governance, Mode D Model Notice, FC consent lane, default-Sonnet guidance. New in 1.3.0: public-surface-audit, field-harvest Mode B auto-trigger, 4-axis gate scope ext. Validated cross-CLI: Claude Code, Codex, Gemini.",
       "source": "./plugins/fh-meta"
     },
     {
       "name": "fh-commons",
-      "version": "1.4.87",
+      "version": "1.4.88",
       "description": "Project-agnostic utility skills — 4 skills (convergence-loop · deliberation · mcp-circuit-breaker · token-budget-gate) + 1 agent (quench-challenger). Domain-independent utilities transplantable into any project.",
       "source": "./plugins/fh-commons"
     }

package/knowledge/shared/learnings/subagent_invocations_log.yaml

@@ -944,3 +944,55 @@
     entry per the "counts and outcomes, not one stub per dispatch" rule.
     Instrument note: the invocation form matters — `| codex exec -` (stdin) as recorded in
     [[feedback_sidecar_liveness_not_passive_wait]]; the argv form hangs nondeterministically.
+
+- date: '2026-08-04'
+  agent: codex/gpt-5.5 (cross-family sidecar, auto-decorrelation)
+  context: >-
+    FH self-dev — two load-bearing gate changes (PR #253 degrade-scan S5 rule, PR #254/#255 Axis-1
+    pathspec parity + anchor wiring). Pre-push gate demanded a cross-family leg on both.
+  dispatches: '3 (2 completed, 1 killed on timeout and re-run)'
+  outcome: accepted
+  evidence: >-
+    Round 1 (PR #253): REFUTED the author's own fix. The first repair widened the S5 rule with a
+    NAMED filter list; codex produced reproduced counter-examples in BOTH directions — still-missed
+    real disarms (`grep -Ec`, `grep --count`, `grep -Fcx`, `| cat`) and a NEW false positive the
+    repair introduced (`| tail -n +2` yields one line, not a disarm). It also caught that a fixture
+    labelled known-NEGATIVE was in fact a positive, because its upstream succeeded and therefore
+    never exercised the failure path it claimed to pin. All four re-run locally before acceptance.
+    Round 2 (PR #255 wiring): no blocker; one residual raised ("a distribution that SHOULD be
+    complete but drops a subject reports SKIP, not FAIL"), which was then TESTED and confirmed
+    uncovered by any existing anchor. Recorded as a WEAK signal — the auditor stated it could not
+    trace F1-F3 because those implementations were not in the diff it was given, and that residual
+    was closed locally by measurement, not by the auditor.
+  note: >-
+    Third consecutive session where the cross-family leg produced net-new findings the same-family
+    round walked past. New this session: the two rounds differed in SIGNAL STRENGTH (refutation vs
+    nothing-found), and both markers record which one it was — recording them at equal weight would
+    launder a weak pass into a strong one.
+    Instrument note: the FIRST attempt derailed into its own sidecar-availability exploration and
+    timed out (exit 124, ~7 min). Re-running with an explicit "Do NOT run shell commands, do NOT use
+    tools, answer ONLY from the text below" preamble fixed it. Stdin form `codex exec -m gpt-5.5
+    --skip-git-repo-check -` as recorded in [[feedback_sidecar_liveness_not_passive_wait]].
+    These were CLI sidecars, not Agent-tool spawns, so the SubagentStop hook tallied ZERO — the
+    ④-e check passed on a true zero while three real dispatches had happened. Named gap: the tally
+    is blind to CLI-invoked sidecars.
+
+- date: '2026-08-05'
+  agent: (unattributed — SubagentStop tally only)
+  context: >-
+    Close chain of the 2026-08-04 session, which crossed midnight. The tally file recorded ONE
+    dispatch dated 2026-08-05; this session made no Agent-tool spawn that it is aware of.
+  dispatches: '1 (tallied, origin not attributable)'
+  outcome: sustained
+  evidence: >-
+    Recorded rather than guessed. The substantive sidecar work of this session is the 2026-08-04
+    entry above (3 codex CLI dispatches). MEASURED here, after the claim had already been written
+    into a commit message and the session card: a `codex exec` call does NOT increment the tally
+    (before=1, after=1 on `grep -c '^2026-08-05$'`), and the hook matcher is `SubagentStop`, i.e.
+    Agent-tool spawns only. So the CLI-blindness claim holds — but its evidence arrived AFTER
+    publication, which is the ordering CLAUDE.md §Instrument-Calibration forbids.
+  note: >-
+    What produced the 4 tallies dated 2026-08-04 and this 1 dated 2026-08-05 is UNKNOWN. Not
+    invented: a fabricated outcome would poison the 60/40 promotion gate worse than a missing one,
+    which is the stated reason the hook only tallies and never writes an entry. Open question for
+    the next session that touches the tally: which tool events actually fire SubagentStop here.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrono-meta/fh-gate",
-  "version": "1.4.87",
+  "version": "1.4.88",
   "description": "FH runtime adapters — run FH governance, skills, and agents via Claude or Codex with machine-parseable gates.",
   "license": "MIT",
   "keywords": [

package/plugins/fh-commons/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "fh-commons",
-  "version": "1.4.87",
+  "version": "1.4.88",
   "engines": {
     "claudeCode": ">=1.0.0"
   },

package/plugins/fh-meta/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "fh-meta",
-  "version": "1.4.87",
+  "version": "1.4.88",
   "engines": {
     "claudeCode": ">=1.0.0"
   },

package/scripts/degrade_direction_scan.sh

@@ -164,9 +164,41 @@ for f in "${FILES[@]}"; do
     # yields "9\n0" and the `-gt` guard goes silent. Verified as a known pair (both directions) in
     # scripts/test_degrade_scan_shell_probes.sh; narrowing without that anchor would just trade a
     # noisy probe for a blind one.
+    #
+    # WIDENED 2026-08-04 — the narrowing had gone one step too far, and the proof is that this
+    # probe was BLIND to the live instance that bit us the day before. PR #251 fixed
+    # `grep -c … | tr -d ' ' || echo 0` in session_close_check.sh ④-e; running this scanner over
+    # the pre-#251 file produced ZERO hits (re-measured: fixed rule = 2, old rule = 0).
+    #
+    # THE ANCHOR WAS ON THE WRONG PROPERTY. The old regex asked "is there an upstream pipe" and
+    # required the counter to be the LAST stage. Neither is the discriminator. The discriminator
+    # is: **does the failing side still EMIT?** `grep -c` prints "0" and exits 1 on no-match, so it
+    # disarms with no upstream pipe at all, and any trailing stage that passes that "0" through
+    # keeps the "0\n0" intact.
+    #
+    # A first fix widened to a NAMED filter list (tr|head|sed|…). Cross-family review (gpt-5.5,
+    # 2026-08-04) refuted it with reproduced counter-examples, and the refutation held on
+    # measurement in BOTH directions:
+    #   · still missed, all verified to yield "0\n0": `grep -Ec …`, `grep --count …`, `grep -Fcx …`
+    #     (combined/long flag forms the `-c` literal never matched) and `| cat`.
+    #   · newly over-matched: `| tail -n +2` after the counter yields ONE line — not a disarm.
+    # Name-based approximation produced under-match and over-match simultaneously. So the trailing
+    # chain is no longer enumerated: the rule keys on the COUNTER (grep with a `c` in any flag
+    # cluster or `--count`; or `wc` behind a real pipe) plus the `|| echo 0` fallback, and accepts
+    # any chain between them.
+    #
+    # PRESERVED from the 2026-07-28 narrowing, still pinned as known-negatives: (a) `a || b ||
+    # echo 0` has no pipeline, and (b) a stage that emits NOTHING on failure (`| jq -r … ||
+    # echo 0`) — there the fallback supplies the only line, as intended.
+    # KNOWN RESIDUAL, stated not hidden: a trailing stage that can swallow the counter's output
+    # (`| tail -n +2`, `| sed -n '/[1-9]/p'`) is now flagged though it is not a disarm. That is a
+    # deliberate recall-over-precision trade on an ADVISORY probe, taken because the measured cost
+    # of the other direction was a real defect shipping. Revisit if non-fixture FPs appear.
+    # Known pair: scripts/test_degrade_scan_shell_probes.sh (9 positives / negatives silent).
+    # Reverting this line turns the positive lane red — checked by applying the revert.
     while IFS= read -r m; do
-      emit "$f" "${m%%:*}" "S5:pipefail-fallback(sh)" "\`|| echo 0\` fallback on a pipeline ending in a counter (grep -c/wc) — that stage emits even when an upstream stage fails, so under \`set -o pipefail\` the value gains a SECOND line, the integer comparison errors out, and the guard passes silently; split the pipeline and sanitize to an integer"
-    done < <(grep -nE '[^|]\|[[:space:]]*([a-z]+[[:space:]]+)*(grep[^|]*-c|wc)[^|]*\|\|[[:space:]]*echo[[:space:]]+[\"'"'"']?0' "$f" 2>/dev/null \
+      emit "$f" "${m%%:*}" "S5:pipefail-fallback(sh)" "\`|| echo 0\` fallback after a COUNTER (grep with -c / --count, or wc) — the counter PRINTS \"0\" and exits non-zero on no-match, so the fallback appends a SECOND line, the value becomes \"0\\n0\", the integer test dies with 'integer expression expected' (stderr only) and the guard goes silent; split it and sanitize: n=\$(...); n=\${n:-0}; case \$n in *[!0-9]*) n=0;; esac. VERIFY the trailing stage can actually emit — if it swallows the count (| tail -n +2), this is a known false positive"
+    done < <(grep -nE '(([^|]\|[[:space:]]*([a-z]+[[:space:]]+)*wc[^|]*)|(grep([[:space:]]+-[A-Za-z]*c[A-Za-z]*|[[:space:]]+--count)[^|]*))([^|]*\|[^|]*)*\|\|[[:space:]]*echo[[:space:]]+[\"'"'"']?0' "$f" 2>/dev/null \
              | grep -vE '^[0-9]+:[[:space:]]*#' \
              | grep -vE '#[[:space:]]*noqa[:[:space:]]*degrade')
   fi

package/scripts/gate_pathspec_check.sh

@@ -107,7 +107,12 @@ spec_matches() {  # $1 = path
 for pair in \
   "plugins/fh-meta/skills/frontier-digest/SKILL_detail.md|tracks/_meta/x.md|PATHSPEC covers SKILL_detail.md" \
   "plugins/fh-meta/skills/frontier-digest/SKILL.md|README.md|PATHSPEC still covers SKILL.md" \
-  "CLAUDE.md|CLAUDE.local.md|PATHSPEC covers CLAUDE.md but not the local override"
+  "CLAUDE.md|CLAUDE.local.md|PATHSPEC covers CLAUDE.md but not the local override" \
+  "scripts/selfcheck.sh|README.md|PATHSPEC covers scripts/*.sh (seam #1 — the HEAVY term already gated it, this array did not)" \
+  "scripts/sub/nested.sh|package.json|PATHSPEC covers scripts/ recursively (git/bash globs cross '/')" \
+  "templates/regression_guard.sh|package-lock.json|PATHSPEC covers templates/*.sh — i.e. the guard can guard ITSELF" \
+  "templates/.git-hooks/pre-commit|.gitignore|PATHSPEC covers the git-hook floor (the hook that hard-blocks commits)" \
+  "plugins/fh-meta/agents/challenger.md|tracks/_meta/y.md|PATHSPEC covers agent definitions (seam #3)"
 do
   IFS='|' read -r pos neg label <<< "$pair"
   ok=1

package/scripts/selfcheck.sh

@@ -224,6 +224,38 @@ else
   fail=1
 fi
 
+# gate-pathspec anchor — wired here 2026-08-04. It was reachable ONLY from templates/.git-hooks/
+# pre-commit, i.e. only in a clone where the operator had run `git config core.hooksPath`. Every
+# other clone, every CI run, and the npm package carried the anchor file and never executed it —
+# the built-but-not-wired shape, one layer up: the anchor for the gate had no anchor of its own.
+# That mattered the same day: PR #254 added five known-pairs to it, all of which would have been
+# unexecuted outside the author's machine.
+# Subject = the two implementations it reads (the hook's HEAVY term and the guard's GUARD_PATHSPEC).
+# Absent subject → package/partial surface → legitimate SKIP; present subject with the anchor gone
+# → FAIL, same shape as every block above.
+# NAMED RESIDUAL (cross-family, gpt-5.5, 2026-08-04): if a distribution that SHOULD be complete
+# accidentally drops one subject, this reports SKIP, not FAIL — silent non-coverage. Measured the
+# same day: removing `templates/.git-hooks` from package.json `files[]` and running
+# scripts/package_coverage_check.sh still PASSED, so no existing anchor catches that omission
+# either. Deliberately NOT patched with a stricter branch: the only discriminator available
+# ("templates/ exists but the hook does not") would be built on an UNMEASURED assumption about how
+# a narrower package is shaped, and this repo's rule is not to build before the constraint is
+# measured. What is cheap and honest is naming WHICH subject is missing, so a SKIP is diagnosable
+# instead of opaque. Revisit when a real partial distribution is observed.
+_gps_missing=""
+[ -f templates/.git-hooks/pre-commit ] || _gps_missing="templates/.git-hooks/pre-commit"
+[ -f templates/regression_guard.sh ] || _gps_missing="${_gps_missing:+$_gps_missing, }templates/regression_guard.sh"
+if [ -n "$_gps_missing" ]; then
+  echo "SKIP  gate_pathspec_check.sh (subject absent: $_gps_missing) — not-checked, NOT a pass"
+elif [ -f scripts/gate_pathspec_check.sh ]; then
+  if ! bash scripts/gate_pathspec_check.sh; then
+    fail=1
+  fi
+else
+  echo "FAIL  gate_pathspec_check.sh: the gate implementations are present but their coverage anchor is missing"
+  fail=1
+fi
+
 if [ ! -f scripts/ablation_calibrate.sh ]; then
   echo "SKIP  test_ablation_calibrate_lanes.sh (subject scripts/ablation_calibrate.sh absent)"
 elif [ -f scripts/test_ablation_calibrate_lanes.sh ]; then

package/scripts/test_degrade_scan_shell_probes.sh

@@ -163,6 +163,15 @@ cat > "$TMP/s5_positive.sh" <<'EOF'
 set -uo pipefail
 N=$(find /nope . -maxdepth 1 2>/dev/null | grep -c . || echo 0)
 M=$(git log --oneline 2>/dev/null | wc -l || echo 0)
+# WIDENED 2026-08-04. Every line below was INVISIBLE to the narrowed rule, and each was verified to
+# actually produce "0\n0" before being pinned here (line count measured, not assumed):
+P=$(cat /etc/hosts | grep -c . | tr -d ' ' || echo 0)   # transparent filter after the counter
+Q=$(grep -c "^nosuchline$" /etc/hosts 2>/dev/null | tr -d ' ' || echo 0)  # the PR #251 shape
+R=$(grep -Ec "^nosuchline$" /etc/hosts || echo 0)       # combined flag cluster -Ec
+S=$(grep --count "^nosuchline$" /etc/hosts || echo 0)   # long option
+T=$(grep -Fcx "nosuchline" /etc/hosts || echo 0)        # -Fcx
+U=$(false | grep -c . | cat || echo 0)                  # trailing stage that always emits
+V=$(false | grep -c . | grep -v nosuch || echo 0)       # trailing grep whose pattern misses the "0"
 EOF
 cat > "$TMP/s5_negative.sh" <<'EOF'
 #!/usr/bin/env bash
@@ -174,8 +183,8 @@ J=$(printf '%s' "$x" | jq -r '.a // 0' 2>/dev/null || echo 0)
 # A comment describing the defect must not be scored as the defect: cmd | grep -c . || echo 0
 EOF
 n=$(s_hits "$TMP/s5_positive.sh")
-[ "$n" -eq 2 ] && ok "S5 known-positive: counter-stage fallbacks (grep -c, wc) detected 2/2" \
-                || bad "S5 known-positive: expected 2 S-hits, got $n — the pipefail disarm is invisible"
+[ "$n" -eq 9 ] && ok "S5 known-positive: 9/9 — incl. -Ec/--count/-Fcx flag clusters, trailing \`| cat\`/\`| grep -v\`, and the no-upstream-pipe form" \
+                 || bad "S5 known-positive: expected 9 S-hits, got $n — 2 = the pre-2026-08-04 rule (pipe-presence anchor); 4 = the first widening, which still missed every combined flag cluster (\`-Ec\`, \`--count\`, \`-Fcx\`) and any trailing stage outside a hardcoded name list"
 
 n=$(s_hits "$TMP/s5_negative.sh")
 [ "$n" -eq 0 ] && ok "S5 known-negative: \`||\` chains, empty-on-failure pipelines and comments stay silent" \

package/scripts/test_dispatch_log_lanes.sh

@@ -75,7 +75,14 @@ PY
     [ "$ok" -eq 0 ] ; chk $? "hook ends in exit 0 — a non-zero hook exit discards its stdout SILENTLY"
     # run it against a scratch HUB and confirm it appends today's date
     CLAUDE_PROJECT_DIR="$T/hub" bash -c "$cmd" >/dev/null 2>&1
-    [ "$(grep -c "$(date +%Y-%m-%d)" "$T/hub/tracks/_meta/.subagent_dispatch_tally" 2>/dev/null || echo 0)" -ge 1 ]
+    # Split + sanitize, not `grep -c … || echo 0`: on no-match `grep -c` PRINTS "0" and exits 1, so
+    # the fallback appends a SECOND line and `[ -ge ]` dies with "integer expression expected".
+    # Here that error happens to land on the FAIL branch — honest scope: this was never a live
+    # fail-open, it was a verdict reached by a bash error instead of a comparison, one refactor
+    # away from flipping. Found by the S5 sweep after the rule was widened (2026-08-04).
+    _tally_n=$(grep -c "$(date +%Y-%m-%d)" "$T/hub/tracks/_meta/.subagent_dispatch_tally" 2>/dev/null); _tally_n=${_tally_n:-0}
+    case "$_tally_n" in (*[!0-9]*|'') _tally_n=0 ;; esac
+    [ "$_tally_n" -ge 1 ]
     chk $? "hook actually appends a dated line when run (not merely present)"
   fi
 else

package/templates/degrade_direction_scan.sh

@@ -164,9 +164,41 @@ for f in "${FILES[@]}"; do
     # yields "9\n0" and the `-gt` guard goes silent. Verified as a known pair (both directions) in
     # scripts/test_degrade_scan_shell_probes.sh; narrowing without that anchor would just trade a
     # noisy probe for a blind one.
+    #
+    # WIDENED 2026-08-04 — the narrowing had gone one step too far, and the proof is that this
+    # probe was BLIND to the live instance that bit us the day before. PR #251 fixed
+    # `grep -c … | tr -d ' ' || echo 0` in session_close_check.sh ④-e; running this scanner over
+    # the pre-#251 file produced ZERO hits (re-measured: fixed rule = 2, old rule = 0).
+    #
+    # THE ANCHOR WAS ON THE WRONG PROPERTY. The old regex asked "is there an upstream pipe" and
+    # required the counter to be the LAST stage. Neither is the discriminator. The discriminator
+    # is: **does the failing side still EMIT?** `grep -c` prints "0" and exits 1 on no-match, so it
+    # disarms with no upstream pipe at all, and any trailing stage that passes that "0" through
+    # keeps the "0\n0" intact.
+    #
+    # A first fix widened to a NAMED filter list (tr|head|sed|…). Cross-family review (gpt-5.5,
+    # 2026-08-04) refuted it with reproduced counter-examples, and the refutation held on
+    # measurement in BOTH directions:
+    #   · still missed, all verified to yield "0\n0": `grep -Ec …`, `grep --count …`, `grep -Fcx …`
+    #     (combined/long flag forms the `-c` literal never matched) and `| cat`.
+    #   · newly over-matched: `| tail -n +2` after the counter yields ONE line — not a disarm.
+    # Name-based approximation produced under-match and over-match simultaneously. So the trailing
+    # chain is no longer enumerated: the rule keys on the COUNTER (grep with a `c` in any flag
+    # cluster or `--count`; or `wc` behind a real pipe) plus the `|| echo 0` fallback, and accepts
+    # any chain between them.
+    #
+    # PRESERVED from the 2026-07-28 narrowing, still pinned as known-negatives: (a) `a || b ||
+    # echo 0` has no pipeline, and (b) a stage that emits NOTHING on failure (`| jq -r … ||
+    # echo 0`) — there the fallback supplies the only line, as intended.
+    # KNOWN RESIDUAL, stated not hidden: a trailing stage that can swallow the counter's output
+    # (`| tail -n +2`, `| sed -n '/[1-9]/p'`) is now flagged though it is not a disarm. That is a
+    # deliberate recall-over-precision trade on an ADVISORY probe, taken because the measured cost
+    # of the other direction was a real defect shipping. Revisit if non-fixture FPs appear.
+    # Known pair: scripts/test_degrade_scan_shell_probes.sh (9 positives / negatives silent).
+    # Reverting this line turns the positive lane red — checked by applying the revert.
     while IFS= read -r m; do
-      emit "$f" "${m%%:*}" "S5:pipefail-fallback(sh)" "\`|| echo 0\` fallback on a pipeline ending in a counter (grep -c/wc) — that stage emits even when an upstream stage fails, so under \`set -o pipefail\` the value gains a SECOND line, the integer comparison errors out, and the guard passes silently; split the pipeline and sanitize to an integer"
-    done < <(grep -nE '[^|]\|[[:space:]]*([a-z]+[[:space:]]+)*(grep[^|]*-c|wc)[^|]*\|\|[[:space:]]*echo[[:space:]]+[\"'"'"']?0' "$f" 2>/dev/null \
+      emit "$f" "${m%%:*}" "S5:pipefail-fallback(sh)" "\`|| echo 0\` fallback after a COUNTER (grep with -c / --count, or wc) — the counter PRINTS \"0\" and exits non-zero on no-match, so the fallback appends a SECOND line, the value becomes \"0\\n0\", the integer test dies with 'integer expression expected' (stderr only) and the guard goes silent; split it and sanitize: n=\$(...); n=\${n:-0}; case \$n in *[!0-9]*) n=0;; esac. VERIFY the trailing stage can actually emit — if it swallows the count (| tail -n +2), this is a known false positive"
+    done < <(grep -nE '(([^|]\|[[:space:]]*([a-z]+[[:space:]]+)*wc[^|]*)|(grep([[:space:]]+-[A-Za-z]*c[A-Za-z]*|[[:space:]]+--count)[^|]*))([^|]*\|[^|]*)*\|\|[[:space:]]*echo[[:space:]]+[\"'"'"']?0' "$f" 2>/dev/null \
              | grep -vE '^[0-9]+:[[:space:]]*#' \
              | grep -vE '#[[:space:]]*noqa[:[:space:]]*degrade')
   fi

package/templates/regression_guard.sh

@@ -117,6 +117,31 @@ GUARD_PATHSPEC=(
   'AGENTS.md'
   'docs/*.md'
   'templates/*.md'
+  # ── Added 2026-08-04 — the pathspec had drifted from the 4-axis ASSET LIST it exists to gate.
+  # Measured that day by mechanically walking every asset class in CLAUDE.md §FH Improvement
+  # 4-Axis against this array: four classes had NO covering pattern, and two of them are this
+  # repo's own mechanical floor — `templates/.git-hooks/*` (the hook that hard-blocks commits)
+  # and `templates/*.sh` (THIS FILE — the guard could not guard itself). The pre-commit HEAVY
+  # classifier already listed `^scripts/.*\.sh$`, so a scripts-only change entered the heavy
+  # path and then met Axis 1 returning `SKIP (not-checked, NOT a pass)`. Observed three times
+  # on 2026-08-04 alone, the third being the S5 fix (PR #253) — a change to a verdict-surface
+  # scanner that shipped with zero Axis-1 coverage.
+  #
+  # Calibrated before shipping, both directions (a widened copy, run against real history):
+  #   · 12 consecutive historical commits touching scripts/*.sh → M=0 S=0 (no FP storm), and a
+  #     control confirmed the files were actually SELECTED (4 files checked) rather than the
+  #     zero coming from an inert pathspec — the unwired-instrument reading of a clean 0.
+  #   · known-positive: truncating a shipped .sh by 60% → M-TIER BLOCK (`BLOCK` token dropped
+  #     100%, 60% line reduction). The md-shaped checks (F1 frontmatter, F2 sections, F3 fences)
+  #     are inert on shell files; F4 keyword / F5 xref / F6 line-loss / F7 syntax are the ones
+  #     that carry, and they are exactly the regressions that matter in a gate script.
+  # NOTE on globbing: git pathspec `*` crosses `/` (verified here — `templates/*.md` matches
+  # `templates/.claude/rules/session.md`), so these single-star forms are recursive.
+  'scripts/*.sh'
+  'templates/*.sh'
+  'templates/.git-hooks/*'
+  'plugins/*/agents/*.md'
+  '.claude/agents/*.md'
 )
 
 # 계기 무결: base ref 가 안 풀리면 diff 실패가 2>/dev/null 로 삼켜져 CHANGED 공백 →