@chrono-meta/fh-gate 1.4.97 → 1.4.99

package/scripts/test_stale_clone_guard_lanes.sh

@@ -58,7 +58,7 @@ git clone -q "$WORK/origin.git" "$WORK/C" 2>/dev/null
 run "non-origin remote name still fires"  HIT   "$WORK/C/newfile.py"
 
 # Throttle: SAME marker dir, two calls — second must be silent.
-mdir=$(mktemp -d "$WORK/marker.throttle")
+mdir=$(mktemp -d "$WORK/marker.throttle.XXXXXX")
 o1=$(payload "$WORK/B/x.py" | FH_STALE_CLONE_NO_FETCH=1 FH_STALE_CLONE_MARKER_DIR="$mdir" bash "$G" 2>&1)
 o2=$(payload "$WORK/B/y.py" | FH_STALE_CLONE_NO_FETCH=1 FH_STALE_CLONE_MARKER_DIR="$mdir" bash "$G" 2>&1)
 if printf '%s' "$o1" | grep -q STALE-CLONE && [ -z "$o2" ]; then
@@ -68,7 +68,7 @@ else
 fi
 
 # Contract: HIT emits one JSON object with both channels and no permissionDecision.
-mdir=$(mktemp -d "$WORK/marker.json")
+mdir=$(mktemp -d "$WORK/marker.json.XXXXXX")
 jo=$(payload "$WORK/B/z.py" | FH_STALE_CLONE_NO_FETCH=1 FH_STALE_CLONE_MARKER_DIR="$mdir" bash "$G" 2>/dev/null)
 if printf '%s' "$jo" | python3 -c '
 import json,sys
@@ -114,25 +114,39 @@ run "slashed remote name still fires"     HIT   "$WORK/D/newfile.py"
 # budget, exit 0, arm the day-throttle — instead of letting the RUNNER's 20s timeout kill it
 # (which skipped the marker write and re-stalled every Write of the day). PATH shim makes `git
 # fetch` hang; budget is set to 0.5s; the real git serves every other subcommand.
+#
+# DEBT fix (2026-08-14): `elapsed -lt 10` was a bare wall-clock assertion on a mandatory path — a
+# loaded CI runner's fork/exec + scheduling overhead can push actual elapsed time past a fixed
+# small constant even when the guard's OWN 0.5s internal budget fired correctly (named and
+# predicted by an adversarial review of the original delta; CI then reproduced it, 2/17 lanes red
+# where local was 17/17). What this lane actually needs to prove is RELATIVE, not absolute: the
+# guard returned because its budget bounded it, not because the wedge itself woke up (30s) or an
+# external timeout killed the process. So: widen the wedge to 60s (cheap — the guard should never
+# come close to waiting it out) and assert elapsed is well under HALF of that, not a small fixed
+# number. This keeps strong discriminating power (a guard that stopped bounding itself would still
+# blow well past 30s) while absorbing CI-runner overhead that has nothing to do with the guard's
+# own logic.
+WEDGE_SLEEP=60
 SHIM="$WORK/shim"; mkdir -p "$SHIM"
 REALGIT=$(command -v git)
 cat > "$SHIM/git" <<EOF
 #!/bin/bash
-for a in "\$@"; do [ "\$a" = "fetch" ] && sleep 30; done
+for a in "\$@"; do [ "\$a" = "fetch" ] && sleep $WEDGE_SLEEP; done
 exec "$REALGIT" "\$@"
 EOF
 chmod +x "$SHIM/git"
-mdir=$(mktemp -d "$WORK/marker.wedge")
+mdir=$(mktemp -d "$WORK/marker.wedge.XXXXXX")
 t0=$(date +%s)
 w_out=$(payload "$WORK/B/wedge.py" | PATH="$SHIM:$PATH" FH_STALE_CLONE_FETCH_BUDGET_TENTHS=5 \
         FH_STALE_CLONE_MARKER_DIR="$mdir" bash "$G" 2>&1); w_rc=$?
 t1=$(date +%s)
 elapsed=$((t1 - t0))
+elapsed_cap=$((WEDGE_SLEEP / 2))
 marker_count=$(ls "$mdir" 2>/dev/null | wc -l | tr -d ' ')
-if [ "$w_rc" -eq 0 ] && [ -z "$w_out" ] && [ "$elapsed" -lt 10 ] && [ "$marker_count" -ge 1 ]; then
-  printf '  ✅ %-52s OK (%ss)\n' "wedged fetch: bounded, silent, throttle armed" "$elapsed"; pass=$((pass+1))
+if [ "$w_rc" -eq 0 ] && [ -z "$w_out" ] && [ "$elapsed" -lt "$elapsed_cap" ] && [ "$marker_count" -ge 1 ]; then
+  printf '  ✅ %-52s OK (%ss < %ss)\n' "wedged fetch: bounded, silent, throttle armed" "$elapsed" "$elapsed_cap"; pass=$((pass+1))
 else
-  printf '  ❌ %-52s rc=%s elapsed=%ss markers=%s out=%s\n' "wedged fetch: bounded, silent, throttle armed" "$w_rc" "$elapsed" "$marker_count" "$w_out"; fail=$((fail+1))
+  printf '  ❌ %-52s rc=%s elapsed=%ss(cap %ss) markers=%s out=%s\n' "wedged fetch: bounded, silent, throttle armed" "$w_rc" "$elapsed" "$elapsed_cap" "$marker_count" "$w_out"; fail=$((fail+1))
 fi
 
 # Budget cap (terra round 2): an all-digit literal wider than the shell's integer width made the

package/scripts/test_version_lockstep_lanes.sh

@@ -74,6 +74,68 @@ T=$(_fixture he4 1.4.89 1.4.89 1.4.89 1.4.89 1.4.89); printf '{"name":"fh-meta"}
 _expect "HE-4 manifest with no version → exit 2, NOT 0" 2 "$T"
 _says   "HE-4 → says which file carries none" "carries no version string" 1
 
+# ── Self-restatement — found→extend into this lens (2026-08-14) ──────────────────────────────
+# RS-KN pins the exact false positive the naive first draft threw against its OWN calibration
+# target (scripts/lane_runner_check.sh): a loose \D{0,12} gap matched across an unrelated
+# exit-code legend entry ("declared DEBT · 1 =") and across a before→after transition narration
+# ("DEBT 2 → 0"). Both shapes are known-negatives — they describe history/enumeration, not a
+# live contradiction — and must stay silent.
+
+T=$(_fixture rs1 1.4.89 1.4.89 1.4.89 1.4.89 1.4.89)
+mkdir -p "$T/scripts"
+cat > "$T/scripts/some_lane.sh" <<'EOF'
+#!/usr/bin/env bash
+# Exit: 0 = every suite is WIRED, EXEMPT, or declared DEBT · 1 = an undeclared suite has no runner
+# THE TWO THAT WERE HERE ARE RE-WIRED (2026-08-14) — DEBT 2 → 0.
+# WHAT `DEBT: 0` DOES NOT MEAN — read before quoting the number anywhere.
+DEBT=()
+EOF
+_expect "RS-KN historical DEBT narration (2→0, exit-code legend) → exit 0" 0 "$T"
+_says   "RS-KN → does not fire on the transition/legend shapes" "self-restatement drift" 0
+
+T=$(_fixture rs2 1.4.89 1.4.89 1.4.89 1.4.89 1.4.89)
+mkdir -p "$T/scripts"
+cat > "$T/scripts/broken_lane.sh" <<'EOF'
+#!/usr/bin/env bash
+# DEBT: 12 unwired suites remain, tracked below.
+# ... (later, uncorrected after a partial fix) ...
+# still DEBT 9 by last count.
+DEBT=()
+EOF
+_expect "RS-KP shell comment restates DEBT with two different numbers → exit 0 (advisory)" 0 "$T"
+_says   "RS-KP → names the file and the disagreeing values" \
+        'broken_lane.sh :: comments state DEBT as \[9, 12\]' 1
+
+T=$(_fixture rs3 1.4.89 1.4.89 1.4.89 1.4.89 1.4.89)
+mkdir -p "$T/plugins/fh-commons/skills/fake-skill"
+cat > "$T/plugins/fh-commons/skills/fake-skill/SKILL.md" <<'EOF'
+---
+name: fake-skill
+description: uses v1.4.95 of the reference build
+---
+# fake-skill
+
+Body text never restates a version number, so there is nothing to cross-check against.
+EOF
+_expect "RS-KN2 SKILL.md frontmatter version, body silent → exit 0, no drift" 0 "$T"
+_says   "RS-KN2 → does not fire when body has zero version mentions" "self-restatement drift" 0
+
+T=$(_fixture rs4 1.4.89 1.4.89 1.4.89 1.4.89 1.4.89)
+mkdir -p "$T/plugins/fh-commons/skills/fake-skill2"
+cat > "$T/plugins/fh-commons/skills/fake-skill2/SKILL.md" <<'EOF'
+---
+name: fake-skill2
+description: ships as part of v1.4.95
+---
+# fake-skill2
+
+Elsewhere in this doc we note the shipped build is v1.4.92, which is the value users should
+actually expect to see when they check their installed version.
+EOF
+_expect "RS-KP2 SKILL.md frontmatter v1.4.95 vs body v1.4.92 → exit 0 (advisory)" 0 "$T"
+_says   "RS-KP2 → names the file and the drifted version" \
+        'fake-skill2/SKILL.md :: frontmatter states v{1.4.95}' 1
+
 echo
 echo "──────────────────────────────────────────────"
 if [ "$FAIL" -gt 0 ]; then

package/scripts/version_lockstep_check.sh

@@ -22,7 +22,7 @@ ROOT="${1:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}"
 command -v python3 >/dev/null 2>&1 || { echo "LOCKSTEP: HARNESS-ERROR — python3 unavailable"; exit 2; }
 
 python3 - "$ROOT" <<'PY'
-import json, sys, glob, os
+import json, sys, glob, os, re
 root = sys.argv[1]
 pkg_path = os.path.join(root, 'package.json')
 try:
@@ -69,6 +69,39 @@ for p in targets:
         if got != want:
             drift.append(f"  {rel} :: {label} = {got}  (package.json = {want})")
 
+# ── CHANGELOG is a shipped version surface too, and it was outside this check ─────────────────
+# Measured 2026-08-13, by a peer session, AFTER 1.4.97 was already published: the four JSON
+# manifests all read 1.4.97 and plugins/fh-meta/CHANGELOG.md's newest entry was still [1.4.96].
+# So the tarball a consumer downloads carries a changelog with no entry for the version they just
+# installed — six merged PRs invisible on the record surface. This check reported PASS while that
+# was true, because its target list was "manifests carrying a JSON version field" rather than
+# "surfaces that state which version this is".
+# ★ That is the half-fix propagation boundary in its purest form: the version was updated
+# everywhere the CHECK looked, which is not the same set as everywhere it MATTERS.
+# Non-blocking is deliberate and narrow: a missing entry is a documentation gap, not a broken
+# package, and turning a publish red on prose would train the override this repo has already
+# measured people reaching for. It is LOUD, it names the file, and it is impossible to miss in the
+# publish output — which is what the JSON drift arms could not have been, since those genuinely
+# break installs.
+CHANGELOGS = sorted(glob.glob(os.path.join(root, 'plugins', '*', 'CHANGELOG.md')))
+for p in CHANGELOGS:
+    rel = os.path.relpath(p, root)
+    try:
+        txt = open(p, encoding='utf-8', errors='replace').read()
+    except OSError as e:
+        print(f"LOCKSTEP: HARNESS-ERROR — cannot read {rel}: {e}")
+        sys.exit(2)
+    # The heading form this repo uses: `### [x.y.z] — DATE`. Absence of ANY such heading means the
+    # extractor stopped matching the file's real shape — report that rather than a clean run.
+    heads = re.findall(r'^#+\s*\[(\d+\.\d+\.\d+)\]', txt, re.M)
+    if not heads:
+        print(f"LOCKSTEP: HARNESS-ERROR — {rel} has no `[x.y.z]` heading; the extractor is blind, "
+              f"which is not the same as the changelog being current")
+        sys.exit(2)
+    if want not in heads:
+        print(f"LOCKSTEP: ⚠️  {rel} has no entry for {want} (newest is {heads[0]}) — the published "
+              f"tarball would carry a changelog that does not mention the version it ships")
+
 if drift:
     print(f"LOCKSTEP: DRIFT — {len(drift)} of {checked} shipped version string(s) do not match package.json")
     print("\n".join(drift))
@@ -76,5 +109,114 @@ if drift:
     print("so a stale entry ships as 'already installed' on the runtime that cannot report it.")
     sys.exit(1)
 
+# ── Self-restatement — a file that states its own count/version twice can drift from itself ──
+# Measured 2026-08-13 (peer session, reship axis): N=2 on two DIFFERENT surfaces, both real —
+#   (a) a memory file's YAML frontmatter `description:` stated an npm version differently from
+#       its own body (1.4.95 vs 1.4.92 — a lockstep drift, just in prose instead of JSON)
+#   (b) lane_runner_check.sh's own header comment stated "11/8" while a later comment said the
+#       DEBT count was 12 — caught by cross-family review, not by re-reading (see that file's own
+#       header for the incident write-up; it has since self-corrected into a historical note).
+# «타표면 재발 = 기계화 의무» (recurrence on a second, different surface obligates mechanizing) —
+# found→extend into THIS lens rather than a new scanner: same idiom (extract candidate values,
+# compare, collect drift, report), new target surfaces.
+#
+# 🟥 (a) IS NOT CLOSED BY THIS ARM, AND THAT IS DELIBERATE — cross-family review (2026-08-14)
+# caught an earlier draft of this comment reading as though citing incident (a) meant this scan
+# reaches it. It does not: the memory store lives under the operator's home directory
+# (~/.claude/projects/.../memory/), outside this repo's `root` entirely, so the candidate glob
+# below structurally cannot see it — this script runs at `npm publish` time (package.json
+# prepublishOnly), where only the git-tracked repo exists (CI has no access to a contributor's
+# local home directory, and different operators have different paths). Incident (a) is the
+# MOTIVATING PRECEDENT for the general pattern, not a case this specific scope closes. Closing it
+# for real needs a separate, local-only check over the memory store — a different surface with
+# different constraints, not a widening of this one.
+#
+# Advisory (like the CHANGELOG check above), same reasoning: a stale self-count is a documentation
+# defect, not a broken package, and turning publish red on prose trains the override this repo has
+# already measured people reaching for.
+#
+# Scope, deliberately narrow — the two false-positive traps that would have made this noise instead
+# of signal, both avoided on purpose:
+#   1. tracks/**/*.md and this repo's session cards are EXCLUDED. Those are running logs that
+#      legitimately cite dozens of historical version numbers across dated sessions — scanning them
+#      for "two differing v-numbers in one file" would fire on nearly every one. The mission here is
+#      "does a single-snapshot doc contradict itself", not "every version ever mentioned".
+#   2. The DEBT counter only fires on 2+ DISTINCT values for the SAME literal label ("DEBT") within
+#      comment lines of one file — not on any two numbers that happen to appear near each other. A
+#      one-off historical narration ("this said 11/8 until it was fixed") does not by itself carry
+#      two live DEBT-labeled claims, so it does not false-positive as an active contradiction.
+def _self_restate_md():
+    hits = []
+    candidates = [os.path.join(root, 'CLAUDE.md'), os.path.join(root, 'AGENTS.md')]
+    candidates += sorted(glob.glob(os.path.join(root, 'plugins', '*', 'skills', '*', 'SKILL.md')))
+    # v-prefix optional — cross-family review found the real incident that motivated this arm
+    # (a memory file's frontmatter `latest v1.4.97` vs body `latest **1.4.97**`) does not carry the
+    # prefix on the body side, so the mandatory-v form never fires on the actual shape it exists
+    # to catch. Bare N.N.N is noisier (could match an unrelated dependency version), but the
+    # candidate list above is narrow enough (CLAUDE.md/AGENTS.md/SKILL.md only) that this stays
+    # advisory-tolerable rather than explosive.
+    VERPAT = re.compile(r'\bv?(\d+\.\d+\.\d+)\b')
+    for p in candidates:
+        if not os.path.exists(p):
+            continue
+        try:
+            txt = open(p, encoding='utf-8', errors='replace').read()
+        except OSError:
+            continue
+        m = re.match(r'^---\n(.*?)\n---\n(.*)$', txt, re.S)
+        if not m:
+            continue
+        fm, body = m.group(1), m.group(2)
+        fm_vers = set(VERPAT.findall(fm))
+        body_vers = set(VERPAT.findall(body))
+        drifted = fm_vers - body_vers
+        if fm_vers and body_vers and drifted:
+            rel = os.path.relpath(p, root)
+            hits.append(f"  {rel} :: frontmatter states v{{{','.join(sorted(drifted))}}} not "
+                        f"found anywhere in body (body has v{{{','.join(sorted(body_vers))}}})")
+    return hits
+
+def _self_restate_sh():
+    hits = []
+    # Tight: DEBT immediately followed by (optional :/=, whitespace) a number — not "any digit
+    # within 12 chars" (that matched an unrelated exit-code legend entry across a bullet, «DEBT ·
+    # 1»). A number immediately followed by an arrow (→ / ->) is a before→after transition
+    # narration ("DEBT 2 → 0"), not a live claim about the current count — excluded on purpose,
+    # calibrated against this repo's own lane_runner_check.sh (known-negative: 3 raw matches with
+    # the loose form, 1 real match with this form — verified by hand, 2026-08-14).
+    DEBTPAT = re.compile(r'\bDEBT\b\s*[:=]?\s*(\d+)\b(?!\s*(?:→|->))')
+    # test_*.sh / *_lanes.sh are excluded — measured 2026-08-14 on this check's own test file:
+    # a known-pair fixture legitimately embeds two differing DEBT numbers as heredoc TEST DATA
+    # (proving the detector can tell them apart), and that heredoc text is also literal source in
+    # the test file itself. Those are fixtures, not a claim about the test file's own state — same
+    # distinction the `suites` glob elsewhere in this repo already draws between subject scripts
+    # and the test scripts that exercise them.
+    for p in (sorted(f for f in glob.glob(os.path.join(root, 'scripts', '*.sh'))
+                      if not re.match(r'^(test_.*|.*_lanes)\.sh$', os.path.basename(f)))
+              + sorted(f for f in glob.glob(os.path.join(root, 'templates', '*.sh'))
+                        if not re.match(r'^(test_.*|.*_lanes)\.sh$', os.path.basename(f)))):
+        try:
+            txt = open(p, encoding='utf-8', errors='replace').read()
+        except OSError:
+            continue
+        # Comment lines only — a live `DEBT=()` array literal is code computing the fact, not a
+        # restated claim about it, and must not be treated as a second (possibly stale) copy.
+        vals = set()
+        for ln in txt.splitlines():
+            if not re.match(r'^\s*#', ln):
+                continue
+            vals |= {int(m) for m in DEBTPAT.findall(ln)}
+        if len(vals) > 1:
+            rel = os.path.relpath(p, root)
+            hits.append(f"  {rel} :: comments state DEBT as {sorted(vals)} — pick one number, "
+                        f"or point the stale comment at the live count instead of a literal")
+    return hits
+
+restate_hits = _self_restate_md() + _self_restate_sh()
+if restate_hits:
+    print(f"LOCKSTEP: ⚠️  self-restatement drift — {len(restate_hits)} file(s) state their own "
+          f"version/count more than once and the copies disagree:")
+    print("\n".join(restate_hits))
+
 print(f"LOCKSTEP: PASS — {checked} shipped version string(s) all at {want}")
 PY

package/templates/.git-hooks/pre-commit

@@ -1072,7 +1072,28 @@ if [ -n "$LOADBEARING" ]; then
   echo "[Gate] load-bearing change — degrade lint (advisory) + cross-family acknowledgment..."
   DDSCAN="$REPO_ROOT/scripts/degrade_direction_scan.sh"
   if [ -f "$DDSCAN" ]; then
-    _dd=$(bash "$DDSCAN" 2>/dev/null \
+    # SCOPE THE SCAN TO THE STAGED FILES. This used to call `bash "$DDSCAN"` with NO ARGUMENTS,
+    # which makes the scanner walk the WHOLE REPOSITORY recursively — and then the very next pipe
+    # threw almost all of it away, keeping only the lines naming files we already had in hand.
+    # Measured on this repo 2026-08-13: whole-repo 42s / 260 lines · one staged file 0s / 2 lines.
+    # A sibling harness measured the same call under load at 2m07s inside a commit that took
+    # 7m54s–9m40s, one of which hit a 10-minute tool ceiling and could not complete at all.
+    # ★ The structure was inverted: it held the target list, scanned everything, then filtered.
+    # WHY THIS IS WORSE THAN A SLOW CHECK: this lane declares itself ADVISORY (see the doctrine line
+    # above — FP-tolerant, never a solo block). So a lane that cannot block was consuming most of
+    # every load-bearing commit. That trains `--no-verify`, and the SAME hook carries the
+    # Destructive-Op gate — one learned bypass disarms an irreversible-surface gate too. CLAUDE.md
+    # warns repeatedly that over-blocking trains the override; over-DELAYING gets there just as well.
+    # Read into an array rather than relying on word-splitting: $LOADBEARING is newline-separated and
+    # an unquoted expansion would also split on spaces. `while read` and not `mapfile`, because
+    # mapfile does not exist on bash 3.2 (stock macOS), which this hook still has to run on.
+    _dd_targets=()
+    while IFS= read -r _p; do
+      [ -n "$_p" ] && _dd_targets+=("$_p")
+    done <<< "$LOADBEARING"
+    # The grep filter is KEPT even though the scan is now scoped: the scanner emits summary lines
+    # ("degrade-scan: N smell(s) …") that name no file, and those must not read as findings.
+    _dd=$(bash "$DDSCAN" "${_dd_targets[@]}" 2>/dev/null \
           | grep -Ff <(printf '%s\n' "$LOADBEARING") 2>/dev/null | head -5 || true)
     if [ -n "$_dd" ]; then
       echo "  ⚠️  degrade-direction smell(s) in the staged load-bearing files (advisory):"

package/templates/consent_classes.yaml.example

@@ -44,6 +44,36 @@
 #   Re-point the class's `owner` or `mode` after the grant and the join fails: that is the point.
 
 classes:
+  # ---- REAL, ADOPTABLE class (not illustrative) -------------------------------------
+  # Ships with fh_node_check.sh's consent-gated auto-pull. Copy this block verbatim into your
+  # own tracks/_meta/consent_classes.yaml, then grant it in your UAP frontmatter to enable the
+  # apply arm. Without both, the check surfaces "N commits behind" and never touches the repo —
+  # absent is not granted.
+  #
+  # Read the reason before adopting: this class takes a DIFFERENT verdict from the `local-commit`
+  # example further down, on a deliberately narrow ground. If your integration branch is not
+  # PR-only/protected, that ground does not hold for you and you should not adopt it.
+  - name: repo-freshness-autopull
+    owner: scripts/fh_node_check.sh
+    mode: ff-only-merge-on-default-branch
+    target: this repo's own default branch, in the local clone, when it is already checked out
+    capabilities: [network, repo-mutation]
+    sinks: []
+    feeds: []
+    promotion_eligible: true
+    lease_days: 92
+    reason: >
+      A fast-forward pull introduces nothing new: every commit it brings down is already on the
+      integration branch, which is PR-only and server-side protected, so all of it has passed the
+      gates. `local-commit` below is classified feeds:[go-public] because it CREATES ungated
+      content that publish can then ship; this makes the tree MATCH canon instead. Publish packs
+      the working tree, so a tree matching origin is strictly safer to publish from than a stale
+      one. Blast radius also excludes personal state by construction — a pull touches tracked
+      files only, and session/memory/companion state is gitignored or outside the repo.
+      Envelope (enforced in code, not prose): applies ONLY when the default branch is already
+      checked out, never switches branches, and --ff-only refuses a divergence rather than
+      absorbing it. Lanes: scripts/test_node_check_lanes.sh lane10-a..e + CONTROL.
+
   # ---- promotion-eligible example -------------------------------------------------
   - name: dispatch-readonly-sim-local-artifact
     owner: fh-meta:sim-conductor          # the gate/skill that does the asking

package/templates/degrade_direction_scan.sh

@@ -500,11 +500,20 @@ for f in "${FILES[@]}"; do
   #   `tok in text` (paid⊂prepaid) when the variables aren't named verdict/state (M#4, steel-quench).
   #   C2 closes that: simple var-in-var (not a collection literal / range / for) = a likely
   #   containment check that should be exact/word-boundary if it grounds a verdict. Higher noise; advisory.
+  # 2026-08-14: pinned an ALL-CAPS-constant exclusion here that Probe C already carries a few lines
+  # up (`in [A-Z_]+\b`) — C2 had drifted out of sync with it. Measured on this repo's own scripts/:
+  # 6 raw C2 hits, all `if VAR in {seen,by_name,accepted,packed,PLACEHOLDERS}:` — genuine collection
+  # membership, not the substring-containment smell this probe exists to catch. Do NOT also add
+  # lowercase collection-name heuristics (`seen`/`by_name`/...) here — that class still needs a
+  # human to read the assignment and confirm it is a set/dict/list, and a naming guess would just
+  # move the false-negative risk instead of removing it. This narrows one already-established class,
+  # it does not invent a new one.
   while IFS= read -r m; do
     emit "$f" "${m%%:*}" "C2:substring-boolean" "bare 'X in Y' in if/return/assert — if this grounds a presence/verdict check, use exact/word-boundary match, not containment"
   done < <(grep -nE '^[[:space:]]*(if|elif|return|assert|while)[[:space:]]+[A-Za-z_][A-Za-z0-9_]*[[:space:]]+in[[:space:]]+[A-Za-z_][A-Za-z0-9_.]*[[:space:]]*[:)]?[[:space:]]*$' "$f" 2>/dev/null \
            | grep -vE '\bfor\b|in range|in enumerate|not in' \
-           | grep -vE '\b(verdict|present|ground|state|match|expected)\w*\b')
+           | grep -vE '\b(verdict|present|ground|state|match|expected)\w*\b' \
+           | grep -vE 'in [A-Z_]+[[:space:]]*[:)]?[[:space:]]*$')
 
   # Probe E — negated-falsy guard returning permissive (dominance-benchmark round-2 f2 class): an error
   # SENTINEL (None / {} / "" / []) is falsy, so `if not X: return <PASS>` treats "the check errored / never