@chrono-meta/fh-gate 3.1.4 → 3.4.0

package/scripts/test_gate_shape_scan_lanes.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+# test_gate_shape_scan_lanes.sh — scripts/gate_shape_scan.sh 회귀 앵커.
+# 지키는 것은 «판별력»: known-pair 가 갈리는가, 주석만 있는 파일이 안 걸리는가, 바이너리가
+# «아님» 으로 접히지 않는가, Promise `reject(` 가 게이트로 읽히지 않는가(실측 오탐).
+set -uo pipefail
+HERE="$(cd "$(dirname "$0")" && pwd)"; SCAN="$HERE/gate_shape_scan.sh"
+PASS=0; FAIL=0
+ok(){ PASS=$((PASS+1)); printf '  ✅ %s\n' "$1"; }
+no(){ FAIL=$((FAIL+1)); printf '  ❌ %s — %s\n' "$1" "${2:-}"; }
+echo "── test_gate_shape_scan_lanes ──"
+[ -x "$SCAN" ] || { no "L1 실행비트" "$SCAN"; echo "FAILED=1"; exit 1; }
+bash -n "$SCAN" && ok "L1 구문" || no "L1 구문"
+OUT=$(bash "$HERE/gate_shape_scan.sh" --selftest 2>&1); RC=$?   # 직접 호출(변수 경유 아님) — new-code-anchor 가 실행으로 센다
+[ "$RC" -eq 0 ] && ok "L2 selftest rc=0 (known-pair 5)" || no "L2 selftest" "rc=$RC · $OUT"
+D="$(mktemp -d 2>/dev/null)" || D=""; [ -n "$D" ] && [ -w "$D" ] || { no "L3 환경" "mktemp -d 불가 — 레인 미측정(통과 아님)"; echo "PASS=$PASS FAIL=$FAIL"; echo "FAILED=1"; exit 1; }
+printf 'export function up(p) {\n  return new Promise((resolve, reject) => {\n    if (!p) reject(new Error("x"));\n    resolve(p);\n  });\n}\n' > "$D/promise.ts"
+bash "$SCAN" "$D/promise.ts" >/dev/null 2>&1; RC=$?
+[ "$RC" -eq 1 ] && ok "L3 Promise reject( 는 게이트가 아니다 (실측 오탐 앵커)" || no "L3 Promise reject" "rc=$RC"
+printf 'func main() {\n  http.ListenAndServe("0.0.0.0:8080", nil)\n}\n' > "$D/serve.go"
+bash "$SCAN" "$D/serve.go" >/dev/null 2>&1; RC=$?
+[ "$RC" -eq 0 ] && ok "L4 Go ListenAndServe → GATE-SHAPED" || no "L4 Go exposure" "rc=$RC"
+printf 'def f():\n    return "PASS"\n' > "$D/enum.py"; printf 'def g():\n    pass\n' > "$D/lower.py"
+bash "$SCAN" "$D/enum.py" >/dev/null 2>&1; R1=$?; bash "$SCAN" "$D/lower.py" >/dev/null 2>&1; R2=$?
+[ "$R1" -eq 0 ] && [ "$R2" -eq 1 ] && ok "L5 대문자 PASS 만 enum (소문자 pass 는 키워드)" || no "L5 enum case" "PASS rc=$R1 pass rc=$R2"
+bash "$SCAN" >/dev/null 2>&1; RC=$?; [ "$RC" -eq 3 ] && ok "L6 인자 없음 → usage rc=3" || no "L6 usage" "rc=$RC"
+printf '\x00\x01bin' > "$D/b.dat"; bash "$SCAN" "$D/serve.go" "$D/b.dat" >/dev/null 2>&1; RC=$?
+[ "$RC" -eq 3 ] && ok "L6b [gate-shaped, binary] → 3 이 0 을 이긴다 (무음 미스 금지)" || no "L6b 혼합 exit" "rc=$RC"
+printf 'x = author\n' > "$D/au.py"; printf 'ok = authorize(u)\n' > "$D/az.py"
+bash "$SCAN" "$D/au.py" >/dev/null 2>&1; R1=$?; bash "$SCAN" "$D/az.py" >/dev/null 2>&1; R2=$?
+[ "$R1" -eq 1 ] && [ "$R2" -eq 0 ] && ok "L6c 경계: author 는 아니고 authorize 는 맞다" || no "L6c auth 경계" "author rc=$R1 authorize rc=$R2"
+# L7 — 되돌림: 분류기의 EXPOSURE 클래스를 죽이면 L4 가 빨개지는가 (앵커가 장식이 아님을 실행으로)
+MUT="$D/scan_mut.sh"; /usr/bin/sed 's/^EXPOSURE_RE=.*/EXPOSURE_RE='"'"'(NEVER_MATCHES_XYZ)'"'"'/' "$SCAN" > "$MUT"
+bash "$MUT" "$D/serve.go" >/dev/null 2>&1; RC=$?
+[ "$RC" -eq 1 ] && ok "L7 되돌림: EXPOSURE 제거 → serve.go 가 NOT 로 떨어진다 (레인이 실물을 잰다)" || no "L7 되돌림" "rc=$RC (제거해도 초록이면 앵커가 장식)"
+# L8 — pmh-dev #76: 여러 줄 docstring 안쪽 줄은 게이트가 아니다 (""" · ''' · 컨트롤 = docstring 뒤 실제 판정 줄)
+printf 'def t():\n    """docstring\n    PASS allow true\n    """\n    return 1\n' > "$D/doc3.py"
+printf "def t():\n    '''docstring\n    return Verdict.ALLOW in prose\n    '''\n    return 1\n" > "$D/doc1.py"
+printf 'def t():\n    """docstring\n    PASS allow true\n    """\n    return Verdict.ALLOW\n' > "$D/doc_ctrl.py"
+bash "$SCAN" "$D/doc3.py" >/dev/null 2>&1; R1=$?; bash "$SCAN" "$D/doc1.py" >/dev/null 2>&1; R2=$?; bash "$SCAN" "$D/doc_ctrl.py" >/dev/null 2>&1; R3=$?
+[ "$R1" -eq 1 ] && [ "$R2" -eq 1 ] && [ "$R3" -eq 0 ] && ok "L8 docstring 안쪽(triple-double · triple-single)은 NOT · 그 뒤 실제 판정 줄은 GATE-SHAPED" || no "L8 docstring" "triple=$R1 single=$R2 ctrl=$R3"
+# L8b — 되돌림: 짝 상태 추적을 죽이면 L8 이 빨개지는가
+MUT2="$D/scan_mut2.sh"; /usr/bin/sed 's/if (n % 2 == 1) { indoc=1; next }/if (0) { indoc=1; next }/' "$SCAN" > "$MUT2"
+bash "$MUT2" "$D/doc3.py" >/dev/null 2>&1; RC=$?
+[ "$RC" -eq 0 ] && ok "L8b 되돌림: 짝 상태 제거 → doc3.py 가 GATE-SHAPED 로 돌아간다 (레인이 실물을 잰다)" || no "L8b 되돌림" "rc=$RC"
+
+/bin/rm -rf "$D"
+echo "PASS=$PASS FAIL=$FAIL"; [ "$FAIL" -eq 0 ] && { echo "FAILED=0"; exit 0; } || { echo "FAILED=1"; exit 1; }

package/scripts/test_heavy_classifier_lanes.sh

@@ -7,8 +7,14 @@
 # louder symptom. Nothing was watching the watcher: measured 2026-08-20, `scripts/test_*.sh` files
 # testing this classifier = **0**, while 12 test files touch the hook for other reasons.
 #
-# Absorbed from a sibling harness (pmh-dev, 2026-08-08) rather than invented here. The load-bearing
-# idea is the extraction below, not the fixture list.
+# Provenance arc (sibling harness pmh-dev → FH, recorded both ways per the shared-layer canon rule):
+# this lane started TWO-WAY in pmh-dev (2026-08-08), was absorbed into FH, and FH extended the
+# classifier to FOUR-WAY (HEAVY · CARVEOUT · LIGHT · uncovered). The load-bearing idea is the
+# extraction below, not the fixture list. pmh-dev's own «#32 seam» rows were NOT re-imported
+# (2026-09-08, sibling-harvest review): each maps onto a class already pinned here — seam 1 (scripts/*.sh)
+# → `scripts/selfcheck.sh` · seam 2 (SKILL_detail.md) → goal-quench row · seam 3 (agent .md) →
+# challenger/local rows · seam 4 (sibling md in a skill dir) → `assets/note.md` row. Re-pinning the
+# same class under a sibling's issue number would be a decorative row, not a new anchor.
 #
 # 🟥 FH's classifier is FOUR-WAY, not two-way like the sibling's. The port is not a copy:
 #     HEAVY     → full gate
@@ -105,13 +111,17 @@ check carveout  "README.zh-CN.md"            "🟥 5-char locale forms too — c
 check uncovered ".claude/registry/README.md" "🟥 STILL UNCOVERED — in files[] but not root; named, not closed"
 check uncovered "package.json"               "files[] / version changes are unclassified"  # portability-noqa: "package.json" is a string literal fed to classify()'s regex test, never opened from disk — a ported repo without this exact file still exercises the same classifier logic
 check uncovered ".github/workflows/validate.yml" "🟥 CI definition — changing what CI runs is unclassified"
-check uncovered "scripts/memory_link_check.py"   "🟥 .py is not .sh — shipped python is unclassified"
+check heavy     "scripts/memory_link_check.py"   "🟢 .py joined .sh on 2026-09-07 — was pinned «uncovered» here (7 shipped python files outside the gate)"
+check heavy     "scripts/doc_claim_triad_scan.py" ".py — the file whose gate-less commit exposed the blind spot"
+check heavy     "scripts/adapters/peer_resolve.py" ".py in a subdirectory — the regex is ^scripts/.*, not ^scripts/[^/]*"
 
 echo "  ── controls (the classifier discriminates, it does not just fire) ──"
 # known-negative: a path that resembles a HEAVY one but must not match. This is the arm that
 # separates "the classifier works" from "the classifier fires on everything" — without it, a
 # regex of `.` would pass every HEAVY row above.
 check uncovered "notes/scripts/foo.sh.txt"   "control — .sh.txt is not a shell script (\$-anchored)"
+check uncovered "scripts/notes.txt"           "control — a non-executable under scripts/ must NOT become heavy with the .py widening"
+check uncovered "scripts/data.pyc"            "control — .pyc is not .py (\$-anchored, alternation closed)"
 check uncovered "notes/skills-overview.md"   "control — 'skills' in a path is not a skill spec"
 # ⚠️ this control was first written as `docs/design/skills-overview.md`, which the lane
 #    correctly classified `carveout` (`^docs/.*\.md$`). The FIXTURE was wrong, not the

package/scripts/test_marker_crossfamily_lanes.sh

@@ -38,7 +38,8 @@ sed -n '/^validate_crossfamily_leg()/,/^}/p' "$HOOK" > "$T/fn.sh"
 # itself lives OUTSIDE the function (same placement as DEFEATER_GRACE_DATE next to
 # validate_defeater_leg), so it is not part of this extraction and is supplied by the harness
 # below, exactly like GRACE_RES is.
-if ! grep -q 'DEGRADED_PANEL_UNUSED' "$T/fn.sh" || ! grep -q '_res_active' "$T/fn.sh"; then
+if ! grep -q 'DEGRADED_PANEL_UNUSED' "$T/fn.sh" || ! grep -q '_res_active' "$T/fn.sh" \
+   || ! grep -q '_ev_active' "$T/fn.sh"; then
   echo "❌ HARNESS-ERROR — validate_crossfamily_leg did not extract from $HOOK (or the residency"
   echo "   token block is missing from it). Fixtures below would measure an empty/stale function."
   exit 1
@@ -46,6 +47,11 @@ fi
 
 GRACE_RES=$(grep -m1 '^RESIDENCY_TOKEN_GRACE_DATE=' "$HOOK" | sed -E 's/.*"(.*)"/\1/')
 [ -n "$GRACE_RES" ] || { echo "❌ HARNESS-ERROR — RESIDENCY_TOKEN_GRACE_DATE 를 못 읽었다"; exit 1; }
+# 🟥 evidence= (2026-09-12) 도 같은 자리에 산다. 이 값을 «안 주입하면» 함수 안에서 빈 문자열이 되고
+#    `[ "$mdate" \< "" ]` 은 언제나 거짓 → grace 가 통째로 무효 → panel 을 쓰는 **기존 픽스처 전부**가
+#    evidence 없다는 이유로 BLOCK 된다. 실행해 보지 않으면 안 보이는 자리라 가드를 둔다.
+GRACE_EV=$(grep -m1 '^EVIDENCE_TOKEN_GRACE_DATE=' "$HOOK" | sed -E 's/.*"(.*)"/\1/')
+[ -n "$GRACE_EV" ] || { echo "❌ HARNESS-ERROR — EVIDENCE_TOKEN_GRACE_DATE 를 못 읽었다"; exit 1; }
 # Every fixture below this point (k*/b*/x*/c*) tests crossfamily's PRE-EXISTING shape rules —
 # panel format, embedding/reranker filters, declined, degrade grounds — none of them are testing
 # the residency-token addition. So mk()/run() stamp a date BEFORE RESIDENCY_TOKEN_GRACE_DATE into
@@ -61,7 +67,7 @@ PRE_RES="2026-08-01"   # < RESIDENCY_TOKEN_GRACE_DATE (2026-09-05) by constructi
 # every pre-existing fixture was silently treated as un-exempt).
 mk() { printf "$1" > "$T/.axes_23_passed_fix_x_$2_${PRE_RES}.marker"; }   # $1=body $2=fixture name
 run() {
-  bash -c "RESIDENCY_TOKEN_GRACE_DATE='$GRACE_RES'; source '$T/fn.sh'; validate_crossfamily_leg '$T/.axes_23_passed_fix_x_$1_${PRE_RES}.marker'" \
+  bash -c "RESIDENCY_TOKEN_GRACE_DATE='$GRACE_RES'; EVIDENCE_TOKEN_GRACE_DATE='$GRACE_EV'; source '$T/fn.sh'; validate_crossfamily_leg '$T/.axes_23_passed_fix_x_$1_${PRE_RES}.marker'" \
     >/dev/null 2>&1
 }
 
@@ -197,7 +203,7 @@ check c5 BLOCK "qwen-embedding — same overlap, other direction"
 # Same ordering requirement as mk()/run() above — date LAST, immediately before `.marker`.
 resfix() { printf "%s\n" "$1" > "$T/.axes_23_passed_fix_x_$3_$2.marker"; }   # $1=body $2=date $3=fname
 resrun() {   # $1=date $2=fname → rc
-  bash -c "RESIDENCY_TOKEN_GRACE_DATE='$GRACE_RES'; source '$T/fn.sh'; validate_crossfamily_leg '$T/.axes_23_passed_fix_x_$2_$1.marker'" \
+  bash -c "RESIDENCY_TOKEN_GRACE_DATE='$GRACE_RES'; EVIDENCE_TOKEN_GRACE_DATE='$GRACE_EV'; source '$T/fn.sh'; validate_crossfamily_leg '$T/.axes_23_passed_fix_x_$2_$1.marker'" \
     >/dev/null 2>&1
 }
 rescheck() {   # $1=fname $2=date $3=body $4=expect(PASS|BLOCK) $5=label
@@ -250,6 +256,72 @@ rescheck r16 "$GRACE_RES" 'crossfamily: panel(codex) — residency=CLEAN(files=3
 rescheck r17 "$GRACE_RES" 'crossfamily: panel(codex) — residency=CLEAN(files=3, stripped=2) — stripped files were named to the reviewer' \
   PASS  "r17 control — a second em-dash in the grounds does not break the token parse"
 
+echo
+echo "── evidence= token in crossfamily grounds (grace = $GRACE_EV) ──"
+# 🟥 왜 있나 — arXiv:2609.10969 이 고정예산 2×2(48 템플릿 · 2,880 시나리오)로 두 축을 분리해 재니
+#   «같은 증거를 읽는 교차-모델 투표» 가 위험 제안의 62.9 % 를 승인하고 «독립 출처» 는 22.9 % 였다
+#   (출처 40.9 %p vs 모델 다양성 11.3 %p = 3.6 배). 이 훅이 하드 차단하는 축이 약한 쪽이고,
+#   `panel(codex, gemini)` 가 «같은 diff» 를 읽은 패널이면 62.9 % 팔인데 기록은 강한 값으로 남는다.
+#   이 토큰은 그 구분을 «말할 수 있게» 만든다 — SHARED 를 불법으로 만드는 것이 아니다.
+EVOK='residency=CLEAN(files=3)'
+evcheck() { rescheck "$1" "$GRACE_EV" "$3" "$4" "$2"; }   # $1=fname $2=label $3=body $4=expect
+
+evcheck e1 "e1 panel + residency 만 있고 evidence= 없음 → BLOCK (구분이 안 적히면 강한 값으로 오독된다)" \
+  "crossfamily: panel(codex) — $EVOK · R1..R2, 4 findings" BLOCK
+evcheck e2 "e2 evidence=SHARED(...) — 정직한 약한 팔도 **통과한다**(불법이 아니다)" \
+  "crossfamily: panel(codex) — $EVOK · evidence=SHARED(same staged diff sent to both) · R1, 3 findings" PASS
+evcheck e3 "e3 evidence=INDEPENDENT(...) → PASS" \
+  "crossfamily: panel(codex, gemini) — $EVOK · evidence=INDEPENDENT(each ran its own checkout) · R1..R2" PASS
+evcheck e4 "e4 evidence=MIXED(...) → PASS" \
+  "crossfamily: panel(codex, gemini) — $EVOK · evidence=MIXED(codex got the diff, gemini ran the repo) · R1" PASS
+evcheck e5 "e5 닫힌 집합 밖 evidence=PARTIAL(...) → BLOCK" \
+  "crossfamily: panel(codex) — $EVOK · evidence=PARTIAL(some) · R1" BLOCK
+evcheck e6 "e6 닫는 괄호 없는 evidence=SHARED(x → 형식 위반(부재로 읽히면 fail-open)" \
+  "crossfamily: panel(codex) — $EVOK · evidence=SHARED(same diff · R1" BLOCK
+evcheck e7 "e7 토큰 두 개 → BLOCK (읽는 쪽이 첫 것만 취한다)" \
+  "crossfamily: panel(codex) — $EVOK · evidence=SHARED(same diff to both) · evidence=INDEPENDENT(no) · R1" BLOCK
+evcheck e8 "e8 SHARED 본문이 공허(한 낱말) → BLOCK — 약한 팔을 «기록된 것처럼» 남기지 못한다" \
+  "crossfamily: panel(codex) — $EVOK · evidence=SHARED(diff) · R1, 3 findings" BLOCK
+evcheck e8b "e8b 컨트롤 — INDEPENDENT 는 자기서술적이라 한 낱말도 통과(과차단이 override 를 훈련시킨다)" \
+  "crossfamily: panel(codex) — $EVOK · evidence=INDEPENDENT(rerun) · R1, 3 findings" PASS
+evcheck e8c "e8c SHARED 본문이 자리표시자 <...> → BLOCK" \
+  "crossfamily: panel(codex) — $EVOK · evidence=SHARED(<what>) · R1" BLOCK
+evcheck e9 "e9 컨트롤 — 패널이 안 돌았으면(DEGRADED) evidence= 는 요구하지 않는다(전면 요구가 아니다)" \
+  'crossfamily: DEGRADED_SINGLE_FAMILY — residency=CLEAN(files=0) probed codex/agy/gemini, 0 reachable' PASS
+rescheck e10 "2026-09-11" "crossfamily: panel(codex) — $EVOK · R1..R2, 4 findings" PASS \
+  "e10 grace 경계 — grace 하루 전 날짜의 마커는 evidence= 없이도 통과(소급 없음)"
+
+echo "· cross-family(agy) 가 초판 evidence= 에서 찾은 여섯 결함 — 전부 실행으로 재현 후 수리 ·"
+evcheck e11 "e11 🟥 중첩 한 겹은 정당하다 — MIXED(codex(diff), gemini(repo)) (초판은 본문이 'codex(diff' 로 잘려 과차단)" \
+  "crossfamily: panel(codex) — $EVOK · evidence=MIXED(codex(diff), gemini(repo)) · R1" PASS
+evcheck e11b "e11b 두 겹 중첩은 여전히 형식 위반(무한 중첩을 정규식으로 쫓지 않는다)" \
+  "crossfamily: panel(codex) — $EVOK · evidence=SHARED(a(b(c))) · R1" BLOCK
+evcheck e12 "e12 🟥 INDEPENDENT() 빈 본문 → BLOCK (초판은 통과 — «길이 미검사» 를 «본문 없어도 됨» 으로 접었다)" \
+  "crossfamily: panel(codex) — $EVOK · evidence=INDEPENDENT() · R1" BLOCK
+evcheck e12b "e12b 🟥 INDEPENDENT(<what>) 자리표시자 → BLOCK (초판 통과)" \
+  "crossfamily: panel(codex) — $EVOK · evidence=INDEPENDENT(<what>) · R1" BLOCK
+evcheck e12c "e12c 컨트롤 — INDEPENDENT(rerun) 은 짧아도 통과(길이 바는 SHARED/MIXED 에만)" \
+  "crossfamily: panel(codex) — $EVOK · evidence=INDEPENDENT(rerun) · R1" PASS
+evcheck e13 "e13 🟥 하이픈 복합어 SHARED(same-diff) → PASS (초판은 wc -w 로 1 낱말이라 과차단)" \
+  "crossfamily: panel(codex) — $EVOK · evidence=SHARED(same-diff) · R1" PASS
+evcheck e13b "e13b 🟥 한국어 본문 SHARED(동일 프롬프트 파일) → PASS — 이 레포는 근거를 한국어로 쓴다" \
+  "crossfamily: panel(codex) — $EVOK · evidence=SHARED(동일 프롬프트 파일) · R1" PASS
+evcheck e13c "e13c 컨트롤 — SHARED(diff) 는 여전히 너무 얇다(어느 산출물인지 안 말한다)" \
+  "crossfamily: panel(codex) — $EVOK · evidence=SHARED(diff) · R1" BLOCK
+rescheck e14 "2026-09-11" "crossfamily: panel(codex) — $EVOK · evidence=PARTIAL(some) · R1" BLOCK \
+  "e14 🟥 pre-grace 라도 «쓴 토큰» 의 형식은 본다 — 부재는 면제, 오작성은 면제 아님(초판 통과)"
+rescheck e14b "2026-09-11" "crossfamily: panel(codex) — $EVOK · R1..R2, 4 findings" PASS \
+  "e14b 컨트롤 — pre-grace + 토큰 부재는 그대로 통과(면제가 살아 있다)"
+# e15 — 상수 미주입이 «조용히 grace 를 끄는» 것이 아니라 크게 죽는지. 다른 레인과 러너가 달라 직접 돈다.
+N=$((N+1))
+resfix "crossfamily: panel(codex) — $EVOK · R1..R2" "2026-09-11" e15
+_E15=$(bash -c "RESIDENCY_TOKEN_GRACE_DATE='$GRACE_RES'; source '$T/fn.sh'; validate_crossfamily_leg '$T/.axes_23_passed_fix_x_e15_2026-09-11.marker'" 2>&1)
+if printf '%s' "$_E15" | grep -q 'EVIDENCE_TOKEN_GRACE_DATE unset'; then
+  echo "✅ e15 🟥 상수 미주입 → 크게 죽는다(초판은 조용히 grace 를 꺼서 pre-grace 마커 전부를 막았다) → BLOCK"
+else
+  echo "❌ e15 상수 미주입 — 가드가 안 울렸다: $(printf '%s' "$_E15" | head -2)"; FAIL=1
+fi
+
 echo
 if [ "$FAIL" -eq 0 ]; then echo "✅ all $N fixtures behave"; else echo "❌ regression ($N fixtures run)"; fi
 exit "$FAIL"

package/scripts/test_marker_standpoint_lanes.sh

@@ -42,11 +42,19 @@ if ! grep -q 'DEGRADED_NO_TARGET_ACCESS' "$T/fn.sh"; then
   exit 1
 fi
 
+# 🟥 STANDPOINT_GROUNDS_GRACE_DATE 는 함수 «바깥» 에 살아서 이 추출에 안 들어온다. 주입하지 않으면
+#    `set -u` 아래에서 그 확장이 죽거나(날짜 있는 마커) 조용히 grace 를 무효화한다(날짜 없는 마커).
+#    훅 쪽에도 `:?` 가드를 뒀으므로 미주입은 이제 **크게** 죽는다 — 그래서 여기서 반드시 읽어 온다.
+GRACE_SP=$(grep -m1 '^STANDPOINT_GROUNDS_GRACE_DATE=' "$HOOK" | sed -E 's/.*"(.*)"/\1/')
+[ -n "$GRACE_SP" ] || { echo "❌ HARNESS-ERROR — STANDPOINT_GROUNDS_GRACE_DATE 를 못 읽었다"; exit 1; }
+# 마커명에 날짜를 박는다 — validate_standpoint_leg 의 mdate 추출은 `.*_(YYYY-MM-DD)\.marker$` 다.
+# 기본은 grace «이후» 로 둔다: 새 계약이 기본값이어야 한다.
+POST_SP="$GRACE_SP"
 FAIL=0
-lane() { # $1 = id  $2 = expect(BLOCK|PASS)  $3 = marker body
-  local id="$1" expect="$2" body="$3" rc out
-  printf '%s\n' "$body" > "$T/m.marker"
-  out=$( bash -c 'set -uo pipefail; . "$1"; validate_standpoint_leg "$2"' _ "$T/fn.sh" "$T/m.marker" 2>&1 ); rc=$?
+lane() { # $1 = id  $2 = expect(BLOCK|PASS)  $3 = marker body  [$4 = marker date]
+  local id="$1" expect="$2" body="$3" mdate="${4:-$POST_SP}" rc out
+  printf '%s\n' "$body" > "$T/m_${mdate}.marker"
+  out=$( bash -c "set -uo pipefail; STANDPOINT_GROUNDS_GRACE_DATE='$GRACE_SP'; . \"\$1\"; validate_standpoint_leg \"\$2\"" _ "$T/fn.sh" "$T/m_${mdate}.marker" 2>&1 ); rc=$?
   local got=PASS; [ $rc -ne 0 ] && got=BLOCK
   if [ "$got" = "$expect" ]; then
     printf '  ✅ %-34s %s\n' "$id" "$got"
@@ -76,8 +84,25 @@ lane N5-deg-grounded   PASS  'standpoint: DEGRADED_NOT_RUN — 표적 접근 가
 lane N6-deg-targets    PASS  'standpoint: DEGRADED_NOT_RUN(qasp-dev · pmh-dev) — 전파 자산이라 해당되나 대상 레포에서 아무것도 실행 안 했다'
 lane N7-quoted-value   PASS  'standpoint: "tier2(pmh-dev) — 그 레포 로컬 클론에서 실제로 실행, 양·음 arm 확인"'
 
-echo "== WARN side — recorded, not blocking (the named residual above) =="
-lane N8-tier2-vague    PASS  'standpoint: tier2(pmh-dev) — 그쪽 레포 기준으로 판단했다'
+echo "== tier2+ grounds — BLOCKING since 2026-09-12 (was advisory) =="
+# ⚠️ 계약 변경 2026-09-12 — 이 픽스처는 PASS 를 단언하고 있었다(advisory 시절). 뒤집는 이유:
+#   arXiv:2609.10969 이 출처 축을 40.9 %p, 모델 축을 11.3 %p 로 재면서(n=2,880, 고정 호출예산)
+#   «강한 축의 grounds 를 advisory 로 두고 약한 축을 하드 차단» 이 균형이 아니게 됐다. 옛 기대값은
+#   조용히 지우지 않고 여기서 이유와 함께 뒤집는다(crossfamily k3 의 선례와 같은 형태).
+lane N8-tier2-vague    BLOCK 'standpoint: tier2(pmh-dev) — 그쪽 레포 기준으로 판단했다'
+lane N8b-tier2-named   PASS  'standpoint: tier2(pmh-dev) — 그 클론에서 `bash scripts/x.sh` 를 돌렸고 출력은 30/30 PASS 였다'
+lane N8c-tier1b-vague  PASS  'standpoint: tier1b(pmh-dev) — 그쪽 파일만 읽었다, 실행은 안 했다'
+# grace 경계 — 하루 전 날짜의 마커는 종전 advisory 대로 통과(소급 없음)
+lane N8d-pre-grace     PASS  'standpoint: tier2(pmh-dev) — 그쪽 레포 기준으로 판단했다' 2026-09-11
+
+echo "== 과차단 수리 (cross-family agy 적발 — 차단이 된 순간 이건 override 를 훈련시키는 결함이다) =="
+# 초판 키워드에 «뒤따르는 공백» 이 박혀 있어 콜론·다른 러너가 전부 막혔다. 실측으로 셋 다 BLOCK 이었다.
+lane N8e-cargo         PASS  'standpoint: tier2(pmh-dev) — 그쪽 클론에서 cargo check 로 확인했고 결과는 0 errors 였다'
+lane N8f-python        PASS  'standpoint: tier2(pmh-dev) — python scripts/eval.py 를 그 레포에서 수행, 12 passed 나왔다'
+lane N8g-colon         PASS  'standpoint: tier2(pmh-dev) — ran: ./ci.sh 결과 30/30 초록이었다'
+lane N8h-output-only   PASS  'standpoint: tier2(pmh-dev) — 그 레포에서 스위트를 돌렸고 53/53 으로 끝났다'
+# 컨트롤 — 느슨하게 만든 뒤에도 «명령도 출력도 안 적은 줄» 은 여전히 막힌다(과교정 방지)
+lane N8i-still-vague   BLOCK 'standpoint: tier2(pmh-dev) — 그쪽 관점에서 충분히 검토했다고 판단한다'
 
 [ $FAIL -eq 0 ] && { echo "✅ all standpoint lanes behave"; exit 0; }
 echo "❌ standpoint lane regression"; exit 1

package/scripts/test_preprep_font_lanes.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+# test_preprep_font_lanes.sh — preprep L15(서체 일관성)의 계약을 고정한다.
+#
+# WHY: 발표 템플릿을 주는 조직은 거의 항상 서체를 규정하는데, 서체 이탈은 **렌더링에서만**
+# 드러나 사람이 눈으로 훑기 전에는 안 보인다. preprep 의 이웃 레인들은 배치(P1/P3)와 말의
+# 정합(L1·L5·L8·R1~R5)을 보지, 「무슨 서체로 찍혔나」는 어느 레인도 안 봤다.
+#
+# 🟥 이 레인이 증명해야 하는 것은 «이탈을 잡는다»가 아니라 **«상속분을 안 잡는다»** 다.
+#    실측(2026-09-11, 조직 배포 템플릿 기반 발표 덱 120장): 순진하게 세면 `Helvetica Neue`
+#    **85건**이 «위반»으로 나오는데, 그 85건은 전부 `slideMasters/` 안에 있고 **배포 템플릿의
+#    마스터에도 정확히 같은 85건**이 있다(해시 동일). 저자는 그 글자를 찍은 적이 없다.
+#    진짜 이탈은 하나뿐이었고 그건 의도였다(코드 데모의 고정폭 서체).
+#    ⇒ known-negative 를 «서체 하나뿐인 덱»으로 두면 그 오탐을 **구조적으로 못 잡는다.**
+#      그래서 K1 은 «마스터에 이질 서체가 있지만 템플릿과 동일한 덱» 이다.
+#
+# 종료코드: 0 pass · 1 레인 실패 · 2 대상 부재 · 10 setup 실패
+set -uo pipefail
+cd "$(dirname "$0")/.." || exit 10
+LANE=plugins/fh-commons/skills/preprep/lane_font.py
+SELFTEST=plugins/fh-commons/skills/preprep/test_lane_font.py
+PROBE=plugins/fh-commons/skills/preprep/fixtures/font_revert_probe.py
+[ -f "$LANE" ] || { echo "ⓘ $LANE absent — subject missing (NOT a pass)"; exit 2; }
+[ -f "$SELFTEST" ] || { echo "ⓘ $SELFTEST absent — subject missing (NOT a pass)"; exit 2; }
+[ -f "$PROBE" ] || { echo "ⓘ $PROBE absent — subject missing (NOT a pass)"; exit 2; }
+command -v python3 >/dev/null 2>&1 || { echo "ⓘ python3 absent — setup broke"; exit 10; }
+# 🟥 스테일 바이트코드가 뮤턴트/복원을 가린다 — 이웃 레인이 실측한 사고다(2026-09-06).
+rm -rf plugins/fh-commons/skills/preprep/__pycache__
+PASS=0; FAIL=0
+ok(){ echo "  ✅ $1"; PASS=$((PASS+1)); }
+ng(){ echo "  ❌ $1"; FAIL=$((FAIL+1)); }
+
+echo "== K1~K13 known-pair (레인 자체 self-test) =="
+OUT=$(python3 "$SELFTEST" 2>&1); RC=$?
+echo "$OUT" | sed 's/^/  /'
+if [ "$RC" -eq 0 ] && echo "$OUT" | grep -q 'FAIL 0'; then
+  ok "self-test 전항 통과 (rc=$RC)"
+elif [ "$RC" -eq 2 ]; then
+  echo "  ⏭  픽스처 생성 불가 — UNMEASURED (통과 아님)"; FAIL=$((FAIL+1))
+else
+  ng "self-test 실패 (rc=$RC)"
+fi
+
+echo "== 배선·퇴화 — self-test 밖에서 한 번 더 =="
+OUT=$(python3 -c "
+import sys; sys.path.insert(0,'plugins/fh-commons/skills/preprep')
+import lane_font as L
+print(L.scan({}, '.')[1][0])
+print(L.scan({'surfaces_by_id':{'built_deck':{'path':'/nope/none.pptx'}}}, '.')[1][0])
+" 2>&1)
+echo "$OUT" | grep -q 'NOT_CONFIGURED' && echo "$OUT" | grep -q 'UNMEASURED' \
+  && ok "미선언 → NOT_CONFIGURED · 실물 없음 → UNMEASURED (둘 다 0 아님)" \
+  || ng "퇴화 표기가 0 으로 접힌다: $OUT"
+
+grep -q "import lane_font" plugins/fh-commons/skills/preprep/preprep.py \
+  && ok "배선: preprep.py 가 이 레인을 부른다" \
+  || ng "배선 없음 — 정의만 있고 아무도 안 부른다(built-but-not-wired)"
+
+grep -q "lane_font" plugins/fh-commons/skills/preprep/SKILL.md \
+  && ok "명세: SKILL.md 가 이 레인을 적는다(고아 구현 아님)" \
+  || ng "SKILL.md 에 없다 — 명세 없는 구현"
+
+# 🟥 이 프로브가 «template 미선언» 조건에서 도는 이유는 프로브 파일 머리에 적혀 있다. 요약:
+#    한때 방어가 둘이었고(영역 분리 · 템플릿-자체-서체 강등) 해시 동일 부품에서는 ②가 ①을
+#    완전히 덮어, 둘 다 켠 채 ①만 죽이면 «분리가 장식»이라는 **거짓 판정**이 났다.
+#    그 뒤 ②는 cross-family 2라운드에서 **fail-open 으로 판정돼 걷혔다**(억제 → 맥락 주석).
+#    지금 방어는 ① 하나뿐이고, 이 조건이 그 하나를 정확히 겨눈다.
+echo "== 되돌림 — 영역 분리를 죽이면 오탐이 돌아오는가 (template 미선언 = 방어 하나) =="
+OUT=$(python3 "$PROBE" separation 2>&1)
+if echo "$OUT" | grep -q 'BASE 0' && echo "$OUT" | grep -qE 'MUT [1-9]'; then
+  ok "되돌림: 분리를 죽이면 마스터 상속 서체가 오탐으로 돌아온다 ($OUT) — 분리가 하중을 진다"
+else
+  ng "되돌림 실패 — 분리를 죽여도 결과가 같다(그 분기가 장식이다): $OUT"
+fi
+
+# 🟥 «템플릿도 쓰는 이름» 을 노트로 **억제**하면 fail-open 이다 — 2라운드가 그렇게 지목해서
+#    억제를 걷어내고 맥락 주석만 남겼다. 이 레인이 그 되돌림을 고정한다.
+echo "== 템플릿도 쓰는 이름이 억제되지 않고 finding 으로 남는가 =="
+OUT=$(python3 "$PROBE" annotation 2>&1)
+if echo "$OUT" | grep -qE 'FINDING [1-9]' && echo "$OUT" | grep -qE 'ANNOTATED [1-9]'; then
+  ok "억제 아님: finding 은 남고 맥락 주석만 붙는다 ($OUT)"
+else
+  ng "억제로 되돌아갔다 — 저자가 그 이름으로 본문을 찍어도 종료코드가 안 움직인다: $OUT"
+fi
+
+echo "── preprep font lanes: PASS=$PASS FAIL=$FAIL"
+[ "$FAIL" -eq 0 ] || exit 1
+exit 0

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

@@ -213,10 +213,11 @@ fi
 # dlp-filter.sh, …) — the gate's OWN tooling. Leaving it ungated was a gate-locality
 # seam: the engine that enforces the 4-axis could itself ship unverified. Gated broadly,
 # not by an allowlist, so a NEW gate script cannot silently slip in ungated (the drift
-# that would re-open the seam). Scope is `scripts/*.sh` BY CONVENTION (all current gate
-# engines are .sh under scripts/): a governance script with another extension (.py) or
-# placed elsewhere (bin/) is NOT auto-caught and must be hand-gated — broaden this term
-# if that changes. Axis 1 (regression_guard) skips non-markdown, so the live effect on a
+# that would re-open the seam). Scope is `scripts/**/*.{sh,py}` (2026-09-07: `.py` joined
+# — a 252-line python instrument landed with no marker while 7 shipped python files sat
+# outside this term the whole time; the heavy-classifier lane had it PINNED as `uncovered`).
+# A governance script with yet another extension or placed elsewhere (bin/) is still NOT
+# auto-caught and must be hand-gated — broaden this term if that changes. Axis 1 (regression_guard) skips non-markdown, so the live effect on a
 # script is Axes 2-3 (adversarial design + phantom), NOT behavioral regression — that is
 # covered downstream (selfcheck.sh / count_check.sh at publish), not by this commit gate.
 # seam #3 (2026-06-27): agent definitions (plugins/*/agents/*.md, .claude/agents/*.md) are
@@ -242,7 +243,7 @@ fi
 #    «no FH asset staged» 로 빠져 4축 게이트를 통째로 건너뛰었다. tenet 을 바꾸는 것은
 #    이 레포에서 가장 하중 큰 편집 중 하나다 — LIGHT 는커녕 CARVEOUT 도 아니다.
 HEAVY=$(echo "$STAGED" \
-  | grep -E "(SKILL(_detail)?\.md|^plugins/[^/]+/skills/[^/]+/.*\.md$|\.claude/rules/|^knowledge/shared/rules/|templates/|CLAUDE\.md|^scripts/.*\.sh$|^plugins/[^/]+/agents/.*\.md$|^\.claude/agents/.*\.md$|^\.claude/soul_tenets\.txt$)" || true)
+  | grep -E "(SKILL(_detail)?\.md|^plugins/[^/]+/skills/[^/]+/.*\.md$|\.claude/rules/|^knowledge/shared/rules/|templates/|CLAUDE\.md|^scripts/.*\.(sh|py)$|^plugins/[^/]+/agents/.*\.md$|^\.claude/agents/.*\.md$|^\.claude/soul_tenets\.txt$)" || true)
 
 # Carve-out candidates: knowledge/ docs, docs/*.md, AGENTS.md. Heavy only if substantive.
 CARVEOUT=$(echo "$STAGED" \
@@ -804,8 +805,25 @@ validate_defense_leg() { # $1 = marker path — fires ONLY at the floor tiers (s
 # would block every in-flight branch and teach `--no-verify`, which disarms the Destructive-Op
 # gate sharing this hook.
 RESIDENCY_TOKEN_GRACE_DATE="2026-09-05"
+# 🟥 `evidence=` — panel(...) 이 «무엇을 받았는지» 를 적게 한다. 2026-09-12 신설, 근거는 외부 실측이다:
+#   arXiv:2609.10969 (48 템플릿 · 2,880 시나리오 · **고정예산 2×2**) 에서 «같은 증거를 읽는 교차-모델
+#   투표» 는 위험 제안의 **62.9 %** 를 승인하고 «독립 출처» 는 **22.9 %** — 출처 효과 40.9 %p 대
+#   모델 다양성 11.3 %p, **3.6 배**. 즉 이 훅이 이미 하드 차단하는 축(계열)이 약한 쪽이고,
+#   `panel(codex, gemini)` 가 **같은 diff 를 읽은 패널**이면 그것은 62.9 % 팔인데 기록은 강한 값으로
+#   남는다. 그 구분을 닫는 토큰이다. 🟥 새 필드도 새 게이트도 만들지 않는다 — residency= 와 같은
+#   자리(crossfamily 의 grounds) 에 같은 문법으로 얹는다.
+EVIDENCE_TOKEN_GRACE_DATE="2026-09-12"
+# 🟥 `standpoint:` tier2+ grounds — 2026-09-12 부로 **advisory 에서 차단으로**. 근거가 바뀌었다:
+#   이 carve-out 은 증거가 FH 자기 관찰 n=4+8 뿐일 때 합리적이었다. arXiv:2609.10969 이 같은 비교를
+#   n=2,880 에서 **40.9 %p 대 11.3 %p** 로 재면서, 「강한 축의 grounds 를 advisory 로 두고 약한 축을
+#   하드 차단한다」가 더는 균형이 아니게 됐다. §Mechanization Boundary 검사는 여전히 통과한다 —
+#   «저자가 실행한 명령과 본 출력을 명명했는가» 는 **기록의 속성**(존재·비공허·귀속가능)이지 결론이 아니다.
+#   🟥 정직한 범위: 이 게이트는 **기록의 형태**만 막는다. 그 실행이 진짜였는지는 여전히 안 본다 —
+#   게임 가능성은 §Mechanization Boundary 가 사람에게 남긴 의도된 잔여이고 이 변경이 닫는 구멍이 아니다.
+STANDPOINT_GROUNDS_GRACE_DATE="2026-09-12"
 validate_crossfamily_leg() { # $1 = marker path
   local m="$1" line val reason fams mdate _res_active _res_tokens _res_ntok _res_wellformed _res_kind
+  local _ev_active _ev_tokens _ev_ntok _ev_full _ev_nfull _ev_wellformed _ev_kind _ev_body _ev_grace _ev_strip
   if [ ! -f "$m" ] || ! grep -qE '^[[:space:]]*crossfamily:[[:space:]]*[^[:space:]]' "$m"; then
     echo "  ❌ FAIL — load-bearing file staged with no 'crossfamily:' line in the Axes 2-3 marker."
     echo "     Verdict/gate/irreversible-surface code shares the author's blind spot with a"
@@ -868,6 +886,31 @@ validate_crossfamily_leg() { # $1 = marker path
   _res_kind=""
   [ "$_res_wellformed" -eq 1 ] && _res_kind=$(printf '%s' "$_res_full" | sed -E 's/^residency=([A-Za-z_]*)\(.*$/\1/')
 
+  # evidence= token — same grammar and same presence-first rule as residency= above. REQUIRED for
+  # panel(...) on markers dated >= EVIDENCE_TOKEN_GRACE_DATE; format-only-if-present elsewhere.
+  # 🟥 상수를 «먼저» 평가한다(cross-family agy 적발). 이걸 mdate 검사 뒤에 두면 두 결함이 같이 난다:
+  #    ⓐ 미주입 시 `[ "$mdate" \< "" ]` 이 거짓이 되어 **grace 가 통째로 꺼지고** pre-grace 마커가
+  #      전부 막힌다(실측 확인) ⓑ mdate 가 비면 단축평가로 `:?` 가드가 아예 안 돈다.
+  _ev_grace="${EVIDENCE_TOKEN_GRACE_DATE:?EVIDENCE_TOKEN_GRACE_DATE unset — partial extraction of this hook? refusing to guess a grace date}"
+  _ev_active=1
+  if [ -n "$mdate" ] && [ "$mdate" \< "$_ev_grace" ]; then _ev_active=0; fi
+  _ev_tokens=$(printf '%s' "$reason" | grep -oE 'evidence=[^[:space:]]*' 2>/dev/null || true)
+  _ev_ntok=0
+  [ -n "$_ev_tokens" ] && _ev_ntok=$(printf '%s\n' "$_ev_tokens" | grep -c .)
+  # 🟥 `[^)]*` 는 중첩 괄호에서 안쪽 `)` 에 끊긴다 — `evidence=MIXED(codex(diff), gemini(repo))` 의
+  #    본문이 `codex(diff` 로 잘려 «공허» 판정을 받고 **정당한 기록이 하드 차단**됐다(실측).
+  #    한 겹 중첩을 허용한다(두 겹은 여전히 형식 위반 — 무한 중첩을 정규식으로 쫓지 않는다).
+  _ev_full=$(printf '%s' "$reason" | grep -oE 'evidence=(SHARED|INDEPENDENT|MIXED)\(([^()]|\([^()]*\))*\)' 2>/dev/null || true)
+  _ev_nfull=0
+  [ -n "$_ev_full" ] && _ev_nfull=$(printf '%s\n' "$_ev_full" | grep -c .)
+  _ev_wellformed=0
+  [ "$_ev_ntok" -eq 1 ] && [ "$_ev_nfull" -eq 1 ] && _ev_wellformed=1
+  _ev_kind=""; _ev_body=""
+  if [ "$_ev_wellformed" -eq 1 ]; then
+    _ev_kind=$(printf '%s' "$_ev_full" | sed -E 's/^evidence=([A-Z]*)\(.*$/\1/')
+    _ev_body=$(printf '%s' "$_ev_full" | sed -E 's/^evidence=[A-Z]*\(//; s/\)$//')
+  fi
+
   case "$val" in
     declined)
       # `declined` means ONE thing: the OPERATOR declined sidecars (UAP), a chosen floor. It was
@@ -1021,6 +1064,81 @@ validate_crossfamily_leg() { # $1 = marker path
           return 1
         fi
       fi
+      # evidence= — WHAT the panel received. Same four checks in the same order as residency=
+      # (duplicate → absent → shape → meaning). Why this exists at all: arXiv:2609.10969 measured
+      # the two axes against each other at fixed call budget (48 templates, 2,880 scenarios) and a
+      # cross-model vote over SHARED evidence approved 62.9% of unsafe proposals vs 22.9% with an
+      # independent source — 40.9pp vs 11.3pp for model diversity. A `panel(codex, gemini)` that
+      # read the same diff is that 62.9% arm while recording as this enum's STRONG value. The token
+      # makes the distinction sayable; it does not make shared evidence illegal.
+      # 🟥 grace 여부와 무관하게, 토큰이 «있으면» 형식은 본다 — residency 가 `DEGRADED_*` 에서 하는
+      #    약속과 같은 모양이다. 이게 없으면 pre-grace 마커의 `evidence=PARTIAL(...)` 이 조용히
+      #    통과한다(실측). 부재는 grace 가 면제하지만, **잘못 쓴 것은 면제하지 않는다.**
+      if [ "$_ev_active" -eq 0 ] && [ "$_ev_ntok" -gt 0 ] && [ "$_ev_wellformed" -ne 1 ]; then
+        echo "  ❌ FAIL — 'evidence=' token present but malformed (pre-grace marker: the token is"
+        echo "     OPTIONAL here, but a token that IS written must be well-formed):"
+        printf '%s\n' "$_ev_tokens" | sed 's/^/       /'
+        echo "     Closed set evidence=(SHARED|INDEPENDENT|MIXED)(...) with a closing paren."
+        return 1
+      fi
+      if [ "$_ev_active" -eq 1 ]; then
+        if [ "$_ev_ntok" -gt 1 ]; then
+          echo "  ❌ FAIL — grounds carries MORE THAN ONE 'evidence=' token."
+          printf '%s\n' "$_ev_tokens" | sed 's/^/       /'
+          echo "     Same trap as two crossfamily: lines — the reader takes the first. Leave one."
+          return 1
+        fi
+        if [ "$_ev_ntok" -eq 0 ]; then
+          echo "  ❌ FAIL — panel(...) with no 'evidence=' token in grounds."
+          echo "     State WHAT the panel received, because that axis carries ~3.6x the effect of"
+          echo "     family diversity (arXiv:2609.10969: shared evidence approves 62.9% of unsafe"
+          echo "     proposals vs 22.9% independent; 40.9pp vs 11.3pp). One of:"
+          echo "       evidence=SHARED(<what every family read — e.g. the same diff>)"
+          echo "       evidence=INDEPENDENT(<what each got separately — own checkout, own run>)"
+          echo "       evidence=MIXED(<which member got which>)"
+          echo "     e.g. crossfamily: panel($fams) — residency=CLEAN(files=3) · evidence=SHARED(same"
+          echo "          staged diff to both) · R1..R2, 4 findings"
+          echo "     🟥 SHARED is a legal, common answer — it is not a failure. Recording it as if"
+          echo "     it were INDEPENDENT is the failure this token exists to stop."
+          return 1
+        fi
+        if [ "$_ev_wellformed" -ne 1 ]; then
+          echo "  ❌ FAIL — 'evidence=' token present but not one well-formed"
+          echo "     evidence=(SHARED|INDEPENDENT|MIXED)(...) token:"
+          printf '%s\n' "$_ev_tokens" | sed 's/^/       /'
+          echo "     Closed set with a closing paren — same shape as residency=, same reason: a"
+          echo "     malformed token must be malformed, never invisible."
+          return 1
+        fi
+        # Meaning check, and it is deliberately only on SHARED/MIXED: those are the values whose
+        # whole content is "which evidence did they actually share", so an empty body says nothing.
+        # INDEPENDENT is self-describing; over-blocking it would train the override.
+        # 🟥 본문 검사, 두 층 — cross-family agy 가 초판의 두 결함을 다 지목했다:
+        #   ⓐ **빈 본문과 자리표시자는 세 값 모두 차단**한다. 초판은 INDEPENDENT 를 통째로 면제해서
+        #     `evidence=INDEPENDENT()` 와 `evidence=INDEPENDENT(<what>)` 가 **통과했다**(실측 fail-open).
+        #     «자기서술적이라 본문 검사 면제» 는 «본문이 없어도 된다» 와 다른 말이었는데 초판이 접었다.
+        #   ⓑ 길이 바는 **문자 수**로 센다. `wc -w` 는 `same-diff` 도 `동일diff` 도 1 낱말로 세서
+        #     정당한 한국어/하이픈 기록을 막았다(실측) — 한국어로 근거를 쓰는 이 레포에서 이건 상습 과차단이다.
+        _ev_strip=$(printf '%s' "$_ev_body" | tr -d '[:space:]')
+        if [ -z "$_ev_strip" ] \
+           || printf '%s' "$_ev_body" | grep -qE '^[[:space:]]*(TBD|tbd|N/?A|n/?a|없음|미정|-+|\?+|<[^>]*>)[[:space:]]*$'; then
+          echo "  ❌ FAIL — evidence=$_ev_kind(...) has an EMPTY or placeholder body: '$_ev_body'"
+          echo "     All three values need a body — 'self-describing' meant it is not length-checked,"
+          echo "     never that it can be blank. Name what each member actually received."
+          return 1
+        fi
+        case "$_ev_kind" in
+          SHARED|MIXED)
+            # 문자 수 기준(공백 제외). 4자 미만이면 «diff» 같은 한 토큰이고, 그건 어느 산출물인지
+            # 말하지 않는다. 🟥 낱말 수로 세지 않는다 — CJK 와 하이픈 복합어가 전부 1 낱말이 된다.
+            if [ "$(printf '%s' "$_ev_strip" | wc -m | tr -d ' ')" -lt 6 ]; then
+              echo "  ❌ FAIL — evidence=$_ev_kind(...) body too thin to identify the artifact: '$_ev_body'"
+              echo "     Name it (\"same staged diff\", \"one findings.jsonl\", \"동일 프롬프트 파일\")."
+              echo "     A bare $_ev_kind(diff) records the weak arm as if it were documented."
+              return 1
+            fi ;;
+        esac
+      fi
       echo "  ✅ cross-family leg: $val${reason:+ — $(printf '%s' "$reason" | cut -c1-60)}" ;;
     DEGRADED_SINGLE_FAMILY|DEGRADED_PANEL_UNUSED|UNKNOWN)
       # A degrade is allowed; being silent about WHICH degrade, or about its grounds, is not.
@@ -1128,6 +1246,7 @@ validate_crossfamily_leg() { # $1 = marker path
 # and 0 over-blocks. Anchor: scripts/test_marker_standpoint_lanes.sh
 validate_standpoint_leg() { # $1 = marker path
   local m="$1" line val reason n quoted=""
+  local _sp_mdate _sp_block _sp_grace
   n=$(grep -cE '^[[:space:]]*standpoint:' "$m" 2>/dev/null); n=${n:-0}
   if [ "$n" -eq 0 ]; then
     echo "  ❌ FAIL — load-bearing file staged with no 'standpoint:' line in the Axes 2-3 marker."
@@ -1173,13 +1292,41 @@ validate_standpoint_leg() { # $1 = marker path
     tier1b\(*\)|tier2\(*\)|tier2b\(*\)|tier3\(*\))
       case "$val" in
         tier2\(*\)|tier2b\(*\)|tier3\(*\))
+          # 🟥 키워드에 «뒤따르는 공백» 을 박아두면 정당한 기록이 막힌다 — cross-family agy 적발,
+          #    실측 확인: `cargo check` · `python scripts/eval.py` · `ran: ./ci.sh` 가 전부 BLOCK 이었다.
+          #    advisory 일 때는 경고 한 줄이었지만 **차단이 된 순간 이건 override 를 훈련시키는 결함**이다.
+          #    ⇒ ⓐ 경계를 «비-알파벳» 으로 바꾸고(콜론·세미콜론·줄끝 허용) ⓑ 흔한 러너를 넣고
+          #      ⓒ «출력» 의 형태(`30/30`, `rc=`, `./path`)도 실행의 증거로 받는다.
+          #    ⚠️ 방향: 이건 **느슨하게** 만드는 변경이다. 막고 싶은 것은 «명령도 출력도 안 적은 줄» 이고,
+          #    길이 20 자 하한은 그대로 남는다.
           if [ "${#reason}" -lt 20 ] || ! printf '%s' "$reason" \
-              | grep -qiE 'ran |run |실행|돌렸|호출|invok|call|rc=|exit |output|출력|suite|스위트|test|bash |grep |npm |pytest|command|커맨드|arm'; then
-            echo "  ⚠️  standpoint leg: $val — recorded, but the grounds do not NAME an execution."
-            echo "     ${val%%(*} asserts code RAN in the target. The discriminator is mechanical:"
-            echo "     name the command you ran and the output you saw. If you only read files,"
-            echo "     the honest rung is tier1b — weaker on purpose, so the owed arm stays visible."
-            echo "     Advisory by design (see the named residual above this function)."
+              | grep -qiE '(^|[^[:alpha:]])(ran|run|runs|exec|invoke[ds]?|call|calls|called|exit|output|suite|test|tests|tested|bash|sh|zsh|grep|npm|pnpm|yarn|pytest|python|python3|cargo|make|go|gradle|mvn|dotnet|node|command)([^[:alpha:]]|$)|실행|돌렸|돌린|돌려|호출|출력|스위트|커맨드|rc=|[0-9]+/[0-9]+|\./'; then
+            # Grace: markers dated before STANDPOINT_GROUNDS_GRACE_DATE keep the old advisory
+            # behaviour (no retro-blocking), same pattern as the residency=/evidence= tokens.
+            _sp_mdate=$(printf '%s' "$m" | sed -nE 's/.*_([0-9]{4}-[0-9]{2}-[0-9]{2})\.marker$/\1/p')
+            _sp_block=1
+            # Unreadable date → NOT exempt. The hook stamps TODAY into every marker filename it
+            # creates, so an unparseable date is an unexpected shape, not evidence of age.
+            # 🟥 상수를 «먼저» 평가한다 — 초판은 `[ -n "$_sp_mdate" ] && [ ... ${VAR:?} ]` 였고,
+            #    mdate 가 비면 단축평가로 `:?` 가드가 **아예 안 돌았다**(agy 적발). 가드가 있다고
+            #    적어놓고 안 도는 것은 장식이다([[feedback_anchor_can_be_decorative]]).
+            _sp_grace="${STANDPOINT_GROUNDS_GRACE_DATE:?STANDPOINT_GROUNDS_GRACE_DATE unset — partial extraction of this hook? refusing to guess a grace date}"
+            if [ -n "$_sp_mdate" ] && [ "$_sp_mdate" \< "$_sp_grace" ]; then _sp_block=0; fi
+            if [ "$_sp_block" -eq 1 ]; then
+              echo "  ❌ FAIL — standpoint leg: $val — the grounds do not NAME an execution."
+              echo "     ${val%%(*} asserts code RAN in the target. The discriminator is mechanical:"
+              echo "     name the command you ran and the output you saw. If you only read files,"
+              echo "     the honest rung is tier1b — weaker on purpose, so the owed arm stays visible."
+              echo "       standpoint: tier2(<harness>) — ran \`bash scripts/x.sh\` there, output: 30/30 PASS"
+              echo "     🟥 BLOCKING since 2026-09-12 (was advisory). Why it changed:"
+              echo "     arXiv:2609.10969 measured evidence-source diversity at 40.9pp against 11.3pp"
+              echo "     for model diversity (n=2,880, fixed call budget) — this is the STRONGER axis,"
+              echo "     and leaving its grounds advisory while hard-blocking the weaker one was not a"
+              echo "     balance. Honest scope: this blocks on the RECORD's shape, never on whether the"
+              echo "     run was real."
+              return 1
+            fi
+            echo "  ⚠️  standpoint leg: $val — grounds name no execution (pre-$STANDPOINT_GROUNDS_GRACE_DATE marker, advisory)."
           else
             echo "  ✅ standpoint leg: $val$quoted"
           fi ;;