@chrono-meta/fh-gate 1.4.89 → 1.4.91

package/scripts/test_reviewer_capability_conformance.sh

@@ -0,0 +1,173 @@
+#!/usr/bin/env bash
+# test_reviewer_capability_conformance.sh — runs the SHARED corpus against THIS repo's
+# reviewer-capability implementation and reports every disagreement.
+#
+# THE CONTRACT, and why it is shaped this way. Three repos judge "can this model be an
+# adversarial reviewer?" in three languages (bash hook · shell probe · python backend).
+#
+# Be precise about WHY they do not share a library, because the first draft of this comment
+# overstated it and a cross-family review caught the inversion: residency blocks the
+# PRIVATE→PUBLIC direction (internal model ids must never reach a public repo). It does NOT
+# stop a private repo from vendoring a sanitized PUBLIC library. The actual reasons are
+# (a) three languages/runtimes, and (b) the classifier is two regexes — a shared library
+# would add more coupling than the thing it shares. Residency governs the CORPUS's contents,
+# not the decision to share data instead of code.
+#
+# What they share is `scripts/reviewer_capability_corpus.tsv`
+# — pure data, residency-safe. Each side keeps its own implementation and vendors this
+# script plus the corpus; drift then surfaces as a red test in whichever repo drifted,
+# instead of as a silent difference nobody measures.
+#
+# Measured before this existed: 19 ids, 10 disagreements between two implementations, 9 of
+# them the private side reading INCAPABLE as CAPABLE. That drift had shipped and was
+# invisible — nothing compared the two.
+#
+# ── PORTING THIS TO ANOTHER REPO (the adapter is the only thing you write) ──────
+# Copy this file + the corpus, then replace classify() with a call into your own code:
+#   shell :  classify(){ your_probe.sh --check-model "$1" >/dev/null 2>&1 && echo CAPABLE || echo INCAPABLE; }
+#   python:  classify(){ python3 -c 'import sys;from x import is_reviewer_capable;
+#                        print("CAPABLE" if is_reviewer_capable(sys.argv[1]) else "INCAPABLE")' "$1"; }
+# Everything else — corpus parsing, verdict comparison, the UNDECIDABLE rule — stays.
+#
+# ── THE UNDECIDABLE ROWS ARE THE POINT ─────────────────────────────────────────
+# An implementation with only a denylist answers CAPABLE for an unrecognised id. That is
+# fail-open: a denylist cannot know `voyage-3` is an embedding model. Such an implementation
+# FAILS these rows, and that failure is correct — it is telling you to add a default-deny
+# leg, not to edit the corpus. A repo that genuinely cannot express UNDECIDABLE may set
+# ALLOW_UNDECIDABLE_AS_INCAPABLE=1, which is strictly-safer and reported as a named
+# deviation rather than a silent pass.
+#
+# Usage: bash scripts/test_reviewer_capability_conformance.sh   Exit: 0 = conforms; 1 = drift.
+
+set -uo pipefail
+REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+CORPUS="${CORPUS:-$REPO_ROOT/scripts/reviewer_capability_corpus.tsv}"
+HOOK="$REPO_ROOT/templates/.git-hooks/pre-commit"
+LENIENT="${ALLOW_UNDECIDABLE_AS_INCAPABLE:-0}"
+
+[ -f "$CORPUS" ] || { echo "🟥 HARNESS-ERROR: corpus not found at $CORPUS"; exit 10; }
+
+# ── Contract pin: am I reading THE corpus, or a drifted local copy? ─────────────
+# The single shared artifact lives in N repos as N copies, so the first failure mode is not
+# a wrong verdict — it is each side quietly grading itself against its own stale copy while
+# every instrument reports healthy. Verdict on mismatch is HARNESS_ERROR (exit 10), which is
+# neither PASS nor FAIL: nothing was measured against the contract.
+PINNED=$(grep -m1 '^#CORPUS-SHA256' "$CORPUS" | awk '{print $2}')
+ACTUAL=$(grep -E '^[^#[:space:]]' "$CORPUS" | shasum -a 256 2>/dev/null | cut -c1-16)
+[ -z "$ACTUAL" ] && ACTUAL=$(grep -E '^[^#[:space:]]' "$CORPUS" | sha256sum 2>/dev/null | cut -c1-16)
+if [ -z "$PINNED" ] || [ -z "$ACTUAL" ]; then
+  echo "🟥 HARNESS-ERROR: cannot verify the corpus pin (pinned='$PINNED' actual='$ACTUAL')."
+  echo "   An unverifiable pin is not a passing pin — refusing to grade against an unknown corpus."
+  exit 10
+fi
+if [ "$PINNED" != "$ACTUAL" ]; then
+  echo "🟥 HARNESS-ERROR: corpus drift — pinned=$PINNED actual=$ACTUAL"
+  echo "   This copy's data rows differ from the contract it names. Either re-sync from the"
+  echo "   canonical corpus, or bump #CORPUS-VERSION + #CORPUS-SHA256 in EVERY repo that"
+  echo "   vendors it. A local-only edit is how the shared contract silently stops being shared."
+  exit 10
+fi
+
+# ── Namespace declaration: what THIS consumer owns (OPA-bundle `roots` shape) ───
+# This consumer composes PANELS, so it judges sidecar/CLI names and model ids alike.
+# A consumer that only classifies model ids declares NS="model-id" and its skipped rows are
+# REPORTED below, never silently counted as passing.
+NS="${NS:-cli model-id}"
+
+# ── THIS repo's adapter: the two regexes inside validate_crossfamily_leg ────────
+# Sourced FROM the hook rather than restated, so this test cannot drift from the thing it
+# is testing. A restated copy would be a fourth implementation — the exact defect class
+# this file exists to measure.
+DENY=$(grep -m1 -oE "grep -qiE 'embed\|[^']*'" "$HOOK" | sed -E "s/^grep -qiE '//; s/'$//")
+ALLOW=$(grep -m1 -oE "grep -qiE 'codex\|[^']*'" "$HOOK" | sed -E "s/^grep -qiE '//; s/'$//")
+if [ -z "$DENY" ] || [ -z "$ALLOW" ]; then
+  echo "🟥 HARNESS-ERROR: could not extract the classifier from $HOOK"
+  echo "   (deny='$DENY' allow='$ALLOW') — refusing to measure against an empty pattern,"
+  echo "   which would report every row as agreeing."
+  exit 10
+fi
+
+classify() { # $1 = model id → CAPABLE | INCAPABLE | UNDECIDABLE
+  # Ineligible-first: the overlap rows depend on this order and exist to catch its inversion.
+  if printf '%s' "$1" | grep -qiE "$DENY"; then echo INCAPABLE
+  elif printf '%s' "$1" | grep -qiE "$ALLOW"; then echo CAPABLE
+  else echo UNDECIDABLE; fi
+}
+
+# ── Instrument calibration: prove the adapter separates a known pair BEFORE trusting it ──
+# The pair is DERIVED FROM THE CORPUS within this consumer's own namespace, never hardcoded.
+# A hardcoded pair is namespace-blind: the first draft pinned `codex`, and a consumer that
+# classifies model ids (and correctly has no opinion on CLI names) failed calibration for a
+# reason that had nothing to do with its classifier. A calibration that can fail for the
+# wrong reason cannot certify anything.
+kp_pos=$(sed 's/\t/|/g' "$CORPUS" | awk -F'|' -v ns="$NS" \
+  '$2=="CAPABLE" && $3 ~ /^ns:/ { split($3,a,"/"); n=substr(a[1],4); if (index(" " ns " ", " " n " ")) { print $1; exit } }')
+kp_neg=$(sed 's/\t/|/g' "$CORPUS" | awk -F'|' -v ns="$NS" \
+  '$2=="INCAPABLE" && $3 ~ /^ns:/ { split($3,a,"/"); n=substr(a[1],4); if (index(" " ns " ", " " n " ")) { print $1; exit } }')
+if [ -z "$kp_pos" ] || [ -z "$kp_neg" ]; then
+  echo "🟥 HARNESS-ERROR: corpus has no known pair inside namespace [$NS]"
+  echo "   (pos='$kp_pos' neg='$kp_neg'). Without a pair that this consumer OWNS, nothing"
+  echo "   below is calibrated — refusing to grade."
+  exit 10
+fi
+gp=$(classify "$kp_pos"); gn=$(classify "$kp_neg")
+# Separate "the instrument is broken" from "the instrument works and disagrees". Collapsing
+# them makes a real, gradeable divergence abort as HARNESS-ERROR and go unmeasured — the
+# finding disappears into the error channel. A classifier that says CAPABLE to a known
+# NEGATIVE is not discriminating at all → unmeasurable. One that is merely too strict on the
+# positive still separates, so grade it and report the strictness as drift.
+if [ "$gn" = CAPABLE ]; then
+  echo "🟥 HARNESS-ERROR: adapter does not discriminate — known NEGATIVE $kp_neg → CAPABLE."
+  echo "   It cannot separate a case whose answer is already known. Aborting, not reporting."
+  exit 10
+fi
+if [ "$gp" != CAPABLE ]; then
+  echo "⚠️  calibration: known POSITIVE $kp_pos → $gp (expected CAPABLE)."
+  echo "   The classifier discriminates (negative held) but is stricter than the contract."
+  echo "   Grading continues — this is drift to report, not an unmeasurable instrument."
+else
+  echo "calibrated on [$NS]: $kp_pos → $gp · $kp_neg → $gn"
+fi
+
+N=0; BAD=0; DEV=0; SKIP=0
+printf "%-32s %-12s %-12s %s\n" "id" "expected" "actual" ""
+# IFS=$'\t' collapses CONSECUTIVE tabs (POSIX: repeated whitespace-class IFS chars are one
+# delimiter), so an aligned row with an empty field shifts every later field left and the
+# verdict column silently reads someone else's value. Split on a sentinel instead.
+while IFS='|' read -r id want cls why; do
+  case "$id" in ''|'#'*|' '*|$'\t'*) continue ;; esac
+  # Verdict field must be one of the three tokens. A continuation line of a multi-line note
+  # otherwise parses as a row and reports a phantom disagreement — measured on this file's
+  # own first draft, which is exactly the "instrument, not target" failure it must not have.
+  case "${want:-}" in CAPABLE|INCAPABLE|UNDECIDABLE) : ;; *) continue ;; esac
+  row_ns=$(printf '%s' "${cls:-}" | sed -E 's|^ns:([^/]+)/.*|\1|')
+  case " $NS " in *" $row_ns "*) : ;; *) SKIP=$((SKIP+1)); continue ;; esac
+  N=$((N+1)); got=$(classify "$id")
+  if [ "$got" = "$want" ]; then
+    printf "%-32s %-12s %-12s ✅\n" "$id" "$want" "$got"
+  elif { [ "$want" = UNDECIDABLE ] && [ "$got" = INCAPABLE ]; } \
+    || { [ "$want" = INCAPABLE ] && [ "$got" = UNDECIDABLE ]; }; then
+    # Outcome-safety grading, not label identity. Both verdicts BLOCK under default-deny, so
+    # the operational result is identical and this is a reported deviation, never a failure.
+    # Failing it would punish a pattern classifier for an opaque id it cannot possibly read
+    # (`voyage-3`, `bge-m3`) and make DELETING THE ROW the rational maintenance move — the
+    # corpus would then shrink toward whatever the weakest implementation happens to catch.
+    printf "%-32s %-12s %-12s ⚠️  deviation — same outcome (both block)\n" "$id" "$want" "$got"
+    DEV=$((DEV+1))
+  else
+    printf "%-32s %-12s %-12s ❌ %s\n" "$id" "$want" "$got" "$cls"
+    # Name the direction: a permissive miss is the one that ships broken panels.
+    { [ "$want" = INCAPABLE ] || [ "$want" = UNDECIDABLE ]; } && [ "$got" = CAPABLE ] \
+      && echo "     ↑ PERMISSIVE drift — this id would be counted as a reviewer"
+    BAD=$((BAD+1))
+  fi
+done < <(sed 's/\t/|/g' "$CORPUS")
+
+echo
+echo "corpus pin: $PINNED · namespaces: [$NS]"
+echo "rows graded: $N · disagreements: $BAD · allowed deviations: $DEV · skipped (other namespace): $SKIP"
+if [ "$BAD" -eq 0 ]; then echo "✅ conforms to the shared corpus"; else
+  echo "❌ DRIFT — this repo's classifier disagrees with the shared corpus on $BAD row(s)."
+  echo "   Fix the implementation, or change the corpus in ALL repos that vendor it."
+fi
+exit $([ "$BAD" -eq 0 ] && echo 0 || echo 1)

package/scripts/test_wizard_snippet_merge_lanes.sh

@@ -129,6 +129,93 @@ _eq  "MG-T  → the user's file is left byte-identical" "$(cat "$H/.claude/setti
   || _pass "MG-T  → no misleading backup artifact left behind"
 
 echo
+# ══ MULTI-SNIPPET DISCOVERY (regression for the 2026-08-08 high review, finding #1) ══
+# The merge block used to hardcode settings.SessionStart.snippet.json, so every OTHER shipped snippet
+# was structurally unregisterable — the compaction hooks shipped with a README reciting the
+# shipping-is-not-wiring lesson while reproducing it, and PreToolUse was already in the same hole.
+# These lanes fail if anyone reintroduces a single-snippet path.
+echo "══ multi-snippet discovery ══"
+
+_hub2() {  # $1=name → hub with the shipped SessionStart snippet PLUS a second, unrelated snippet
+  local h="$TMPROOT/$1"; mkdir -p "$h/templates" "$h/.claude"
+  cp "$SNIPPET" "$h/templates/settings.SessionStart.snippet.json"
+  cat > "$h/templates/settings.Zzz.snippet.json" <<'EOF'
+{
+  "_README": ["fixture — a snippet the merge code has never heard of"],
+  "project_settings_json": {
+    "hooks": {
+      "PreCompact": [
+        { "matcher": "", "hooks": [ { "type": "command", "command": "bash \"$HUB/scripts/zzz_probe.sh\" seal" } ] }
+      ]
+    }
+  }
+}
+EOF
+  echo "$h"
+}
+
+H=$(_hub2 multi); _merge "$H"
+_rc "MS-1 merge with two snippets exits 0" "$RC" 0
+python3 -c "
+import json,sys
+d=json.load(open('$H/.claude/settings.json'))
+h=d.get('hooks',{})
+ss=json.dumps(h.get('SessionStart',[]))
+pc=json.dumps(h.get('PreCompact',[]))
+print('OK' if ('fh_node_check' in ss and 'zzz_probe' in pc) else 'MISS')
+" > "$TMPROOT/ms.out" 2>/dev/null
+_eq "MS-2 BOTH snippets registered (unknown snippet needs no code edit)" "$(cat "$TMPROOT/ms.out")" "OK"
+
+# The registered-event set must come from the snippets, not from a hardcoded list.
+_eq "MS-3 a non-SessionStart event is registered" \
+    "$(python3 -c "import json;print('YES' if json.load(open('$H/.claude/settings.json')).get('hooks',{}).get('PreCompact') else 'NO')" 2>/dev/null)" "YES"
+
+# Idempotence: re-running must not duplicate either snippet's hooks.
+_merge "$H"
+_eq "MS-4 re-run is idempotent (no duplicate zzz_probe entry)" \
+    "$(python3 -c "import json;print(json.dumps(json.load(open('$H/.claude/settings.json')).get('hooks',{}).get('PreCompact',[])).count('zzz_probe'))" 2>/dev/null)" "1"
+
+# A user's own hook in the same event must survive the merge (hook-level, not group-level).
+python3 - "$H" <<'PY2'
+import json,collections,os,sys
+t=sys.argv[1]+"/.claude/settings.json"
+d=json.load(open(t),object_pairs_hook=collections.OrderedDict)
+d["hooks"].setdefault("PreCompact",[]).append({"matcher":"","hooks":[{"type":"command","command":"bash my_own.sh"}]})
+json.dump(d,open(t,"w"),indent=2,ensure_ascii=False)
+PY2
+_merge "$H"
+_eq "MS-5 user's own hook in the same event survives" \
+    "$(python3 -c "import json;print('YES' if 'my_own.sh' in json.dumps(json.load(open('$H/.claude/settings.json')).get('hooks',{}).get('PreCompact',[])) else 'NO')" 2>/dev/null)" "YES"
+
+# ══ RE-REVIEW REPAIRS (2026-08-08 round 2) ══
+# 두 건 다 **직전 라운드의 수리가 만든 결함**이다. 레인 없이 고치면 같은 자리로 돌아온다.
+echo "══ re-review repairs ══"
+
+# ZS — 스니펫 0개는 조용한 성공이 아니라 시끄러운 실패여야 한다 (#1)
+ZH="$TMPROOT/zerosnip"; mkdir -p "$ZH/templates" "$ZH/.claude"   # templates/ 는 있고 스니펫만 없다
+_merge "$ZH"
+_rc "ZS-1 스니펫 0개 → non-zero (조용한 성공 금지)" "$RC" 1
+case "$OUT" in *"NO SNIPPETS"*) _pass "ZS-2 무엇이 없는지 이름을 말한다" ;; *) _fail "ZS-2 실패 사유가 불명" ;; esac
+
+# KC — 파생 키가 베이스네임이면 남의 훅을 지운다 (#2)
+KH=$(_hub2 keycollide)
+python3 - "$KH" <<'PY2'
+import json,collections,os,sys
+t=sys.argv[1]+"/.claude/settings.json"
+d=collections.OrderedDict()
+if os.path.exists(t): d=json.load(open(t),object_pairs_hook=collections.OrderedDict)
+h=d.setdefault("hooks",collections.OrderedDict())
+# 사용자 자기 훅 — 파일명은 겹치지만 **경로가 다르다**
+h.setdefault("PreCompact",[]).append({"matcher":"","hooks":[
+  {"type":"command","command":"bash ~/tools/zzz_probe.sh --mine"}]})
+json.dump(d,open(t,"w"),indent=2,ensure_ascii=False)
+PY2
+_merge "$KH"
+_eq "KC-1 파일명만 겹치는 사용자 훅은 살아남는다" \
+    "$(python3 -c "import json;print('YES' if 'tools/zzz_probe.sh' in json.dumps(json.load(open('$KH/.claude/settings.json')).get('hooks',{}).get('PreCompact',[])) else 'NO')" 2>/dev/null)" "YES"
+_eq "KC-2 FH 자기 훅은 여전히 교체된다 (중복 없음)" \
+    "$(python3 -c "import json;print(json.dumps(json.load(open('$KH/.claude/settings.json')).get('hooks',{}).get('PreCompact',[])).count('scripts/zzz_probe.sh'))" 2>/dev/null)" "1"
+
 echo "══ ⓘ GAP lanes ══"
 
 # GAP 1 — the ONLY validation is what `kept + entry` incidentally requires: that entry is a list.
@@ -148,23 +235,29 @@ for name in emptylist nocommand wrongscript juststring; do
     BADSCHEMA_HITS=$((BADSCHEMA_HITS+1)); DETAIL="$DETAIL $name"
   fi
 done
-_g=0; [ "$BADSCHEMA_HITS" -gt 0 ] && _g=1
-_gap "valid-JSON / invalid-SCHEMA snippet → written, reported as success, node hook absent" "$_g" \
-  "$BADSCHEMA_HITS of $BADSCHEMA_TOTAL cases:$DETAIL. exit 0 and 'node-check SessionStart hook \
-registered ->' are printed while fh_node_check is NOT in the file that was just written. The success \
-message is unconditional — it does not re-read what it wrote. One-line fix: after the write, assert \
-fh_node_check appears in the serialized result, else exit non-zero."
+# PROMOTED 2026-08-08 (was a GAP): the merge block now shape-validates before writing and re-reads
+# what it wrote, so a bad-schema snippet can no longer be written-and-reported-as-success.
+# NOTE the fixture nuance: the `wrongscript` case is NOT malformed — it is a valid snippet naming a
+# different script, which the discovery-based merge correctly registers. `_registered` only greps for
+# fh_node_check, so it reads as "not registered". Assert the property that actually matters instead:
+# a run that skips a snippet must not exit 0 (fail-closed), which is what makes the old GAP dead.
+_eq "BS-1 malformed snippet never yields a zero exit (fail-closed)" \
+    "$(H=$(_hub bs1 '{"project_settings_json":{"hooks":{"SessionStart":["not even an object"]}}}'); _merge "$H"; [ "$RC" != 0 ] && echo CLOSED || echo OPEN)" "CLOSED"
+# (GAP 1 retired — promoted to BS-1 above, 2026-08-08)
 
 # GAP 2 — the corruption from GAP 1 is LATENT: the bad value lands in the user's settings.json and
 # detonates on the NEXT wizard run, in the kept-loop, far from where it was introduced.
 H=$(_hub latent '{"project_settings_json":{"hooks":{"SessionStart":["not even an object"]}}}')
 _merge "$H"; FIRST_RC=$RC
 _merge "$H"; SECOND_RC=$RC
-_g=0; { [ "$FIRST_RC" = 0 ] && [ "$SECOND_RC" != 0 ]; } && _g=1
-_gap "the bad write detonates on the NEXT run, not the run that made it" "$_g" \
-  "run1 exit=$FIRST_RC (reported success), run2 exit=$SECOND_RC (AttributeError in the kept-loop: \
-g.get on a str). The user's settings.json is now un-mergeable and the traceback points at the \
-survivor filter, not at the snippet that caused it."
+# PROMOTED 2026-08-08 (was a GAP): a bad snippet is skipped with a visible SKIP line instead of
+# corrupting settings.json, so run 2 no longer detonates on run 1's write.
+# The old GAP was: run 1 reports success, run 2 detonates on run 1's write. The promoted property is
+# DETERMINISM — both runs must reach the same verdict, so a failure is attributable to the snippet
+# that caused it rather than surfacing later inside the survivor filter.
+_eq "LT-1 verdict is deterministic across runs (no latent detonation)" \
+    "$([ "$FIRST_RC" = "$SECOND_RC" ] && echo DETERMINISTIC || echo LATENT)" "DETERMINISTIC"
+# (GAP 2 retired — promoted to LT-1 above, 2026-08-08)
 
 # GAP 3 — INSTRUMENT COVERAGE, measured not asserted. Build the exact post-failure state (companion
 # hook registered, node hook absent) and run install-doctor's registration check on it. The

package/scripts/utterance_landing_check.sh

@@ -0,0 +1,209 @@
+#!/usr/bin/env bash
+# utterance_landing_check.sh — 마감 전, 운영자 발화가 기록에 착지했는지 grep 검증.
+#
+# WHY. 마감 체인이 `CONSISTENT` 를 내면서도 운영자 발화가 통째로 빠지는 일이 두 세션 연속
+# 일어났다(2026-08-07 5건 · 2026-08-08 2건). close check 는 **형식**만 본다 — 카드가 로그보다
+# 새로운가, 필수 아티팩트가 있는가. **내용이 착지했는지는 안 본다.**
+#
+# 가장 잘 빠지는 것은 잊은 발화가 아니라 **행동으로 대응한 발화**다. 답장에서 판단까지 내리고
+# 나면 처리된 느낌이 남아서, 그 판단이 어디에도 안 적힌 채 세션이 끝난다. 2026-08-08 실측:
+# "PMH 가 개인위키에 4축을 돌려 늦어졌다" 에 대해 과적용이라는 판정을 답장에 썼고 기록은 0건.
+#
+# ── 이 스크립트가 존재하는 두 번째 이유: 손으로 짜면 계기가 죽는다 ──
+# 같은 검증을 손으로 짤 때마다 계기가 죽었다(N=3). 마지막 사망 원인은 **zsh word-split**:
+#
+#     S="a.md b.md";  grep -l "$pat" $S      # bash 는 분리, zsh 는 파일명 하나로 전달 → 전건 0
+#
+# 컨트롤이 없으면 그 0 이 "전부 미착지" 로 읽힌다. 그래서 이 스크립트는 (1) 파일을 배열로
+# 다루고 (2) **컨트롤을 먼저 돌려 살아있음을 증명한 뒤에만** 타깃 결과를 출력한다.
+# 컨트롤이 죽으면 타깃 결과를 아예 인쇄하지 않는다 — 죽은 계기의 출력은 데이터가 아니다.
+#
+# ── 사용 ──
+#   bash scripts/utterance_landing_check.sh <probes.tsv> <file> [<file>...]
+#   bash scripts/utterance_landing_check.sh --self-test
+#
+#   probes.tsv 형식 (탭 구분):
+#     CONTROL<TAB><정규식><TAB><라벨>     착지가 확실한 것. 하나라도 0이면 HARNESS-ERROR
+#     TARGET<TAB><정규식><TAB><라벨>      검증 대상 발화
+#
+# ── ⚠️ 명명된 잔여: 프로브는 문구 변경에 깨진다 (2026-08-08 실측) ──
+# 정규식을 **정확한 문구**에 걸면, 그 문구를 나중에 고치는 순간 프로브가 죽고 **착지한 항목이
+# 미착지로 뜬다**. 실측: 프로브 `2건만|두 개에만` 이 카드 제목을 `2건만` → `2건 병렬` 로
+# 편집하자 오탐을 냈다(내용은 그대로 있었다).
+#
+# 이건 `[[feedback_typed_verdict_channel]]` 이 이름 붙인 Grep-Collision Treadmill 의 반대편이다:
+# 충돌은 없는데 **너무 좁아서** 깨진다. 두 방향 모두 "문자열을 재고 대상을 안 본다" 의 사례다.
+#
+# 완화(닫히지 않음):
+#   · 정규식은 **여러 표현을 OR** 로 — 한 문구에 걸지 마라 (`A|B|C`)
+#   · **미착지가 뜨면 먼저 손으로 열어 확인**하라. 프로브 노후가 첫 번째 의심 대상이다.
+#     rc=1 은 "기록하라"가 아니라 "확인하라"로 읽어야 한다.
+#   · 이 실패 방향은 **안전**하다 — 착지한 것을 미착지로 부르지, 미착지를 착지로 부르지 않는다.
+#     과차단이지 fail-open 이 아니다. (반대였다면 이 도구는 못 쓴다.)
+#
+# ── 종료 코드 ──
+#   0   전건 착지
+#   1   미착지 있음 (라벨과 함께 출력)
+#  10   HARNESS-ERROR — 컨트롤 사망 또는 입력 불량. **PASS 도 FAIL 도 아니다**
+
+set -uo pipefail
+
+self_test() {
+  local T f=0 n=0
+  # mktemp 실패를 안 보면 T 가 빈 문자열이 되고 이어지는 쓰기가 `/a.md` 로 나간다 — 루트에
+  # 쓰려다 실패하고, 그 실패가 '캘리브레이션 실패' 로 렌더된다. 계기 부재를 계기 결함으로
+  # 오진하는 경로라 여기서 갈라 놓는다. (cross-family 감사에서 실제 샌드박스가 이걸 밟았다.)
+  T=$(mktemp -d 2>/dev/null) || T=""
+  if [ -z "$T" ] || [ ! -d "$T" ]; then
+    echo "🟥 HARNESS-ERROR: mktemp -d 실패 — 캘리브레이션을 돌릴 수 없다(계기 결함이 아니라 환경 부재)."
+    return 10
+  fi
+  trap 'rm -rf "$T"' RETURN
+  printf 'alpha 라는 단어\n' > "$T/a.md"
+  printf 'beta 라는 단어\n'  > "$T/b.md"
+  t() { n=$((n+1)); if [ "$2" = "$3" ]; then echo "✅ $1 → $3"; else echo "❌ $1 → $3 (기대 $2)"; f=1; fi; }
+
+  printf 'CONTROL\talpha\tctl\nTARGET\tbeta\thit\n' > "$T/p1.tsv"
+  bash "$0" "$T/p1.tsv" "$T/a.md" "$T/b.md" >/dev/null 2>&1 && r=PASS || r=FAIL
+  t "컨트롤 생존 + 타깃 착지" PASS "$r"
+
+  printf 'CONTROL\talpha\tctl\nTARGET\tgamma\tmiss\n' > "$T/p2.tsv"
+  bash "$0" "$T/p2.tsv" "$T/a.md" "$T/b.md" >/dev/null 2>&1; rc=$?
+  t "타깃 미착지 → rc=1" 1 "$rc"
+
+  # 핵심 레인: 컨트롤이 죽으면 타깃이 '전부 미착지'처럼 보이는데, 그때 1을 내면 안 된다.
+  printf 'CONTROL\tzzz없는단어\tctl\nTARGET\tbeta\thit\n' > "$T/p3.tsv"
+  bash "$0" "$T/p3.tsv" "$T/a.md" "$T/b.md" >/dev/null 2>&1; rc=$?
+  t "컨트롤 사망 → rc=10 (1 아님)" 10 "$rc"
+
+  # zsh word-split 재현 방어: 파일 인자가 여러 개일 때 실제로 전부 읽히는가.
+  # ⚠️ 이 픽스처는 원래 TARGET 없이 컨트롤 2건만 두고 rc=0 을 기대했다. 그 형태가 곧
+  # "아무것도 안 쟀는데 합격" 을 **레인이 승인하는** 상태였다(아래 p6 이 그래서 신설됐다).
+  # word-split 을 재려면 컨트롤이 두 파일에 흩어져 있으면 충분하고, TARGET 은 있어야 한다.
+  printf 'CONTROL\talpha\tctl\nCONTROL\tbeta\tctl2\nTARGET\t라는\thit\n' > "$T/p4.tsv"
+  bash "$0" "$T/p4.tsv" "$T/a.md" "$T/b.md" >/dev/null 2>&1; rc=$?
+  t "두 파일에 흩어진 컨트롤 2건 모두 생존" 0 "$rc"
+
+  printf 'TARGET\tbeta\thit\n' > "$T/p5.tsv"
+  bash "$0" "$T/p5.tsv" "$T/a.md" >/dev/null 2>&1; rc=$?
+  t "컨트롤 0개 → rc=10 (검증 불가)" 10 "$rc"
+
+  # 잰 발화가 0 건인데 초록을 내면 안 된다. rc=1(미착지)과도 **다른 값**이어야 한다 —
+  # 둘이 뭉치면 "기록하라" 와 "프로브를 안 썼다" 가 구분되지 않는다.
+  printf 'CONTROL\talpha\tctl\n' > "$T/p6.tsv"
+  bash "$0" "$T/p6.tsv" "$T/a.md" "$T/b.md" >/dev/null 2>&1; rc=$?
+  t "TARGET 0개 → rc=10 (0 도 1 도 아님)" 10 "$rc"
+
+  # 깨진 정규식은 무매치가 아니다. grep 은 에러도 비영으로 주므로 순진하게 받으면
+  # **고장난 프로브가 '미착지' 로 렌더된다** = 있지도 않은 누락을 기록하게 만든다.
+  printf 'CONTROL\talpha\tctl\nTARGET\t[\tbroken\n' > "$T/p7.tsv"
+  bash "$0" "$T/p7.tsv" "$T/a.md" "$T/b.md" >/dev/null 2>&1; rc=$?
+  t "깨진 정규식 → rc=10 (1 아님)" 10 "$rc"
+
+  # 대시로 시작하는 패턴이 grep 옵션으로 먹히면 계기가 통째로 오작동한다.
+  printf 'CONTROL\talpha\tctl\nTARGET\t-베타\tdashy\n' > "$T/p8.tsv"
+  bash "$0" "$T/p8.tsv" "$T/a.md" "$T/b.md" >/dev/null 2>&1; rc=$?
+  t "대시 시작 패턴이 옵션으로 안 먹힘 → rc=1(정상 미착지)" 1 "$rc"
+
+  echo; [ "$f" -eq 0 ] && echo "✅ 캘리브레이션 통과 ($n 쌍)" || echo "❌ 캘리브레이션 실패 ($n 쌍)"
+  return "$f"
+}
+
+[ "${1:-}" = "--self-test" ] && { self_test; exit $?; }
+
+if [ "$#" -lt 2 ]; then
+  echo "usage: $0 <probes.tsv> <file> [<file>...]" >&2
+  echo "       $0 --self-test" >&2
+  exit 10
+fi
+
+PROBES="$1"; shift
+FILES=("$@")   # 배열 — word-split 에 의존하지 않는다
+[ -f "$PROBES" ] || { echo "🟥 HARNESS-ERROR: probes 파일 없음: $PROBES"; exit 10; }
+for f in "${FILES[@]}"; do
+  [ -f "$f" ] || { echo "🟥 HARNESS-ERROR: 대상 파일 없음: $f"; exit 10; }
+done
+
+# 단일 검색 경로. CONTROL 과 TARGET 이 **같은 함수**를 통과해야 한다 — 두 벌로 나누면 한쪽만
+# 통과하는 입력이 다른 쪽에서 무음 드롭된다([[feedback_divergent_leniency_duplicate_normalizers]]).
+# 반환: 0=매치 · 1=무매치 · 2=grep 에러(잘못된 정규식 등). grep 은 에러도 2 로 주는데, 그걸
+# 무매치와 뭉치면 **깨진 프로브가 '미착지'로 렌더된다** — 계기 고장을 데이터로 파는 것이라
+# 이 스크립트가 막으려는 바로 그 오독이다. `--` 는 `-foo` 같은 패턴이 옵션으로 먹히는 걸 막는다.
+_probe_hits() {
+  local pat="$1"; shift
+  grep -lE -- "$pat" "$@" 2>/dev/null
+  return "${PIPESTATUS[0]:-$?}"
+}
+
+# ── 1단계: 컨트롤. 살아있음을 증명하기 전에는 타깃을 인쇄하지 않는다 ──
+CTL_TOTAL=0; CTL_DEAD=0; DEAD_LABELS=""; BAD_PAT=""
+while IFS=$'\t' read -r kind pat label; do
+  [ "${kind:-}" = "CONTROL" ] || continue
+  CTL_TOTAL=$((CTL_TOTAL+1))
+  _probe_hits "$pat" "${FILES[@]}" >/dev/null; _rc=$?
+  if [ "$_rc" -ge 2 ]; then
+    BAD_PAT="${BAD_PAT:+$BAD_PAT, }CONTROL/${label:-$pat}"
+  elif [ "$_rc" -ne 0 ]; then
+    CTL_DEAD=$((CTL_DEAD+1)); DEAD_LABELS="${DEAD_LABELS:+$DEAD_LABELS, }${label:-$pat}"
+  fi
+done < "$PROBES"
+
+if [ "$CTL_TOTAL" -eq 0 ]; then
+  echo "🟥 HARNESS-ERROR: probes 에 CONTROL 이 없다."
+  echo "   컨트롤 없는 부재 측정은 근거가 아니다 — 0 이 '미착지'인지 '계기 사망'인지 구분 불가."
+  exit 10
+fi
+if [ "$CTL_DEAD" -gt 0 ]; then
+  echo "🟥 HARNESS-ERROR: 컨트롤 $CTL_DEAD/$CTL_TOTAL 사망 — [$DEAD_LABELS]"
+  echo "   착지가 확실한 문자열이 안 잡힌다 = 계기가 대상을 못 읽고 있다."
+  echo "   타깃 결과는 **인쇄하지 않는다** — 죽은 계기의 출력은 데이터가 아니라 소음이다."
+  echo "   흔한 원인: zsh word-split(\$FILES 인용 누락) · 경로 오류 · 인코딩 불일치."
+  exit 10
+fi
+
+# TARGET 이 0건이면 잰 것이 없다. 예전 판본은 여기서 `발화 0 건 전부 착지` 를 인쇄하고 **0 을
+# 냈다** — 빈 프로브 세트가 초록 도장으로 환전됐다는 뜻이고, 그건 이 스크립트가 존재하는
+# 이유와 정확히 반대 방향이다(미측정을 0 으로, 0 을 합격으로). cross-family 감사가 지목했고,
+# self-test 의 p4 픽스처가 그 상태를 **기대값 0 으로 인코딩해** 굳히고 있었다 — 레인이 결함을
+# 방어하는 대신 승인하고 있었던 셈이다([[feedback_not_found_is_not_zero_family]]).
+if ! grep -qE '^TARGET'$'\t' "$PROBES"; then
+  echo "🟥 HARNESS-ERROR: probes 에 TARGET 이 없다 — 잰 발화가 0 건이다."
+  echo "   '전부 착지' 가 아니라 '아무것도 안 쟀다' 다. 빈 프로브 세트는 합격이 아니다."
+  exit 10
+fi
+echo "계기 생존: 컨트롤 $CTL_TOTAL/$CTL_TOTAL"
+echo
+
+# ── 2단계: 타깃 ──
+MISS=0; N=0
+while IFS=$'\t' read -r kind pat label; do
+  [ "${kind:-}" = "TARGET" ] || continue
+  N=$((N+1))
+  hits=$(_probe_hits "$pat" "${FILES[@]}" | wc -l | tr -d ' '); _rc=${PIPESTATUS[0]}
+  if [ "$_rc" -ge 2 ]; then
+    printf "  🟥 %-46s 프로브 오류\n" "${label:-$pat}"
+    BAD_PAT="${BAD_PAT:+$BAD_PAT, }TARGET/${label:-$pat}"
+  elif [ "$hits" -gt 0 ]; then
+    printf "  ✅ %-46s %s파일\n" "${label:-$pat}" "$hits"
+  else
+    printf "  🟥 %-46s 미착지\n" "${label:-$pat}"
+    MISS=$((MISS+1))
+  fi
+done < "$PROBES"
+
+echo
+# 깨진 프로브는 '미착지' 가 아니다. 둘을 같은 rc 로 내면 "기록하라" 와 "프로브를 고쳐라" 가
+# 구분되지 않고, 후자를 전자로 읽으면 있지도 않은 누락을 기록하게 된다.
+if [ -n "$BAD_PAT" ]; then
+  echo "🟥 HARNESS-ERROR: 프로브 정규식 오류 — [$BAD_PAT]"
+  echo "   grep 이 에러(rc≥2)를 냈다. 무매치가 아니라 계기 고장이다 — 정규식을 고쳐라."
+  exit 10
+fi
+if [ "$MISS" -eq 0 ]; then
+  echo "✅ 발화 $N 건 전부 착지"
+  exit 0
+fi
+echo "🟥 $N 건 중 $MISS 건 미착지 — 마감 전에 기록하라."
+echo "   ⚠️ 가장 잘 빠지는 것은 잊은 발화가 아니라 **행동으로 대응한 발화**다."
+echo "      답장에서 판단까지 내리고 나면 처리된 느낌이 남고, 그 판단이 어디에도 안 적힌다."
+exit 1