@chrono-meta/fh-gate 1.4.86 → 1.4.88

package/scripts/session_close_check.sh

@@ -39,6 +39,7 @@ if command -v gh >/dev/null 2>&1; then
   # `[{"number":227},{"number":226},{"number":225}]` → old 1, new 3; `[]` → 0 both ways — which is
   # why an environment with zero open PRs can never surface this, and why the 0-case alone is not a
   # calibration. Observed live the same day: 2 open PRs reported as 1.
+  # Anchored by scripts/test_session_close_chain_lanes.sh lane ①-b-P3.
   PRS=$(gh pr list --author "@me" --state open --json number 2>/dev/null | grep -o '"number"' | wc -l | tr -d ' ' || true)
   [ "${PRS:-0}" -gt 0 ] && echo "⚠️  ①-b $PRS open PR(s) by you — classify: self-mergeable vs awaiting-external"
 fi
@@ -72,11 +73,16 @@ if [ "${FH_CHANGED:-0}" -gt 0 ]; then
   fi
 fi
 
-# ④ real-time completion log — required whenever any commit landed today
+# ④-log real-time completion log — required whenever any commit landed today.
+# NAMING: this block does NOT implement CLAUDE.md's ④ (memory hygiene). It implements the
+# "Real-time completion tracking" paragraph that sits above the chain. Labelling it ④ meant a green
+# "④" told a reader memory hygiene had been verified when nothing had checked it — false coverage,
+# the same class as a summary line that prints PASS while the exit code refuses. The label now says
+# what it checks. (Numbering mismatch found 2026-08-02 by the lane-writing pass.)
 COMMITS_TODAY=$(git -C "$FH" log --since="today 00:00" --oneline 2>/dev/null | wc -l | tr -d ' ')
 FC="$FH/tracks/_meta/fh_completed_${TODAY}.md"
 if [ "$COMMITS_TODAY" -gt 0 ] && [ ! -f "$FC" ]; then
-  echo "❌ ④ commits landed today but tracks/_meta/fh_completed_${TODAY}.md is missing"
+  echo "❌ ④-log commits landed today but tracks/_meta/fh_completed_${TODAY}.md is missing"
   FAIL=1
 fi
 
@@ -150,12 +156,20 @@ if [ "$HOOK_OK" -eq 0 ]; then
   echo "     (that file is gitignored, so a fresh clone has none). An unmeasured dispatch count is"
   echo "     NOT a count of zero. Install: templates/subagent-tally-hook.json → .claude/settings.json"
 fi
-DISPATCHED=$(grep -c "^$TODAY$" "$TALLY" 2>/dev/null | tr -d ' ' || echo 0)
+# `grep -c` PRINTS 0 and EXITS 1 when the count is zero. Under `set -o pipefail` (line 16) that
+# makes the pipeline fail, `|| echo 0` appends a SECOND line, and the value becomes "0\n0" — which
+# `[ -eq ]` rejects as a bash error, so the branch it guards is skipped. The guard was therefore
+# disarmed in EXACTLY the case it exists for (zero log entries). Measured 2026-08-04 during a close:
+# the check printed ✅ while `[: 0\n0: integer expression expected` went to stderr.
+# Fix = no `|| echo`, plus integer sanitation. This is the documented prescription for this class
+# ([[feedback_pipefail_fallback_disarms_guard]]) applied to the checker that cited it.
+_int() { case "${1:-}" in (''|*[!0-9]*) echo 0 ;; (*) echo "$1" ;; esac; }
+DISPATCHED=$(_int "$(grep -c "^$TODAY$" "$TALLY" 2>/dev/null | tr -d ' ' || true)")
 # Both quotings, because the file carries both: hand-written entries use `- date: 2026-08-02`
 # while anything appended via yaml.dump renders `- date: '"'"'2026-08-02'"'"'`. Matching one form counted
 # half the entries as absent — a divergent-normalizer miss inside the check that exists to catch
 # missing records. Known-pair calibrated below in test_dispatch_log_lanes.sh.
-LOGGED=$(grep -cE "^- date: *'?$TODAY'?" "$LOG" 2>/dev/null | tr -d ' ' || echo 0)
+LOGGED=$(_int "$(grep -cE "^- date: *'?$TODAY'?" "$LOG" 2>/dev/null | tr -d ' ' || true)")
 if [ "${DISPATCHED:-0}" -gt 0 ] && [ "${LOGGED:-0}" -eq 0 ]; then
   echo "❌ ④-e $DISPATCHED sub-agent dispatch(es) today and ZERO invocation-log entries — the 60/40"
   echo "     promotion gate and the UAP loop both read that file; an unlogged session is invisible to"

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
@@ -93,6 +100,39 @@ hookless_verdict() { # $1=hook_configured -> MEASURED | NOT-MEASURED
 grep -q "NOT MEASURED" "$CHECK" ; chk $? "the subject actually carries that branch (not just this lane)"
 [ -f "$SCRIPT_DIR/../templates/subagent-tally-hook.json" ] ; chk $? "installable snippet exists for a clone that has no settings.json"
 
+echo "── pipefail disarm (the guard was dead in EXACTLY its target case) ──"
+# `grep -c` PRINTS 0 and EXITS 1 on a zero count. Under `set -o pipefail` the old
+# `grep -c … | tr -d ' ' || echo 0` therefore produced "0\n0", `[ -eq ]` threw, and the ❌ branch
+# was skipped — so ④-e reported ✅ whenever the log had ZERO entries, which is the one situation it
+# exists to block. Measured live 2026-08-04 during a session close.
+# Lane 1: reproduce the OLD form and assert it is broken (a control — if this ever passes, the
+# premise changed and the fix below is measuring nothing).
+old_form=$(bash -c 'set -uo pipefail; grep -c "^NOSUCHDATE$" '"$CHECK"' 2>/dev/null | tr -d " " || echo 0')
+[ "$(printf %s "$old_form" | grep -c "")" -eq 2 ] ; chk $? "control: the old \`|| echo 0\` form really does yield TWO lines under pipefail"
+# Lane 2: the shipped form yields a single sanitised integer.
+new_form=$(bash -c 'set -uo pipefail; _int() { case "${1:-}" in (""|*[!0-9]*) echo 0 ;; (*) echo "$1" ;; esac; }; _int "$(grep -c "^NOSUCHDATE$" '"$CHECK"' 2>/dev/null | tr -d " " || true)"')
+[ "$new_form" = "0" ] ; chk $? "shipped form yields a single sanitised 0"
+( set -uo pipefail; [ "$new_form" -eq 0 ] ) 2>/dev/null ; chk $? "and \`[ -eq ]\` accepts it (the old form threw here)"
+# Lane 3-5: BEHAVIOUR, not spelling. The first draft of these lanes string-matched the old form and
+# went GREEN on a revert — the needle did not match `tr -d ' '` (quotes), so the anchor was
+# decorative in the way this repo already named ([[feedback_anchor_can_be_decorative]], cause:
+# "needle matching unrelated text"). Extract the subject's OWN assignment lines and evaluate them.
+_eval_subject_assign() {  # $1 = variable name; echoes what the SUBJECT computes for a zero match
+  local var="$1" line
+  line=$(grep -E "^${var}=" "$CHECK" | head -1)
+  [ -n "$line" ] || { echo "NOLINE"; return; }
+  bash -c "set -uo pipefail
+    _int() { case \"\${1:-}\" in (''|*[!0-9]*) echo 0 ;; (*) echo \"\$1\" ;; esac; }
+    TODAY=NOSUCHDATE; TALLY='$CHECK'; LOG='$CHECK'
+    $line
+    printf %s \"\$$var\"" 2>/dev/null
+}
+for _v in DISPATCHED LOGGED; do
+  _got=$(_eval_subject_assign "$_v")
+  [ "$(printf %s "$_got" | grep -c '')" -le 1 ] ; chk $? "subject's \$$_v is ONE line on a zero match (was two: the disarm)"
+  ( set -uo pipefail; [ "${_got:-x}" -eq 0 ] ) 2>/dev/null ; chk $? "subject's \$$_v survives \`[ -eq 0 ]\` (the disarm threw here)"
+done
+
 echo ""
 if [ "$FAILED" -ne 0 ]; then echo "DISPATCH-LOG LANES: FAIL"; exit 1; fi
 echo "DISPATCH-LOG LANES: PASS ($PASS/$PASS)"

package/scripts/test_node_infra_delta_lanes.sh

@@ -0,0 +1,211 @@
+#!/usr/bin/env bash
+# test_node_infra_delta_lanes.sh — lanes for the INFRA-DELTA branch of scripts/fh_node_check.sh.
+#
+# WHY A SEPARATE FILE FROM test_node_check_lanes.sh: that suite covers the floor probes (git hooks,
+# Mode D companion detection, emission model) and never enters the infra-delta branch — every one of
+# its fixtures runs against a state file whose PREV_HEAD is either empty (first session) or equal to
+# HEAD. The branch that reacts to `git pull` moving install-relevant files was unexercised, which is
+# how the four items below survived. Keeping it separate also keeps the two suites' fixture families
+# from colliding: this one must CHANGE HEAD between runs, which breaks the "event once then silent"
+# lane in the other file.
+#
+# CALIBRATION RULE OBSERVED THROUGHOUT: every lane asserting an ABSENCE names its known-positive in
+# the lane title and builds it from the SAME fixture family in the SAME run. Exit codes are read
+# DIRECTLY off the subject, never through a pipe.
+#
+# ⓘ GAP lanes pin behaviour believed WRONG without failing the suite; if the behaviour changes they
+# announce "GAP CLOSED" so the lane gets promoted instead of silently rotting.
+#
+# Exit 0 = every asserting lane calibrated · 1 = the instrument is wrong.
+
+set -uo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CHECK="$SCRIPT_DIR/fh_node_check.sh"
+[ -f "$CHECK" ] || { echo "FAIL  subject missing: $CHECK"; exit 1; }
+
+TMPROOT=$(mktemp -d "${TMPDIR:-/tmp}/fh_infra_lanes.XXXXXX")
+trap 'rm -rf "$TMPROOT"' EXIT
+FAILED=0; PASSED=0; GAPS=0
+
+_pass() { echo "✅ $1"; PASSED=$((PASSED+1)); }
+_fail() { echo "❌ $1"; FAILED=1; }
+_line() {  # $1=name $2=pattern $3=expect(0/1) $4=output
+  local hit=0
+  printf '%s\n' "$4" | grep -q -- "$2" && hit=1
+  if [ "$hit" = "$3" ]; then _pass "$1 (hit=$hit, expected=$3)"
+  else _fail "$1 — hit=$hit, expected=$3"; printf '%s\n' "$4" | sed 's/^/       │ /'; fi
+}
+_rc() { if [ "$2" = "$3" ]; then _pass "$1 (exit=$2, expected=$3)"; else _fail "$1 — exit=$2, expected=$3"; fi; }
+_gap() {  # $1=name $2=observed(1=still open) $3=note
+  if [ "$2" = "1" ]; then echo "ⓘ GAP (still open) $1"; echo "       ↳ $3"; GAPS=$((GAPS+1))
+  else echo "🎉 GAP CLOSED — $1 : behaviour changed, promote this lane to an asserting one"; fi
+}
+
+# ── fixtures ────────────────────────────────────────────────────────────────────
+# A hub with FH's own gate sentinel in both hooks, so MISS is empty and any output is attributable
+# to the infra-delta branch alone (instrument-discrimination: a lane that cannot tell which leg
+# fired is not measuring that leg).
+_hub() {  # $1=name → echoes path
+  local d="$TMPROOT/$1"
+  mkdir -p "$d/.git" || true
+  git -C "$d" init -q 2>/dev/null || { mkdir -p "$d"; git -C "$d" init -q; }
+  git -C "$d" config user.email anchor@local; git -C "$d" config user.name anchor
+  mkdir -p "$d/.git/hooks"
+  printf '#!/bin/sh\n# FH 4-Axis Gate\nexit 0\n' > "$d/.git/hooks/pre-commit"
+  cp "$d/.git/hooks/pre-commit" "$d/.git/hooks/pre-push"
+  chmod +x "$d/.git/hooks/pre-commit" "$d/.git/hooks/pre-push"
+  echo seed > "$d/seed.txt"
+  git -C "$d" add -A >/dev/null 2>&1
+  git -C "$d" -c commit.gpgsign=false commit -qm seed >/dev/null 2>&1
+  printf '%s' "$d"
+}
+_commit() {  # $1=hub $2..=paths to create
+  local d="$1" p; shift
+  for p in "$@"; do mkdir -p "$d/$(dirname "$p")"; echo changed >> "$d/$p"; done
+  git -C "$d" add -A >/dev/null 2>&1
+  git -C "$d" -c commit.gpgsign=false commit -qm change >/dev/null 2>&1
+}
+_run() {  # $1=hub $2=statefile ; sets OUT/RC (RC read directly, no pipe)
+  OUT=$(HUB_DIR="$1" FH_NODE_STATE="$2" FH_MACHINE_ID=lanebox bash "$CHECK" 2>&1); RC=$?
+}
+# seed the state so PREV_HEAD is the pre-change commit (this is the ONLY way into the branch)
+_seed_state() { _run "$1" "$2" >/dev/null 2>&1; }
+
+NEW='🆕 Install-relevant assets changed'
+HDR='🖥️  \[node\]'
+
+echo "══ infra delta: fires on an install-relevant change, silent otherwise ══"
+H=$(_hub p_pos); _seed_state "$H" "$TMPROOT/st_pos"
+_commit "$H" scripts/fh_env_delta_scan.sh
+_run "$H" "$TMPROOT/st_pos"
+_line "ID-P  install-relevant file changed → 🆕 block fires" "$NEW" 1 "$OUT"
+_line "ID-P  → names the changed path"  'scripts/fh_env_delta_scan.sh' 1 "$OUT"
+_line "ID-P  → routes to the wizard"    'Re-run /install-wizard'       1 "$OUT"
+_rc   "ID-P  detector never gates (exit 0)" "$RC" 0
+
+# CONTROL for ID-P, same fixture family, same run-shape: HEAD advances by exactly one commit, but
+# the changed path is outside the install surface. Silence here is only meaningful BECAUSE ID-P
+# above spoke on an otherwise identical fixture.
+H=$(_hub p_ctl); _seed_state "$H" "$TMPROOT/st_ctl"
+_commit "$H" README.md
+_run "$H" "$TMPROOT/st_ctl"
+_line "ID-C  non-install path changed → no 🆕 block (over-fire ctl for ID-P)" "$NEW" 0 "$OUT"
+_rc   "ID-C  → exit 0" "$RC" 0
+
+echo
+echo "══ one fixture PER regex alternative (an untested alternative is an untested branch) ══"
+# Deliberately one path per alternative: a single fixture touching several at once would let any
+# alternative be deleted with the suite staying green — the lane4c lesson from test_node_check_lanes.
+i=0
+for p in "templates/.git-hooks/pre-push" \
+         "templates/settings.SessionStart.snippet.json" \
+         "scripts/fh_session_load.sh" \
+         "plugins/fh-meta/skills/install-wizard/SKILL.md" \
+         "plugins/fh-meta/skills/install-doctor/SKILL.md"; do
+  i=$((i+1))
+  H=$(_hub "alt$i"); _seed_state "$H" "$TMPROOT/st_alt$i"
+  _commit "$H" "$p"
+  _run "$H" "$TMPROOT/st_alt$i"
+  _line "ID-R$i alternative covered: $p" "$NEW" 1 "$OUT"
+done
+
+# NEGATIVE for the regex: install-adjacent-LOOKING paths that the pattern deliberately does not
+# cover. Without this leg "the regex matches everything" would also pass ID-R1..5.
+H=$(_hub alt_neg); _seed_state "$H" "$TMPROOT/st_altneg"
+_commit "$H" "plugins/fh-meta/skills/harvest-loop/SKILL.md"
+_run "$H" "$TMPROOT/st_altneg"
+_line "ID-Rn non-install skill path → not treated as infra (paired with ID-R4/5)" "$NEW" 0 "$OUT"
+
+echo
+echo "══ unreachable PREV_HEAD: UNMEASURED, not silence ══"
+H=$(_hub p_unreach); _commit "$H" scripts/fh_env_delta_scan.sh
+printf 'lanebox|1700000000|deadbee' > "$TMPROOT/st_unreach"
+_run "$H" "$TMPROOT/st_unreach"
+_line "ID-U  gc/rebase/shallow → UNMEASURED is stated" 'UNMEASURED'  1 "$OUT"
+_line "ID-U  → does NOT claim the 🆕 delta (not found ≠ 0)" "$NEW"   0 "$OUT"
+_rc   "ID-U  → exit 0" "$RC" 0
+
+echo
+echo "══ co-reporting: a missing floor does not suppress the infra delta ══"
+H=$(_hub p_both); _seed_state "$H" "$TMPROOT/st_both"
+rm -f "$H/.git/hooks/pre-commit"
+_commit "$H" scripts/fh_node_check.sh
+_run "$H" "$TMPROOT/st_both"
+_line "ID-B  missing floor reported"            'Missing mechanical floor' 1 "$OUT"
+_line "ID-B  AND infra delta reported (paired)" "$NEW"                     1 "$OUT"
+
+echo
+echo "══ ⓘ GAP lanes — believed-wrong behaviour, pinned not asserted ══"
+
+# GAP 1 — attribution. Every other emission path prints the 🖥️ [node] header; the infra-only and
+# UNMEASURED-only paths print 4-space-indented CONTINUATION lines under a header that was never
+# printed. This is not cosmetic in situ: SessionStart hooks on one matcher have their outputs
+# delivered as separate, unordered, unlabelled blocks (measured in
+# scripts/test_sessionstart_multihook_lanes.sh), so an unattributed indented block genuinely cannot
+# be traced to the hook that emitted it.
+H=$(_hub g_hdr); _seed_state "$H" "$TMPROOT/st_hdr"
+_commit "$H" scripts/fh_env_delta_scan.sh
+_run "$H" "$TMPROOT/st_hdr"
+_g=0
+{ printf '%s\n' "$OUT" | grep -q "$NEW"; } && ! printf '%s\n' "$OUT" | grep -q "$HDR" && _g=1
+_gap "infra-only emission has NO 🖥️ [node] header" "$_g" \
+  "Output is 4-space-indented continuation lines with no parent line. MISS and IDENTITY both print a \
+header; the infra and UNMEASURED paths do not, because they hang off an if/elif that both fail."
+
+# GAP 2 — silent truncation. `head -6` with no count. The script's own header argues 'not found ≠ 0'
+# and 'distinguish no-change from could-not-measure'; an omitted-3-of-9 list is the same class of
+# hidden omission, one layer in.
+H=$(_hub g_trunc); _seed_state "$H" "$TMPROOT/st_trunc"
+_commit "$H" scripts/fh_a.sh scripts/fh_b.sh scripts/fh_c.sh scripts/fh_d.sh \
+             scripts/fh_e.sh scripts/fh_f.sh scripts/fh_g.sh scripts/fh_h.sh scripts/fh_i.sh
+_run "$H" "$TMPROOT/st_trunc"
+LISTED=$(printf '%s\n' "$OUT" | grep -c '^       - ')
+_g=0; { [ "$LISTED" = "6" ] && ! printf '%s\n' "$OUT" | grep -qiE 'more|[0-9]+ of [0-9]+|truncat'; } && _g=1
+_gap "9 install-relevant files changed → 6 listed, 3 dropped with no count" "$_g" \
+  "listed=$LISTED, and no '…and N more'. A big pull (exactly when re-running the wizard matters most) \
+silently hides the tail. Cheap fix: append the residual count."
+
+# GAP 3 — the one-shot consumes an UNRESOLVED unknown. State is written UNCONDITIONALLY to HEAD_NOW,
+# including on the run that could not compute the delta. Next session PREV_HEAD == HEAD, so the
+# delta across that pull is never attempted again and never mentioned again. The script's header
+# says events report once and CONDITIONS report until they stop being true — an un-computed delta is
+# an unresolved condition, and it is being treated as a discharged event.
+H=$(_hub g_once); _commit "$H" scripts/fh_env_delta_scan.sh
+printf 'lanebox|1700000000|deadbee' > "$TMPROOT/st_once"
+SPOKE=0
+for _i in 1 2 3; do
+  _run "$H" "$TMPROOT/st_once"
+  printf '%s\n' "$OUT" | grep -q 'UNMEASURED' && SPOKE=$((SPOKE+1))
+done
+_g=0; [ "$SPOKE" = "1" ] && _g=1
+_gap "UNMEASURED spoken once, then permanently forgotten (state advanced anyway)" "$_g" \
+  "spoke on $SPOKE of 3 consecutive runs. Same shape as the failure the state-based design was \
+introduced to fix ('a broken machine reported once then went quiet forever') — the fix reached MISS \
+but not the infra branch. CODE-vs-DOC: fh_node_check.sh's own header claims it distinguishes \
+'no change' from 'could not measure', yet after run 1 the two are indistinguishable forever."
+
+# GAP 4 — the event is consumed even when nobody saw it. State advances before/independently of
+# whether the emission reached anyone. Pairs directly with the F11 measurement: a SessionStart hook
+# whose sibling ordering, delivery, or exit handling drops its output loses the notice permanently.
+H=$(_hub g_unseen); _seed_state "$H" "$TMPROOT/st_unseen"
+_commit "$H" scripts/fh_env_delta_scan.sh
+HUB_DIR="$H" FH_NODE_STATE="$TMPROOT/st_unseen" FH_MACHINE_ID=lanebox bash "$CHECK" >/dev/null 2>&1
+_run "$H" "$TMPROOT/st_unseen"
+_g=0; printf '%s\n' "$OUT" | grep -q "$NEW" || _g=1
+_gap "infra event is consumed by a run whose output nobody received" "$_g" \
+  "One discarded-stdout run and the notice is gone for good. The write is deliberately unconditional \
+(so the timestamp does not mean 'last time it spoke'), but that argument covers the TIMESTAMP, not \
+the HEAD field. Recording HEAD only when the delta was successfully computed AND emitted would keep \
+the timestamp honest and stop discharging unseen events."
+
+echo
+echo "──────────────────────────────────────────────"
+if [ "$FAILED" -ne 0 ]; then
+  echo "NODE INFRA-DELTA LANES: FAIL — instrument miscalibrated (do not trust its verdict)"
+  echo "  asserting lanes passed: $PASSED · open gaps: $GAPS"
+  exit 1
+fi
+echo "NODE INFRA-DELTA LANES: PASS ($PASSED asserting lanes) · $GAPS KNOWN GAP(S) open (see ⓘ above)"
+echo "  Green covers: fires/does-not-fire, per-alternative regex coverage, UNMEASURED, co-reporting."
+echo "  Green does NOT cover the four gaps above."
+exit 0