@chrono-meta/fh-gate 1.4.98 → 1.4.99

package/docs/OUTPUT_EVIDENCE.md

@@ -8,10 +8,10 @@
 
 | What | Count | Notes |
 |---|---:|---|
-| Active skills | **33** | 29 in `fh-meta` + 4 in `fh-commons`; 3 deprecated redirect stubs not counted |
+| Active skills | **40** | 35 in `fh-meta` + 5 in `fh-commons`; **0** deprecated redirect stubs currently exist, so that exclusion is a no-op today |
 | Agent definitions | **8** | `challenger`, `quench-challenger`, `fact-checker`, `hub-persona-auditor`, `persona-innovator`, `beginner`, `main-player`, `expert` |
-| Operating rules | **6** | `.claude/rules/*.md` — mapping, modes, sync, sister-asset, operations |
-| Knowledge docs | **23** | `knowledge/` — 6-axis framework, compounding loop, runtime flow, dialogue playbook |
+| Operating rules | **1** | `.claude/rules/*.md` — `fh_4axis_gate.md`. The drop from 6 is **not** deletion: the others were relocated to `knowledge/shared/rules/` so they stop loading on every session, and this path now holds only the path-scoped gate |
+| Knowledge docs | **57** | `knowledge/` — 6-axis framework, compounding loop, runtime flow, dialogue playbook, and the harness-core canon |
 | Plugins | **2** | `fh-meta` (meta-harness) + `fh-commons` (project-agnostic) |
 | Self-gate | **1** | 4-axis pre-commit hook (backward / adversarial / forward / record) |
 
@@ -19,12 +19,17 @@
 
 | Metric | Value |
 |---|---|
-| First commit → latest | **2026-05-26 → 2026-06-06** (12 days) |
-| Commits | **224** |
-| Merged PRs | **66** |
+| First commit → latest | **2026-05-26 → 2026-08-15** (81 days) |
+| Commits | **768** |
+| Merged PRs | **372** |
 
-> Read honestly: this is *velocity*, not *maturity*. A 12-day-old project is early. The point is that the
-> compounding loop and self-gate were exercised on the harness's own development, not just described.
+> ⚠️ **Counted 2026-08-15; a pace table is stale the day after it is written.** The previous version of
+> this block sat at "12 days / 224 commits / 66 PRs" for two months and read as current, because nothing
+> in it said when it was measured. Re-run the commands below rather than trusting the numbers above —
+> and if you update them, update this date in the same edit.
+
+> Read honestly: this is *velocity*, not *maturity*. The point is that the compounding loop and self-gate
+> were exercised on the harness's own development, not just described.
 
 ## External artifacts (verifiable links)
 
@@ -106,10 +111,14 @@ rather than only synthetic ones.
 <sub>Reproduce the counts:</sub>
 
 ```bash
-# active skills (excludes deprecated redirect stubs)
-for d in plugins/*/skills/*/; do grep -qi "DEPRECATED — merged\|redirect stub\|moved to" "$d/SKILL.md" || echo "$d"; done | wc -l
-# agents
-ls .claude/agents/*.md plugins/*/agents/*.md | wc -l
+# active skills. NOTE: the old recipe here grepped each SKILL.md for "redirect stub"/"deprecated"
+# and returned 38, because phantom-quench and hub-cc-pr-reviewer — both live — merely MENTION those
+# words in their prose. A body-text grep cannot tell "I am a stub" from "I detect stubs". There are
+# currently zero stubs, so count the files and re-introduce an exclusion only when one exists, in
+# frontmatter where it can be matched on a field rather than on a phrase.
+find plugins -name SKILL.md | wc -l
+# agents  (there is no .claude/agents/ in this repo — that path is for field projects)
+find plugins -path '*/agents/*.md' | wc -l
 # knowledge docs
 find knowledge -name '*.md' | wc -l
 # pace

package/knowledge/shared/learnings/subagent_invocations_log.yaml

@@ -1997,3 +1997,13 @@
     ★**The phantom-quench audit flagged a claim PHANTOM by reading a stale illustrative comment as live ground truth** — the checker's own header names an old example subject (directional_diff_gate.sh) instead of the real live-computed one (relay_channel.sh). Re-derived ground truth by RUNNING the checker's own Python detection logic directly rather than trusting either the audit's reading or the comment: confirmed the diff's own claim was TRUE, but the investigation surfaced a genuinely separate, real bug — lane_runner_check.sh's self-test detector scans a subject's OWN file among its 'runners' search and misreads directional_diff_gate.sh's usage-example comment as a real caller (self-referential false positive), so that subject silently reads as wired when nothing actually calls it. Recorded, not fixed this session (different file/job) — tracks/_meta/fh_signal_2026-08-15_selfcheck-wiring.md.
     ⚠️ **A same-session self-correction on the codex dispatch itself**: an operator-preferred lighter codex tier (gpt-5.6-luna) was believed to have silently fallen back to a bare 'gpt-5' based on a self-report identity probe ('what model are you'). The operator flagged this as surprising given the CLI's own model picker showed it as a valid current tier. A live control (pinning a clearly-different, smaller model and repeating the same probe) got the identical 'gpt-5' self-report, while the tool's own `model:` banner line was correct every time — proving the self-report probe itself is not a discriminating identity signal for this CLI, not that the pin failed. The R2 dispatch had already redirected to gpt-5.5-xhigh before this was caught, so the cross-family result stands (a clean pass on a stronger model is not weakened by this), but the diagnosis that motivated the redirect was wrong and is corrected in the Axis-2 marker.
     🟥 **Tally discrepancy, named not forced**: the mechanical SubagentStop tally counted 16 dispatches machine-wide for 2026-08-15; this entry accounts for 3 substantive + 3 diagnostic = 6. The remaining ~10 are unattributed — a live peer session shared this exact checkout for most of the day (confirmed via ListAgents/SendMessage during this session's own branch-claim conflict) and very likely contributed some of them, but the tally has no per-spawn attribution (same structural gap this log already named on 2026-08-13), so the split is not reconstructable after the fact. Recorded as unknown rather than estimated to fit."
+
+- date: 2026-08-15
+  session: fh-parallel-59b59c27 (Opus 5 1M, bg, A축 lane_runner 자기참조 오탐 + directional_diff_gate 배선 → README 3층 정본 반영)
+  agents_summary: "4 dispatches: codex gpt-5.5×1 (cross-family adversarial on the working-tree diff, live tool execution) · fh-meta:challenger×1 (Axis 2 adversarial, isolated, static-trace only — Bash not in its tool set) · general-purpose×1 (Axis 3 phantom-quench grounding audit over the same diff) · Explore×1 (README.md staleness sweep vs measured repo reality)."
+  dispatch_count: 4
+  outcome: accepted
+  evidence: "codex R1 → 2A+1B, all source-grounded and closed: `calibration passed (0 pairs)` certifies a suite whose lanes were all deleted (reproduced by neutralizing all 23 `t` lanes → rc=0 + PASS); a usage banner satisfied the substring match; no timeout while both neighbouring blocks had one. fh-meta:challenger R2 → 4A+6B, the decisive one falsifying this delta's own evidence: L14/L15 both put the self-reference on a `#` line, so comment-stripping alone satisfied them and the self-exclusion guard could be reverted with 16/16 still green — verified by executing the revert, not by reading. Closed with lane L16 (non-comment self-reference); guard present → 17/17, removed → exactly L16 red. Grounding audit → 31 claims, 0 phantoms, CONDITIONAL_PASS, 3 B closed (chief among them a factually wrong `$_LANE_TO` attribution that would have told the next editor a `set -u` dependency was safe to delete). Explore sweep → README roster enumerates 37 of 40 skills and 4 of 8 agents, model-tier list pinned to an older generation and naming a tier the source artifact deliberately anonymizes, and docs/OUTPUT_EVIDENCE.md drifted hard (skills 33 vs 40, rules 6 vs 1, knowledge 23 vs 57, '12-day-old project' vs 81 days, commits 224 vs 767)."
+  notes: "★**Self-caught 0 of 7 A-grade.** Two different reviewer engines produced DISJOINT A-grade sets — codex found the verdict-predicate family, the challenger found the unanchored-guard family — which is the concrete argument for two legs over one leg twice, on the same diff, same day.
+    ★**The challenger had no Bash** and said so plainly rather than implying execution ('아래는 전부 정적 추적이고, 실행 확인은 0건'). Its decisive finding was still correct, and the governor executed the revert to confirm it — sidecar finding as evidence candidate, verdict closed by a mechanical anchor.
+    🟥 **Self-inflicted, self-caught**: the Explore sweep was dispatched and README.md was then edited while it ran — `[[feedback_audit_target_must_be_frozen]]` reproduced. The agent itself flagged the file changing under it (494 → 572 lines). Its verdicts on the edited region were discarded; only the counts/links/translation-drift findings were used, and the translation port was deferred until the English file is committed and frozen."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrono-meta/fh-gate",
-  "version": "1.4.98",
+  "version": "1.4.99",
   "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.98",
+  "version": "1.4.99",
   "engines": {
     "claudeCode": ">=1.0.0"
   },

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

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

package/plugins/fh-meta/CHANGELOG.md

@@ -10,6 +10,107 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 
 ## Plugin Level
 
+### [1.4.99] — 2026-08-15
+
+**fix: 검출기가 «호출부 0» 을 «10/10 초록» 으로 보고하고 있었다 — 그리고 이 릴리스는 #388 의 첫 출하이기도 하다**
+
+- 🔴 **`lane_runner_check.sh` 가 거짓 초록을 생산했다.** 이 도구의 존재 이유가 «호출자 없는 레인
+  찾기» 인데, `has_selftest_runner()` 가 subject **자기 파일**을 `runners` 에 포함하고
+  `selftest_dispatched()` 가 주석줄을 안 걸렀다. 그래서 `directional_diff_gate.sh` 가 **자기 usage
+  주석**(`#   bash scripts/directional_diff_gate.sh --self-test`)을 호출부로 오독당해, 실제 호출부가
+  **0개**인데 리포트는 `self-test: 10/10 wired` 를 찍었다. 같은 파일의 `has_runner()` /
+  `runner_dispatches()` 는 그 두 가드를 **이미** 갖고 있었다 — 몰라서가 아니라 **한 술어에만
+  적용**돼 있었다. 검출기 수리와 그 부채의 실제 배선을 **한 커밋에** 실었다(따로 실으면 한쪽은
+  «새로 보이는데 여전히 안 도는 부채», 다른 쪽은 «거짓으로 평평한 카운트» 가 된다).
+  🟥 **참값은 6일 전부터 기록돼 있었다** — 2026-08-09 핸드오프가 컨트롤까지 붙여 «호출자 0» 을 재고
+  *"오신뢰를 하나 더한 상태"* 라고 진단해 뒀는데, 그 6일 동안 검출기는 10/10 을 보고했고 이 건이
+  닫힌 경로는 그 문서가 아니라 **검출기 자신의 오탐을 쫓던 세션**이다.
+- **`selfcheck.sh` 의 판정은 종료코드만으로 하지 않는다.** 새 `directional_diff_gate --self-test`
+  블록은 **종결 판정줄을 통째로**(`^✅ calibration passed (N pairs)$`) 요구하고 **N > 0** 을 강제한다.
+  cross-family 라운드가 준 구체 입력: 그 subject 는 *실패* 수가 0이면 **레인 수와 무관하게** 통과줄을
+  찍으므로, 레인을 전부 지우면 `calibration passed (0 pairs)` + `exit 0` 이 나온다 — **삭제가 조용한
+  PASS 로 렌더**된다. 부분문자열 매치였다면 usage 배너도 게이트를 만족시켰다. `rc=124`(timeout kill)는
+  «레인 실패» 가 아니라 **HARNESS ERROR** 로 라우팅한다.
+- **회귀 앵커 7개 신설** — `test_lane_runner_lanes.sh` 14→17, `test_selfcheck_state_lanes.sh` 44→48.
+  L16 이 특히 load-bearing 하다: 같은 세션의 적대검증이 **처음 넣은 자기제외 가드에 앵커가 없음**을
+  지목했고(레인 둘 다 픽스처의 자기참조를 `#` 주석으로 써서, 가드를 되돌려도 16/16 초록이었다),
+  비-주석 픽스처를 넣고서야 «가드 있으면 17/17 · 없으면 정확히 L16 만 적색» 이 됐다.
+- **문서: README 가 정본 이전 프레이밍을 싣고 있었다.** `① Assemble / ② Forge / ③ Sidecar /
+  ④ Self-evolving loop` 는 2026-08-09 정식화 **이전** 판으로, 5대 정체성과 절반 겹치면서 **⑤ 증폭자와
+  ② 인큐베이터가 통째로 빠져** 있었다. 3층 정본(5정체성 → 4엔진 → 3단 공정 + 4축 검증 + standpoint)
+  으로 교체하고 **번역 3종(ko/zh/ja)까지 같은 릴리스에서** 맞췄다. 등급표는 복제하지 않는다 —
+  `ship_readiness_gate.md` 가 유일 정본이고, 이 페이지는 4개 언어라 복제하면 사본이 4개가 된다.
+- **수치 청소(전부 재측정)**: 로스터가 스킬 37/40 · 에이전트 4/8 만 열거하던 것 → 40/40 · 8/8 ·
+  `docs/OUTPUT_EVIDENCE.md` 스킬 33→40 · 규칙 6→1(삭제가 아니라 `knowledge/shared/rules/` 로 이전) ·
+  지식 23→57 · 「12일차 · 커밋 224 · PR 66」→ **81일 · 768 · 372**, 그리고 **측정 날짜를 박았다** —
+  이 표가 두 달간 현재처럼 읽힌 원인은 숫자가 아니라 «언제 쟀는지 안 적힌 것» 이었다.
+  그 문서의 재현 recipe 는 SKILL.md 본문에서 "deprecated"/"redirect stub" 을 grep 해 **살아있는 스킬
+  2개**(`phantom-quench` · `hub-cc-pr-reviewer`)를 stub 으로 오분류하고 38 을 뱉고 있었다 — 본문 grep 은
+  «내가 stub 이다» 와 «나는 stub 을 검출한다» 를 구분하지 못한다. 교체했다.
+- 🟥 **이 릴리스는 #388 의 첫 출하이기도 하다.** `v1.4.98` 태그가 `#387` 에서 잘렸고 `#388`
+  (consent-gated auto fast-forward)은 그 뒤에 머지돼 **레지스트리에 한 번도 나간 적이 없다.**
+  실측 대조: 출하된 1.4.98 tarball 의 `scripts/fh_node_check.sh` 는 **243줄**로 consent 게이트 arm 이
+  통째로 없고, main 은 **282줄**이다. 1.4.98 항목이 «버전을 안 올려 런타임에 도달 못 한 규칙» 을
+  기록했는데 **같은 얼굴이 태그 절단 지점에서 재발**했다. 다만 이번엔 계기가 잡았다 —
+  `session_close_check.sh` ④-b 가 «마지막 태그 이후 출하자산 변경» 을 발화했고, 이번엔 그 출력을
+  표시필터로 자르지 않았다.
+- **공개면 정리**: `README.zh.md` 가 마지막 두 줄에 `</content>` `</invoke>` 도구 잔재 태그를
+  **공개 상태로** 싣고 있었다(이전 커밋부터). 제거.
+
+🟥 **출하 직전 보안 패스가 이 릴리스를 한 번 막았고, 그래서 이 항목이 더 있다.** `npm publish` 전
+게이트로 돌린 코드 보안 리뷰가 **BLOCK** 을 냈다 — `scripts/fh_node_check.sh` 의 consent 게이트가
+**클래스를 조인하지 않았다.** 두 조건이 각각 이랬다: ① `consent_registry_check.sh` 를 인자 없이 돌린
+rc=0 — 그건 «레지스트리와 grant 들이 well-formed 하고 floor join 이 성립» 이라는 **파일 전체 속성**이라
+**무관한 클래스 하나만 유효하게 승인돼 있어도 0** 이 난다 ② UAP **파일 전체**에 대한 raw grep 이라
+`granted` 와 `revoked` 를 구분하지 못하고, 히트가 기계 판독 영역인 frontmatter 안인지 산문 문단인지도
+보지 않는다. **컨트롤 동반 재현**: 무관한 클래스 1건 유효 승인 + 대상 클래스는 산문에
+`  repo-freshness-autopull: 안 쓰기로 했다` 한 줄 → 두 조건 통과 → **자동 fast-forward 실행**, 그리고
+배너는 운영자에게 *"standing consent"* 가 있다고 말한다. 망가진 쪽이 하필 **철회 경로**였고, 그건
+`absent ≠ granted` floor 가 지키려던 바로 그 자리다.
+- **수리**: `consent_registry_check.sh --require-class NAME` 신설 — 그 클래스가 **활성·등록·미만료
+  grant 로 전 항목을 통과했을 때만 0**, 아니면 3(=계속 물어라). 파일 전체 위반은 여전히 1 이 이긴다
+  («판정 불가 == 불허»는 그 스크립트 자신의 규칙이다). 조인 대상은 `validated`(per-grant 검사 **전에**
+  증가하는 카운터)가 아니라 **모든 검사를 통과한 이름 집합**이다. 플래그를 안 주면 동작은 종전과 동일.
+- **없던 컨트롤을 채웠다** — `lane10-f WRONG-CLASS`. 기존 거부 arm 셋(c/d/e)은 전부 **파일 전체 판정을
+  깨는 방식**으로 거부를 만들어서(grant 블록 삭제 · 리스 과거화 · 발산), **클래스 조인 축을 하나도
+  건드리지 않았다.** 새 arm 은 «다른 클래스는 유효 승인 + 이 클래스는 산문에만» 상태에서 거부되는지를
+  보고, **동시에 「그 순간 파일 전체 검사가 여전히 0인지」를 같이 단언**한다 — 그 두 번째 단언이 없으면
+  lane10-c 와 같은 이유로 통과해 축이 또 안 돌아간다.
+  🟥 그 레인도 **처음엔 장식이었다**: 되돌림 프로브를 돌리니 수리를 되돌려도 초록이었다(앞 arm 이 픽스처를
+  발산 상태로 남겨 consent 와 무관하게 ff 가 거부됐다). 전제조건을 리셋·단언하도록 고쳤고, 그 리셋이
+  **tracked UAP 편집을 되돌린다**는 두 번째 함정도 순서를 뒤집어 닫았다. 최종: 수리 있으면 24/24,
+  되돌리면 **정확히 lane10-f 만** 적색.
+- **그 수리 자체도 cross-family 가 4건 깎았다** — 전부 **fail-open** 이었다: ⓐ `--require-class '   '`
+  (공백만)이 bash 의 `-z` 를 통과한 뒤 python 이 strip 해서 빈 문자열이 되어 **좁히기가 조용히 꺼졌다**
+  ⓑ 플래그를 경로 **뒤에** 쓰면 무시되고 옛 파일 전체 판정이 나왔다 ⓒ 미지 옵션이 경로로 삼켜졌다
+  ⓓ 클래스 거부인데 요약줄은 `PASS` 를 찍어 **판정과 모순**했다(이 파일 자신이 「요약이 판정과 모순되면
+  거짓 초록」이라고 적어 둔 규칙). 넷 다 fail-closed 로 닫고 레인 10개를 붙였다(88 → 98).
+- **라운드 3 이 또 두 건을 깎았고 하나는 내가 만든 A급이었다** — 첫 수리가 `tr -d '[:space:]'` 로
+  이름의 **모든 공백을 삭제**해서 `--require-class 'repo-freshness-auto pull'` 이 실제 클래스로 접혀
+  **다른 이름을 물었는데 다른 클래스의 판정을 받았다**(신원 붕괴). 지금은 **트림만** 하고 내부 공백이
+  남으면 **고쳐주지 않고 거부**한다 — 신원을 조용히 수선하는 것이 바로 잘못된 클래스가 승인되는 경로다.
+  같은 라운드가 인자 재조립도 깎았다: 개행 구분 문자열 방식이 **argv 보존이 아니라** 개행 포함 경로를
+  쪼개고 빈 위치인자를 드롭해 **UAP 를 레지스트리 자리로 승격**시켰다 → bash 배열로 교체. 레인 +4(98 → 102).
+- **라운드 4 = 새 S/A 0** (수렴). 남은 B 1건은 **명시 잔여로 소스에 적었다**: 영-폭 결합자 같은 보이지
+  않는 문자가 클래스 이름으로 허용된다. 같은 라운드 컨트롤이 **거짓 조인은 없음**을 보였고(`ok` vs
+  `o<ZWJ>k` → 3, NFC/NFD 불일치 → 3), 악용에는 레지스트리와 UAP **둘 다** 쓰기 권한이 필요한데 그건
+  동의의 원천 자체라 권한 상승이 아니다. 올바른 수리는 NFC 정규화 + format/control 문자 거부이지
+  비-ASCII 일괄 거부가 아니다(이 하네스는 언어 중립이고 한글 클래스명은 정당하다) — 릴리스 중에 넣을
+  줄이 아니라 자기 known-pair 를 갖는 설계 결정이다.
+- **머지 시간 바운드는 넣었다가 뺐다** — cross-family 실측이 그 워치독이 **git 을 안 묶는다**를 보였다
+  (`perl alarm 2` 로 감싼 ff 머지가 느린 smudge 필터 앞에서 **7.9초 걸리고 rc=0**). 안 묶는 장치를
+  「바운드」라는 이름으로 남기면 이 릴리스가 고치려는 거짓 초록을 내가 다시 만드는 것이라 제거했다.
+  🟥 **파급이 더 있다**: 같은 워치독이 그 위 **fetch** 도 감싸고 있고 그건 이 변경 이전부터다 —
+  즉 fetch 가 실제로 묶이는지는 이제 **가정이 아니라 UNVERIFIED** 다. 소스에 잔여로 적었다.
+- **머지에 자기 예산을 줬다**(`FH_NODE_GIT_MERGE_DEADLINE`, 기본 5s). fetch 는 워치독이 있는데 머지는
+  없어서, fetch 가 예산 8s 를 다 쓰면 10s 훅 예산 안에서 큰 fast-forward 가 워킹트리 갱신 도중 죽을 수
+  있었다. **실소요는 안 쟀다 — 바운드지 초과했다는 주장이 아니다.**
+
+**남은 잔여(명시)**: 주석 필터는 줄-접두 전용이라 heredoc/문자열 안의 디스패치는 여전히 계수된다 ·
+subject **발견** 쪽은 아직 주석을 읽는다(«언급 ≠ 선언» 이 runner 쪽에만 강제된다) ·
+`selfcheck.sh` 의 인접 두 루프는 `rc=124` 를 라우팅하지 않는다(하나는 무음 실패, 다른 하나는
+«dispatcher missing?» 이라는 확신에 찬 오진) — Added-Scope Gate 로 분리해 신호로 이월.
+
 ### [1.4.98] — 2026-08-15
 
 **fix: 1.4.97 이후 쌓인 출하면 36파일을 실제로 배포한다 — 특히 «있는데 실행에 도달 못 하던» 검증 축 하나**

package/scripts/consent_registry_check.sh

@@ -66,9 +66,94 @@
 #
 #   "N/A" is printed as N/A, never as PASS — an unmeasured surface is not a clean one.
 #
-# Usage: bash scripts/consent_registry_check.sh [registry.yaml] [uap.md-or-yaml]
+# Usage: bash scripts/consent_registry_check.sh [--require-class NAME] [registry.yaml] [uap.md-or-yaml]
+#
+# `--require-class NAME` narrows the verdict from FILE-WIDE to ONE CLASS, and a caller acting on
+# behalf of a single class MUST use it. Without it, exit 0 means "the registry and the grants are
+# well-formed and the floor join holds" — a property of the FILE. A caller that reads that 0 as
+# "my class is granted" is wrong whenever any OTHER class is validly granted.
+#
+# That is not hypothetical. Measured 2026-08-15 with a live control: fh_node_check.sh gated its
+# auto-fast-forward on this script's file-wide 0 AND a raw `grep` for the class name anywhere in the
+# UAP. With one unrelated class validly granted and `repo-freshness-autopull` appearing only as a
+# prose line saying it had been REVOKED, both conditions passed and the merge ran — while the banner
+# told the operator it was acting on a standing consent that did not exist. The control (a real
+# grant for the class) also returned 0, so the two states were indistinguishable through that channel.
+# With `--require-class` the same pair separates: 0 for the real grant, 3 for the revoked one.
 set -uo pipefail
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+# Flag parsing, hardened by a cross-family round on the first draft. Three defects it found, all
+# reproduced, all fail-OPEN — the flag would appear to be in force while the verdict stayed file-wide:
+#   · `--require-class '   '` passed the `-z` test (non-empty), then Python's `.strip()` reduced it
+#     to "" and the require-class branch silently switched off.
+#   · the flag was read only at argv position 1, so `... reg.yaml uap.md --require-class NAME` was
+#     ignored without a word and returned the old 0.
+#   · an unknown flag was consumed as a path.
+# A gate whose ON switch can be silently OFF is worse than no gate, so all three now fail closed.
+FH_REQUIRE_CLASS=""
+FH_REQUIRE_CLASS_SET=""
+_pos=()
+# `_norm_class` TRIMS the ends. It does NOT delete interior whitespace, and the difference is the
+# whole point: a third round measured `--require-class 'repo-freshness-auto pull'` being squeezed to
+# `repo-freshness-autopull` and returning 0 — i.e. asking about one class and being told about a
+# DIFFERENT one. A name that still contains whitespace after trimming is refused rather than
+# repaired, because silently repairing an identity is how the wrong class gets authorized.
+_norm_class() {
+  local v="$1"
+  v="${v#"${v%%[![:space:]]*}"}"   # strip leading
+  v="${v%"${v##*[![:space:]]}"}"   # strip trailing
+  printf '%s' "$v"
+}
+_set_require_class() {
+  FH_REQUIRE_CLASS_SET=1
+  FH_REQUIRE_CLASS="$(_norm_class "$1")"
+  if [ -z "$FH_REQUIRE_CLASS" ]; then
+    echo "consent-registry: FAIL — --require-class given with an empty or whitespace-only class name; fail-closed" >&2
+    exit 1
+  fi
+  case "$FH_REQUIRE_CLASS" in
+    *[[:space:]]*)
+      echo "consent-registry: FAIL — class name '$FH_REQUIRE_CLASS' contains whitespace; a class identity is not normalised for you (fail-closed)" >&2
+      exit 1 ;;
+  esac
+  # 🟥 NAMED RESIDUAL — invisible and normalisation-confusable identities are still ACCEPTED.
+  # Round 4 measured it: a class whose name carries a zero-width joiner is admitted as an identity,
+  # and `unicodedata` is applied to the effect vocabulary but never to class names or grant keys.
+  # Why it is carried rather than closed here, stated so the next reader does not have to re-derive
+  # it: the same round's controls showed the failure direction is SAFE — `ok` vs `o<ZWJ>k` returns 3,
+  # and an NFC/NFD mismatch returns 3, so no confusable name FALSELY joins a real grant; the residue
+  # is that a weird name can be its own consistent identity. Exploiting that requires write access to
+  # BOTH the registry and the UAP, which are the consent source of truth — anyone holding those has
+  # already granted themselves whatever they wanted, so this is hygiene, not escalation.
+  # The right fix is NFC-normalising both sides and refusing Unicode format/control characters, NOT
+  # a blanket non-ASCII refusal: this harness is language-agnostic and a Korean class name is
+  # legitimate. That is a design decision with its own known-pair, not a line to add during a release.
+}
+# Positionals go into a bash ARRAY. The first draft accumulated them into a newline-delimited string
+# and rebuilt "$@" with `read` — measured not to be argv-preserving: a path containing a newline
+# split into two, and an empty positional was dropped, which silently promoted the UAP path into the
+# registry slot. This file is `#!/usr/bin/env bash`, so an array is available and exact.
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --require-class)
+      if [ "$#" -lt 2 ]; then
+        echo "consent-registry: FAIL — --require-class given with no class name; fail-closed" >&2
+        exit 1
+      fi
+      _set_require_class "$2"; shift 2 ;;
+    --require-class=*)
+      _set_require_class "${1#--require-class=}"; shift ;;
+    --)
+      shift; while [ "$#" -gt 0 ]; do _pos+=("$1"); shift; done ;;
+    --*)
+      echo "consent-registry: FAIL — unknown option '$1'; fail-closed rather than treating it as a path" >&2
+      exit 1 ;;
+    *)
+      _pos+=("$1"); shift ;;
+  esac
+done
+set -- ${_pos[@]+"${_pos[@]}"}
+export FH_REQUIRE_CLASS FH_REQUIRE_CLASS_SET
 REG="${1:-$ROOT/tracks/_meta/consent_classes.yaml}"
 UAP="${2:-$ROOT/tracks/_meta/user_adaptation_profile.md}"
 
@@ -474,6 +559,16 @@ else:
                 fails += 1; grants = None
 
 no_active_grant = False
+# Names that survived EVERY per-grant check. `--require-class` joins against this set, never against
+# `validated` (a count that includes names which then failed) and never against the file-wide verdict.
+clean_grants = set()
+REQUIRE_CLASS = os.environ.get("FH_REQUIRE_CLASS", "").strip()
+# "was the flag given" is tracked separately from "is the name non-empty". Collapsing them is how
+# the first draft turned a whitespace-only name into a silent fall-back to the file-wide verdict.
+REQUIRE_SET = os.environ.get("FH_REQUIRE_CLASS_SET", "") == "1"
+if REQUIRE_SET and not REQUIRE_CLASS:
+    print("consent-registry: FAIL — --require-class resolved to an empty class name; fail-closed")
+    sys.exit(1)
 if grants is None:
     pass
 elif not grants:
@@ -522,6 +617,12 @@ else:
             if st.strip().lower() in NON_GRANT:
                 continue
         validated += 1
+        # Failure count at the START of this grant's checks. A name joins `clean_grants` at the end
+        # of the body only if nothing was recorded against it in between — `validated` cannot serve
+        # that purpose, because it is incremented HERE and every failing branch below still counted.
+        # Each of those branches also `continue`s after `fails += 1`, so a failing name never reaches
+        # the add; this counter covers the non-continuing ones.
+        _f0 = fails
         c = by_name.get(name)
         if c is None:
             out("❌", f"R3 `{name}` granted but NOT in the registry (unregistered == unknown)"); fails += 1; continue
@@ -669,6 +770,8 @@ else:
                 out("❌", f"R7 `{name}` grant target {tgt!r} does not match the registered target "
                           f"{c['target']!r} — scope drift between grant and class")
                 fails += 1
+        if fails == _f0:
+            clean_grants.add(name)
     skipped = len(grants) - validated
     if validated == 0:
         # Same state as the empty-grants branch above, reached differently: every key present was
@@ -682,6 +785,11 @@ else:
         out("✅", f"R3-R6 all {validated} active grant(s) registered, eligible, unexpired, "
                   f"scope-recorded{note}")
 
+# The class-scoped verdict is decided BEFORE the summary, so the summary can agree with it. The
+# first draft printed it after, which produced `consent-registry: PASS` on a run that then exited 3
+# for the requested class — the exact contradiction this file's own comment below calls a false
+# green with extra steps (cross-family, 2026-08-16).
+_class_missing = bool(REQUIRE_CLASS) and not fails and REQUIRE_CLASS not in clean_grants
 print("----")
 # The human-facing summary must agree with the typed exit. It previously printed PASS on a run whose
 # own line above said "nothing granted, keep asking (not a PASS)" and whose exit code was 3 — so an
@@ -690,8 +798,15 @@ print("----")
 # false green with extra steps. (Caught by hand 2026-08-02 while verifying the exit-3 fix.)
 if fails:
     print(f"consent-registry: {fails} violation(s)")
+elif _class_missing:
+    seen = "none" if not clean_grants else ", ".join(sorted(clean_grants))
+    print(f"consent-registry: UNMEASURED for class `{REQUIRE_CLASS}` — nothing granted for it, "
+          f"keep asking (exit 3). Active grants that DID join: {seen}. A grant for another class, "
+          f"or the name merely appearing in the file, is not consent for this one.")
 elif no_active_grant:
     print("consent-registry: UNMEASURED — nothing granted, keep asking (exit 3)")
+elif REQUIRE_CLASS:
+    print(f"consent-registry: PASS for class `{REQUIRE_CLASS}` (active, registered, unexpired)")
 else:
     print("consent-registry: PASS")
 # BROKEN outranks UNMEASURED: a violation is a decided negative, "nothing granted" is merely nothing
@@ -703,5 +818,13 @@ if ZERO_CLASSES and not fails:
         print("consent-registry: FAIL — a standing grant exists but the registry declares zero "
               "classes; every such grant is UNREGISTERED (R3), which is BROKEN, not unmeasured")
         sys.exit(1)
+# ── --require-class: narrow the verdict to ONE class ───────────────────────────────────────────
+# Ordering is deliberate and matches the existing precedence: BROKEN (1) outranks everything, so a
+# violation anywhere still exits 1 even when the required class itself looks fine — an unparseable
+# neighbour means the file could not be decided, and "cannot decide == not allowed" is this script's
+# own rule. Below that, a required class that did not join is UNMEASURED (3), the same code as
+# "nothing granted", because to the caller they are the same instruction: KEEP ASKING.
+if _class_missing:
+    sys.exit(3)
 sys.exit(1 if fails else (3 if no_active_grant else 0))
 PY

package/scripts/fh_node_check.sh

@@ -199,7 +199,75 @@ if git -C "$FH" rev-parse --git-dir >/dev/null 2>&1 && git -C "$FH" remote get-u
       case "$_BEHIND" in
         ''|*[!0-9]*) : ;;   # not measurable — silent, not a claim
         0) : ;;
-        *) GIT_BEHIND_NOTE="local $_DEFAULT_BRANCH is ${_BEHIND} commit(s) behind origin/$_DEFAULT_BRANCH — run: git checkout $_DEFAULT_BRANCH && git pull --ff-only (or: git merge --ff-only origin/$_DEFAULT_BRANCH)" ;;
+        *)
+          # ── auto-apply, consent-gated, inside a deliberately narrow envelope ───────────────
+          # Operator request 2026-08-15, verbatim: "사람이 일일이 수동으로 깃풀해서 최신화해야하는지를
+          # 판단하지않고 … 세션 시작 시 레포체크를 클로드가 알아서 하고 최신화 제안하는 기능이 있으면
+          # 좋을것같아. 그리고 앞으로도 자동으로 이렇게 동기화할지 물어보는 것도."
+          #
+          # 🟥 IT NEVER SWITCHES BRANCHES, and that is the whole safety envelope — not a nicety.
+          # The recommendation this line used to print told the reader to `git checkout
+          # $_DEFAULT_BRANCH && git pull`. In a SHARED CHECKOUT a checkout yanks the ground out from
+          # under a peer session: measured on this repo 2026-08-09 (two sessions, one worktree, one
+          # committed onto the other's branch), which is why scripts/branch_claim.sh exists at all.
+          # As prose advice a human weighed that; automated, nobody would. So the apply arm fires
+          # ONLY when the default branch is ALREADY checked out, and `--ff-only` means it can
+          # neither rewrite history nor absorb a divergence — it refuses instead.
+          #
+          # Consent is a LEASE, joined mechanically, never inferred: the class must be registered
+          # promotion_eligible in tracks/_meta/consent_classes.yaml AND granted unexpired in the
+          # UAP frontmatter. scripts/consent_registry_check.sh is the single decider (exit 0 = a
+          # real grant was joined; 3 = nothing granted; 1 = broken). Absent, expired, unreadable, or
+          # unknown all take the same branch as "no": surface, do not apply. absent ≠ granted.
+          # 🟥 The two conditions this replaced did NOT ask whether THIS class was granted, and a
+          # security pass before the 1.4.99 publish caught it with a live control (2026-08-15).
+          #   · a bare run of consent_registry_check.sh returns 0 for a FILE-WIDE property — "the
+          #     registry and the grants are well-formed and the floor join holds". One validly
+          #     granted UNRELATED class produces that 0.
+          #   · the second condition was `grep -q '^\s*repo-freshness-autopull:'` over the WHOLE UAP,
+          #     which does not distinguish `granted` from `revoked` and does not care whether the
+          #     hit is inside the machine-read frontmatter or in a prose paragraph.
+          # Reproduced: one unrelated class granted + the line `  repo-freshness-autopull: 안 쓰기로
+          # 했다` in prose → both conditions passed, the merge ran, and the banner told the operator
+          # it was acting on a standing consent that had never existed. The revoke path was the one
+          # that broke, which is the exact floor `absent ≠ granted` exists to hold.
+          # `--require-class` joins the ONE class: 0 only if it is an active, registered, unexpired
+          # grant; 3 otherwise. Same known pair now separates 0 from 3.
+          _AUTOPULL=""
+          if [ -x "$FH/scripts/consent_registry_check.sh" ] \
+             && bash "$FH/scripts/consent_registry_check.sh" --require-class repo-freshness-autopull >/dev/null 2>&1; then
+            _AUTOPULL=1
+          fi
+          _ON_DEFAULT=""
+          [ "$(git -C "$FH" symbolic-ref --short -q HEAD 2>/dev/null)" = "$_DEFAULT_BRANCH" ] && _ON_DEFAULT=1
+          # 🟥 NO DEADLINE HERE, AND THAT IS A DECISION — read before adding one back.
+          # A deadline was added here and then REMOVED the same session, because a cross-family
+          # review measured that the watchdog does not do what its name says: wrapping
+          # `git merge --ff-only` in `perl -e 'alarm N; exec @ARGV'` with N=2, against an upstream
+          # adding 20 files behind a slow smudge filter, took ~7.9s and returned 0. The alarm did
+          # not bound git. Shipping it would have added the appearance of a bound with none of the
+          # behaviour — the same false-green shape this release exists to fix.
+          # ⚠️ The consequence reaches further than this line: `_fh_gitcheck_deadline` guards the
+          # FETCH above too, and that guard predates this change. Whether it actually bounds a
+          # stalled fetch is now UNVERIFIED rather than assumed — a network stall may differ from a
+          # CPU-bound checkout, and neither was measured. Recorded as a residual instead of being
+          # quietly relied on.
+          # The exposure that motivated the attempt is real but unmeasured: the fetch may spend its
+          # full 8s inside a SessionStart hook budgeted at 10s, leaving ~2s for a merge whose true
+          # duration nobody has timed. Fixing it properly means measuring that duration and then
+          # bounding with something that actually bounds — not re-adding this line.
+          if [ -n "$_AUTOPULL" ] && [ -n "$_ON_DEFAULT" ] \
+             && git -C "$FH" merge --ff-only "refs/remotes/origin/$_DEFAULT_BRANCH" >/dev/null 2>&1; then
+            # Announce every unprompted run — §Operational Adaptation Loop requires it of a standing
+            # grant, and a sync the reader never saw is indistinguishable from one that never ran.
+            GIT_BEHIND_NOTE="local $_DEFAULT_BRANCH was ${_BEHIND} commit(s) behind — fast-forwarded automatically (standing consent: repo-freshness-autopull). Nothing else was touched; your gitignored state is out of git's reach by construction."
+          else
+            # Every not-applied path lands here and says the same thing: what to run. It does NOT
+            # say why it did not apply, on purpose — "no grant" and "wrong branch" and "ff refused"
+            # would each need their own true sentence, and a wrong reason printed confidently is
+            # worse than none (this file's own §absent-subject rule).
+            GIT_BEHIND_NOTE="local $_DEFAULT_BRANCH is ${_BEHIND} commit(s) behind origin/$_DEFAULT_BRANCH — while ON that branch run: git merge --ff-only origin/$_DEFAULT_BRANCH"
+          fi ;;
       esac
     fi
     # no local branch named $_DEFAULT_BRANCH at all (e.g. a fork never checked it out) → silent,

package/scripts/lane_runner_check.sh

@@ -356,10 +356,16 @@ wired = {s for s in suites if has_runner(s)}
 # ── Embedded --self-test dispatchers — a class the name-pattern `suites` glob cannot see ──────
 # Measured 2026-08-13, the header of this file, §WHAT DEBT:0 DOES NOT MEAN: a lane suite that
 # lives INSIDE its subject as a `--self-test` flag — not a separate `test_*.sh`/`*_lanes.sh` file
-# — is structurally invisible to the glob above. 4 scripts carry one — chamber_witness.sh ·
-# capability_registry_check.sh · digest_landing_check.sh · directional_diff_gate.sh — and none
-# showed up as WIRED or UNWIRED anywhere in this report; the wiring line for the 3 that ARE wired,
-# the `for _subj in ...` loop at scripts/selfcheck.sh:478, could be deleted and nothing here would
+# — is structurally invisible to the glob above. When this block was written, 4 such scripts were
+# known and none showed up as WIRED or UNWIRED anywhere in this report.
+# ⚠️ Do not read that 4 as a current figure, and do not re-list the names here. The set is
+# DISCOVERED at run time by `_st_candidates` below and the live figure is printed in this file's
+# own SELFTEST_COUNTS line, so a hand-maintained example list beside a self-discovering scan is a
+# second source of truth that goes stale in silence. That is not hypothetical: the previous
+# version of this comment named a 4th example the code no longer agreed with, and the session that
+# noticed had to trace the discrepancy to ground by hand.
+# The wiring line for the subjects that ARE wired,
+# the `for _subj in ...` loop in scripts/selfcheck.sh, could be deleted and nothing here would
 # go red. found→extend, not a new file: same idiom as `suites`/`has_runner` above — discover
 # subjects, detect dispatch, report undeclared — new predicates for the shape this pattern uses.
 #
@@ -378,7 +384,7 @@ wired = {s for s in suites if has_runner(s)}
 # literal paren out as an escape sequence instead of a bare character, rather than splitting it
 # across lines.
 # A bare substring match on --self-test would also catch prose that only DISCUSSES the flag
-# (measured: scripts/selfcheck.sh:482 has a comment naming it as an example of what NOT to grep
+# (measured: scripts/selfcheck.sh's `_subj` loop carries a comment naming it as what NOT to grep
 # for, which is exactly the false positive this narrower check exists to avoid). Require one of
 # the two real dispatcher shapes instead: `"--self-test"` in a quoted comparison, or `--self-test)`
 # as a bare case-pattern. The close-paren is built via chr — see the paren-trap note above; a
@@ -392,6 +398,21 @@ def _read(path):
     except OSError:
         return ''
 
+# 🟥 NAMED RESIDUALS in the self-test branch — two asymmetries the 2026-08-15 repair did NOT close,
+# written here because this file names its other residuals and silence would read as coverage.
+#   1. Comment-stripping is LINE-PREFIX only. A dispatch line living inside a heredoc body or
+#      inside an echoed string is not a comment and still counts as a live caller. Symmetric with
+#      runner_dispatches, which has the same limit — so "symmetry restored" is true, and the shared
+#      blind spot survives in both. In-tree example of the shape: the heredoc fixtures in
+#      scripts/test_lane_runner_lanes.sh. Harmless today only because those name a fixture subject.
+#   2. Subject DISCOVERY below still reads comments. `_st_names` matches the raw dispatcher forms
+#      anywhere in the file, so a comment that merely mentions the flag can enrol a script as a
+#      self-test subject. Real case: chamber_witness.sh carries the flag inside a usage comment.
+#      Harmless today because that file also has a real dispatcher — but it means "a mention is not
+#      a declaration" is enforced on the RUNNER side and not on the SUBJECT side.
+# Neither is mechanized: closing them means parsing shell rather than scanning lines, which is the
+# Grep-Collision Treadmill this repo has already logged. Fix on the first case that actually bites.
+#
 # One line on purpose — see the paren-trap note above the SELFTEST_PAT definition.
 _st_candidates = [f for f in glob.glob('scripts/*.sh') if os.path.basename(f) not in suites and os.path.basename(f) != 'lane_runner_check.sh']
 _st_names = [os.path.basename(f)[:-3] for f in _st_candidates if any(_form in _read(f) for _form in SELFTEST_DISPATCH_FORMS)]
@@ -399,8 +420,8 @@ selftest_subjects = sorted(set(_st_names))
 
 def selftest_dispatched(bare_name, txt):
     """Two shapes, both real in this repo. Cross-family review (2026-08-14) caught the first draft
-    shipping only the second — it read scripts/selfcheck.sh:478's `_subj` for-loop but missed
-    :898/:933's direct `bash scripts/probe_scope_check.sh --self-test` / `bash scripts/
+    shipping only the second — it read scripts/selfcheck.sh's `_subj` for-loop but missed that
+    file's direct `bash scripts/probe_scope_check.sh --self-test` / `bash scripts/
     utterance_landing_check.sh --self-test`, so those two subjects were reported UNDECLARED while
     selfcheck.sh runs them every time. This is the exact failure the header above names by cite —
     a reader trusting the count over the source would have been told a false thing with confidence.
@@ -410,11 +431,17 @@ def selftest_dispatched(bare_name, txt):
     Shape 2 (indirect): bare_name sits in a `for VAR in ... bare_name ...; do` loop whose body
     dispatches $VAR with --self-test — mirrors the indirect-branch reasoning of runner_dispatches:
     the literal name is in a list construct, the invocation runs through the loop variable, so a
-    direct-dispatch grep alone structurally cannot see it (scripts/selfcheck.sh:478)."""
-    if re.search(rf'\bbash\s+scripts/{re.escape(bare_name)}\.sh\b[^\n]*--self-test', txt):
+    direct-dispatch grep alone structurally cannot see it (selfcheck.sh's `for _subj in ...` loop).
+
+    Comment lines are dropped first, exactly as runner_dispatches does for ordinary suites: "a
+    mention is not an invocation" applies identically here, and until 2026-08-15 it was enforced in
+    only one of the two predicates. Measured: a `#   bash scripts/x.sh --self-test` usage line
+    matched the direct regex and certified a subject nothing ran."""
+    _body = '\n'.join(_l for _l in txt.split('\n') if not _l.strip().startswith('#'))
+    if re.search(rf'\bbash\s+scripts/{re.escape(bare_name)}\.sh\b[^\n]*--self-test', _body):
         return True
     in_loop = False; loop_var = None; has_name = False
-    for ln in txt.split('\n'):
+    for ln in _body.split('\n'):
         s = ln.strip()
         m = re.match(r'for\s+(\w+)\s+in\b(.*)', s)
         if m:
@@ -430,7 +457,20 @@ def selftest_dispatched(bare_name, txt):
     return False
 
 def has_selftest_runner(bare_name):
-    return any(selftest_dispatched(bare_name, _read(r)) for r in runners)
+    # A subject does not wire itself. has_runner() has skipped a suite's own file since this file
+    # was written; this branch did not, and the asymmetry was invisible because nothing exercised
+    # it — the only in-file control drove selftest_dispatched with synthetic text, never the
+    # runner set.
+    # ⚠️ Attribution, kept precise because a cross-family round caught it being loose: the 2026-08-15
+    # incident — directional_diff_gate.sh dispatched by nothing while the report said 10/10 — was
+    # caused by the COMMENT half, and comment-stripping alone closes it. Every self-reference in
+    # this tree at that date was a `#` line; a non-comment one existed nowhere. So this guard is
+    # SYMMETRY, not a repair of an observed case: it covers the shape where a subject names its own
+    # dispatch in live code, such as a usage helper. That shape is pinned by lane L16, which was
+    # added at the same time and for the same reason — without it this line is a repair no control
+    # drives, which is the failure mode this file exists to name.
+    _own = bare_name + '.sh'
+    return any(selftest_dispatched(bare_name, _read(r)) for r in runners if os.path.basename(r) != _own)
 
 selftest_wired = {s for s in selftest_subjects if has_selftest_runner(s)}
 selftest_undeclared = sorted(s for s in selftest_subjects if s not in selftest_wired)
@@ -445,12 +485,18 @@ if not selftest_dispatched('alpha', _ST_POS_FIXTURE):
 if selftest_dispatched('alpha', _ST_NEG_FIXTURE):
     print("CONTROL_FAILED\tself-test known-negative fixture with no --self-test flag read as dispatched")
     raise SystemExit(2)
+# Second known-negative, added 2026-08-15 with the comment-skip repair. Without it the repair is a
+# line of code no control drives — the failure mode this whole file exists to name.
+_ST_CMT_FIXTURE = '#   bash scripts/alpha.sh --self-test   # usage example, not a caller\n'
+if selftest_dispatched('alpha', _ST_CMT_FIXTURE):
+    print("CONTROL_FAILED\tself-test commented usage line read as a live dispatcher")
+    raise SystemExit(2)
 
 # ── CONTROL: the instrument must be able to see a suite known to be wired, and must NOT see one
 # known to be dead. Without both arms a broken detector reports "all clean" or "all broken" and
 # either reads as a verdict. [[feedback_absence_measurement_needs_control]]
 CTL_POS  = 'test_selfcheck_state_lanes.sh'    # selfcheck.sh invokes this DIRECTLY
-CTL_POS2 = 'test_session_close_lanes.sh'      # selfcheck.sh:613 for-list + `bash "$_anchor"` — the
+CTL_POS2 = 'test_session_close_lanes.sh'      # selfcheck.sh's `_anchor` for-list + `bash "$_anchor"` — the
                                               # INDIRECT arm. Pins the second detection branch: the
                                               # strict detector called this UNWIRED and a hand-check
                                               # showed it runs. Without this control that branch
@@ -628,8 +674,18 @@ if [ -n "$SELFTEST_UNDECLARED" ]; then
   echo "    dispatcher anywhere (self-test code exists, nothing calls it — see this file's own"
   echo "    §Embedded --self-test comment for why the suites glob above cannot see this class):"
   printf '%s\n' "$SELFTEST_UNDECLARED" | sed 's/^/        /'
-  echo "    Fix by wiring \`bash scripts/<name>.sh --self-test\` into scripts/selfcheck.sh's"
-  echo "    _subj for-loop (scripts/selfcheck.sh:478), same shape as the 3 already there."
+  echo "    Fix by wiring \`bash scripts/<name>.sh --self-test\` into scripts/selfcheck.sh, by"
+  echo "    ONE of its two shapes — and the choice is decided by the subject's own output, not"
+  echo "    by which is shorter. The \`for _subj in ...\` loop gates on the substring 캘리브레이션;"
+  echo "    a subject whose terminal verdict is worded any other way goes red there for a reason"
+  echo "    that has nothing to do with its lanes — capability_registry_check was added to that"
+  echo "    loop and reverted for exactly this. Such a subject takes the second shape: its own"
+  echo "    direct-dispatch block, as capability_registry_check.sh and relay_channel.sh do there."
+  echo "    🟥 In that second shape do NOT gate on the exit code alone. Measured 2026-08-15 on"
+  echo "    directional_diff_gate: a suite whose lanes were all deleted still printed a PASS"
+  echo "    verdict and exited 0, and a usage banner carrying the same words satisfied a"
+  echo "    substring match. Require the terminal verdict AS A WHOLE LINE, with a non-zero count"
+  echo "    in it, or exit 0 will certify a suite that ran nothing."
 fi
 
 echo "PASS  lane-runner: ${TOTAL} suites — ${WIRED} wired · ${N_EXEMPT} exempt · ${N_DEBT} declared debt" \