@chrono-meta/fh-gate 1.4.95 → 1.4.97

package/scripts/test_capability_entrypoint_shipping.sh

@@ -0,0 +1,132 @@
+#!/usr/bin/env bash
+# test_capability_entrypoint_shipping.sh — every typed CAPABILITY ENTRY POINT must be in the
+# npm published file set.
+#
+# WHY THIS EXISTS (measured 2026-08-12, cross-family gpt-5.5 + governor widening)
+# `scripts/degrade_probe_capability.sh` AND `scripts/psa_probe_capability.sh` were both absent from
+# `package.json` `files[]`, while their VALIDATOR (`capability_registry_check.sh`) shipped. An npm
+# consumer therefore received the thing that checks capabilities and none of the capabilities — the
+# release's headline feature (scanning ```bash/```python fences) was unreachable on the typed path
+# it advertises.
+#
+# WHY `package_coverage_check.sh` DID NOT CATCH IT — and why this is a separate check rather than a
+# rule added there: that checker walks *references* (a shipped doc names a path → the path must
+# ship). These two files are referenced by NOTHING but their own header. A reference-follower is
+# structurally blind to an ORPHAN; you cannot fix that by adding another pattern to it. The
+# discriminator here is not "is it referenced" but "is it an entry point", which is knowable from
+# the filename convention alone.
+#
+# CLASS: third occurrence of "a shipped surface points outside files[]" in this release cycle
+#   1. SKILL.md pointed at a runner that was not shipped        (caught by CI only)
+#   2. AGENTS.md pointed at validate_yaml.sh, not shipped       (caught by CI only)
+#   3. the capability entry points themselves, not shipped      (caught by cross-family only)
+# The standing rule is N>=3 → mechanize at the front instead of relying on the next reviewer.
+#
+# Usage:  bash scripts/test_capability_entrypoint_shipping.sh
+# Exit:   0 = every entry point ships; 1 = at least one is missing (or the check could not run).
+set -uo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$REPO_ROOT" || { echo "FAIL: cannot cd to repo root"; exit 1; }
+
+pass=0; fail=0
+ok()  { printf '  \342\234\205 %s\n' "$1"; pass=$((pass+1)); }
+bad() { printf '  \342\235\214 %s\n' "$1"; fail=$((fail+1)); }
+
+echo "capability entry-point shipping check"
+
+command -v node >/dev/null 2>&1 || {
+  echo "  INSTRUMENT ERROR: node unavailable — files[] cannot be read. NOT a pass."; exit 1; }
+
+# Discover entry points by convention. A DISCOVERY of zero is an instrument failure, not a clean
+# result: this check exists precisely because the surface it guards is invisible to reference
+# walking, so "found nothing to check" must never render as "everything ships".
+ENTRIES=$(find scripts -maxdepth 1 -type f -name '*_capability.sh' 2>/dev/null | sort)
+n=$(printf '%s\n' "$ENTRIES" | grep -c . || true)
+n=$(( ${n:-0} + 0 ))
+if [ "$n" -eq 0 ]; then
+  echo "  INSTRUMENT ERROR: zero *_capability.sh files discovered — the scan did not reach its target."
+  echo "  (A real zero is possible only if this repo has no typed capabilities; verify by hand before believing it.)"
+  exit 1
+fi
+
+FILES_JSON=$(node -e 'process.stdout.write(JSON.stringify(require("./package.json").files||[]))' 2>/dev/null) || {
+  echo "  INSTRUMENT ERROR: could not read package.json files[]"; exit 1; }
+
+printf '%s\n' "$ENTRIES" | while IFS= read -r e; do
+  [ -n "$e" ] || continue
+  if node -e 'const f=JSON.parse(process.argv[1]);process.exit(f.includes(process.argv[2])?0:1)' "$FILES_JSON" "$e"; then
+    echo "  ok $e"
+  else
+    echo "  MISSING $e"
+  fi
+done > "${TMPDIR:-/tmp}/cap_entry_$$.txt"
+
+missing=$(grep -c '^  MISSING ' "${TMPDIR:-/tmp}/cap_entry_$$.txt" || true)
+missing=$(( ${missing:-0} + 0 ))
+shipped=$(grep -c '^  ok ' "${TMPDIR:-/tmp}/cap_entry_$$.txt" || true)
+shipped=$(( ${shipped:-0} + 0 ))
+cat "${TMPDIR:-/tmp}/cap_entry_$$.txt"
+rm -f "${TMPDIR:-/tmp}/cap_entry_$$.txt"
+
+if [ "$missing" -eq 0 ]; then
+  ok "all $shipped capability entry point(s) are in package.json files[]"
+else
+  bad "$missing capability entry point(s) absent from files[] — npm consumers get the validator without the capability"
+fi
+
+# REVERSE DIRECTION (added 2026-08-12 after a cross-family round broke the first version).
+# The check above walks disk → files[]. That direction alone is blind to the failure that actually
+# loses a capability: MOVE OR DELETE the entry-point file. Discovery then simply does not see it,
+# every remaining entry is still listed, and the lane goes green while `npm pack` ships one fewer
+# capability. So also walk files[] → disk: anything declared as a capability entry point must exist.
+# (A capability removed from BOTH sides is an intentional deletion and correctly flags nothing.)
+DECLARED=$(node -e '
+  const f=JSON.parse(process.argv[1]);
+  process.stdout.write(f.filter(p=>/^scripts\/.*_capability\.sh$/.test(p)).join("\n"));
+' "$FILES_JSON")
+dangling=0
+if [ -n "$DECLARED" ]; then
+  while IFS= read -r d; do
+    [ -n "$d" ] || continue
+    # `-f` alone is not enough, and both gaps were demonstrated (round 5): a SYMLINK satisfies `-f`
+    # but `npm pack` does not follow it — the tarball simply omits the file — and a ZERO-BYTE file
+    # satisfies every existence test while shipping an empty capability. Existence is the weakest
+    # of the three properties; assert all of them.
+    if [ ! -e "$d" ]; then
+      echo "  DANGLING $d (declared in files[], absent on disk)"; dangling=$((dangling+1))
+    elif [ -L "$d" ]; then
+      echo "  SYMLINK $d (npm pack does not follow symlinks — the tarball would omit it)"; dangling=$((dangling+1))
+    elif [ ! -f "$d" ]; then
+      # A DIRECTORY passes -e, is not a symlink, and `-s` reports non-zero size for it — so the
+      # three tests above all agreed a directory was a fine entry point (round 6). Regular-file-ness
+      # is the property actually being claimed; assert it rather than three proxies for it.
+      echo "  NOT-A-FILE $d (declared as an entry point but is not a regular file)"; dangling=$((dangling+1))
+    elif [ ! -s "$d" ]; then
+      echo "  EMPTY $d (zero bytes — ships an entry point that cannot run)"; dangling=$((dangling+1))
+    fi
+  done <<EOF
+$DECLARED
+EOF
+fi
+declared_n=$(printf '%s\n' "$DECLARED" | grep -c . || true); declared_n=$(( ${declared_n:-0} + 0 ))
+if [ "$declared_n" -eq 0 ]; then
+  bad "files[] declares ZERO capability entry points — either the convention changed or the list was gutted; a disk-only check cannot notice that"
+elif [ "$dangling" -eq 0 ]; then
+  ok "all $declared_n declared capability entry point(s) exist on disk (move/delete would be caught)"
+else
+  bad "$dangling declared capability entry point(s) missing from disk — npm would ship a broken files[] and the disk-side check alone stays green"
+fi
+
+# CONTROL — the check must be able to say NO. A checker that only ever prints ok is indistinguishable
+# from a checker that is not looking; assert the negative arm on a name that cannot be in files[].
+if node -e 'const f=JSON.parse(process.argv[1]);process.exit(f.includes(process.argv[2])?0:1)' \
+     "$FILES_JSON" "scripts/definitely_not_shipped_$$.sh"; then
+  bad "CONTROL DEAD — a nonexistent path reported as shipped; the membership test is not testing"
+else
+  ok "control alive — a nonexistent path is correctly reported as not shipped"
+fi
+
+echo "----"
+echo "capability entry-point shipping: $pass passed, $fail failed (entries=$n, missing=$missing)"
+[ "$fail" -eq 0 ] || exit 1

package/scripts/test_consent_registry.sh

@@ -728,6 +728,60 @@ YAML
 lane "P-SPELL a grant WIDER than its class is still refused (the paired control)" 1 "R7"
 
 
+# ── PROV : every verdict states what it measured WITH, and it states the TRUTH ──────────────────
+# 2026-08-12. This gate rides selfcheck → prepublishOnly. A release shipped green from a session whose
+# `python3` resolved to an unrelated project's venv that had PyYAML, while the machine's own python3
+# did not. Nothing was bypassed — the PASS was simply not portable, and said nothing about what
+# produced it.
+#
+# 🟥 The first version of this lane compared two arms, one of them "PyYAML hidden" via
+# `env -i PATH=/usr/bin:/bin PYTHONNOUSERSITE=1`. It passed locally and FAILED IN CI — because
+# `PYTHONNOUSERSITE` suppresses only the USER site directory. On this author's machine PyYAML was a
+# `--user` install so it hid; on the CI runner it is a system `dist-packages` install so it did not,
+# both arms returned the same value, and the lane called its own subject decorative.
+# **The control worked only by accident of how the author happened to install a package** — which is
+# the exact defect class the subject under test exists to catch, reproduced inside its own lane.
+#
+# So the lane no longer manufactures an environment. It compares the reported value against an
+# INDEPENDENT ORACLE computed in the same run: whatever `find_spec` says here, the instrument line
+# must say the same thing. That catches removal, hard-coding, truncation, and drift — everywhere,
+# with no assumption about how PyYAML got installed.
+_prov_line=$(bash "$CHK" 2>&1 | grep -o 'instrument (consent-registry): .*' | head -1)
+_prov_oracle=$(python3 - <<'ORACLE' 2>/dev/null
+import importlib.util, sys
+s = importlib.util.find_spec("yaml")
+print((s.origin or "namespace-package") if s is not None else "ABSENT")
+ORACLE
+)
+if [ -z "$_prov_line" ]; then
+  echo "  ❌ PROV-1 no instrument line on the ordinary path"; fail=$((fail+1))
+elif [ -z "$_prov_oracle" ]; then
+  echo "  ❌ PROV-1 oracle produced nothing — NOT RUN (unmeasured, not a pass)"; fail=$((fail+1))
+elif ! printf '%s' "$_prov_line" | grep -q ': /'; then
+  echo "  ❌ PROV-1 line does not name an absolute interpreter path: [$_prov_line]"; fail=$((fail+1))
+elif ! printf '%s' "$_prov_line" | grep -qF "PyYAML $_prov_oracle"; then
+  echo "  ❌ PROV-1 line disagrees with the oracle — reported [$_prov_line] vs actual [$_prov_oracle]"; fail=$((fail+1))
+else
+  echo "  ✅ PROV-1 instrument line matches an independent resolution of PyYAML [$_prov_oracle]"; pass=$((pass+1))
+fi
+
+# PROV-2 — the ABSENT branch, exercised DETERMINISTICALLY rather than by hiding a package.
+# A `yaml.py` MODULE FILE placed first on PYTHONPATH wins by path order, so find_spec resolves to it
+# — a different, predictable answer that does not depend on how the real PyYAML was installed.
+# ⚠️ A `yaml/` DIRECTORY does NOT work and the first draft used one: a namespace package has LOWER
+# precedence than a regular package, so Python keeps scanning the whole path and still finds the real
+# one. Measured — the arm did not move, and the lane correctly called itself decorative.
+_prov_tmp=$(mktemp -d); printf '# shadow module for the PROV-2 arm\n' > "$_prov_tmp/yaml.py"
+_prov_shadow=$(PYTHONPATH="$_prov_tmp" bash "$CHK" 2>&1 | grep -o 'instrument (consent-registry): .*' | head -1)
+rm -rf "$_prov_tmp"
+if [ -z "$_prov_shadow" ]; then
+  echo "  ❌ PROV-2 no instrument line under a shadowed yaml"; fail=$((fail+1))
+elif [ "$_prov_shadow" = "$_prov_line" ]; then
+  echo "  ❌ PROV-2 line did not move when the resolution moved — decorative [$_prov_line]"; fail=$((fail+1))
+else
+  echo "  ✅ PROV-2 line tracks the resolution when it changes (shadowed → different value)"; pass=$((pass+1))
+fi
+
 echo "----"
 echo "consent-registry anchor: $pass passed, $fail failed"
 [ "$fail" -eq 0 ] || exit 1

package/scripts/test_count_check_readme_format_lanes.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+# test_count_check_readme_format_lanes.sh — known-pair anchor for the README format override guard
+# in `scripts/count_check.sh`.
+#
+# WHY THIS EXISTS
+# `count_check.sh` is a **mandatory-pass** gate wired into selfcheck → prepublishOnly, pre-commit
+# and CI. Its README check renders a caller-supplied printf template and uses the RESULT as a
+# `grep -qE` pattern. Two ways that goes wrong, both measured 2026-08-12:
+#   · a template rendering a NEWLINE turns the pattern into an OR search — a stale README (99/99)
+#     PASSED because the trailing fragment "8" matched "Node 18" elsewhere in the file;
+#   · `printf` failure and value-swallowing directives (`%.0s`) produced partial patterns, unchecked.
+# The guard that closes this shipped with **zero** anchors in the same commit that added four
+# anchors for a sibling fix — the exact "you can delete the feature and stay green" class that
+# commit was closing. This file is that missing half.
+#
+# SCOPE, stated honestly: these lanes exercise the guard's DECISION LOGIC in isolation (render →
+# inspect → accept/reject), not the whole count_check run. The full script needs a git worktree
+# with a populated plugin tree; a fixture that lacks one fails for an unrelated reason ("0 active
+# fh-meta skills") and every arm goes red for the SAME wrong cause — which is how a first attempt
+# at this test nearly certified a guard that had not been exercised at all.
+set -uo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+SUBJECT="$REPO_ROOT/scripts/count_check.sh"
+pass=0; fail=0
+ok()  { printf '  \342\234\205 %s\n' "$1"; pass=$((pass+1)); }
+bad() { printf '  \342\235\214 %s\n' "$1"; fail=$((fail+1)); }
+
+# The guard block is extracted from the subject rather than restated here: a copy drifts from the
+# thing it claims to verify, which is the divergent-normalizer defect this repo has hit before.
+GUARD=$(awk '/^  README_STR=\$\(printf/,/^  \[ -n "\$README_STR" \] && count_check/' "$SUBJECT")
+if [ -z "$GUARD" ]; then
+  bad "guard block not found in count_check.sh — the anchor cannot verify what it cannot locate"
+  echo "----"; echo "count_check README-format lanes: $pass passed, $fail failed"; exit 1
+fi
+
+probe() {   # $1 = template ; echoes rc + a reason token
+  local fmt="$1"
+  bash -c '
+    set -uo pipefail
+    total_sk=40; total_ag=8; fail=0
+    README_FMT="$1"
+    count_check() { echo "ACCEPTED:$3"; }
+    '"$GUARD"'
+    exit $fail
+  ' _ "$fmt" 2>&1
+  return $?
+}
+
+run() {   # $1 = label ; $2 = template ; $3 = expect (accept|reject)
+  local out rc; out=$(probe "$2"); rc=$?
+  case "$3" in
+    accept) if [ "$rc" -eq 0 ] && printf '%s' "$out" | grep -q 'ACCEPTED:'; then
+              ok "$1 — accepted (no over-block)"
+            else bad "$1 — legitimate template was REJECTED (rc=$rc): $out"; fi ;;
+    reject) if [ "$rc" -ne 0 ]; then ok "$1 — rejected (rc=$rc)"
+            else bad "$1 — a broken template PASSED the gate: $out"; fi ;;
+  esac
+}
+
+echo "== count_check README format override — known pair =="
+# Accept arms. Two of them on purpose: the default and a localized one. The whole point of the
+# override is downstream harnesses writing their own wording, so an English-only accept arm would
+# not notice a guard that rejects every non-ASCII template.
+run "A1 default English"      '%s skills · %s agents'   accept
+run "A2 localized (Korean)"   '스킬 %s개 · 에이전트 %s개'  accept
+run "A3 markdown decoration"  '**%s** skills / **%s** agents' accept
+# Reject arms — each must fail for its OWN reason, not a shared incidental one.
+run "R1 renders a newline"    '%s
+%s'                                                     reject
+run "R2 swallows a value"     '%.0s%s agents'           reject
+
+echo "----"
+echo "count_check README-format lanes: $pass passed, $fail failed"
+[ "$fail" -eq 0 ] || exit 1