@chrono-meta/fh-gate 2.6.0 → 2.7.0

package/scripts/residency_admission_check.sh

@@ -0,0 +1,204 @@
+#!/usr/bin/env bash
+# residency_admission_check.sh — 상주 텍스트 **유입** 게이트.
+#
+# 왜 있나 (2026-08-20 실측). 감량은 유출 문제가 아니라 유입 문제였다:
+#   CLAUDE.md   23,839(05-26) → 70,758(07-20 «11.9% 감량» 직후) → 144,138(08-20)
+#   07-20 이후 31일간 +73,380 = 약 2,367 bytes/일 (최근 5일은 약 7,000/일, 가속)
+#   같은 기간 어블레이션 CUT 판정 = **0건** (4개 절 시도 → KEEP 3 · UNCALIBRATED 1)
+# 즉 배수구를 넓히는 쪽엔 레버가 거의 없고, 수도꼭지는 아무도 안 보고 있었다.
+# 가장 큰 감량 후보 절(22k)조차 **유입 9일치**다 — 완벽히 잘라도 한 달이면 원위치이고,
+# 그건 가설이 아니라 07-20 에 실제로 일어난 일이다.
+#
+# 무엇을 검사하나 — 🟥 **결론이 아니라 기록의 속성**이다 (§Mechanization Boundary).
+# 「이 문단이 상주할 가치가 있나」는 판정하지 않는다. 「저자가 유형을 선언했나」만 본다.
+# `crossfamily:` · `standpoint:` 와 같은 형태이고 같은 마커에 얹힌다.
+#
+# 🟥 명시 잔여 — 이 게이트가 잡는 것은 **침묵**이지 **거짓 선언**이 아니다.
+# `detail-belongs-elsewhere` 는 자기 거절 값이라 압박받는 세션은 절대 고르지 않는다.
+# 형식은 채널이고 진위는 사람이다. 위 두 필드와 같은 이유로 받아들인다.
+# 보완: 순증마다 **총량과 베이스라인 대비 델타를 출력**한다 — 그건 자기신고가 아니라
+# 측정이라 게임이 안 되고, 추가하는 그 순간에 보인다.
+#
+# ── 🔒 사전등록 (이 게이트가 값을 냈는지 나중에 채점하기 위해, 배선 **전에** 적는다) ──
+# 가설: 이 게이트는 상주 유입을 줄인다.
+# 채점: 배선일로부터 30일간 CLAUDE.md 순증 bytes/day 를 직전 31일(2026-07-20~08-20)의
+#       **2,367 bytes/day** 와 대조한다. 베이스라인 144,138 @ 2026-08-20.
+# 🟥 사전등록 없이 나중에 «줄어든 것 같다» 로 채점하면 07-20 의 「11.9% 감량」과 같은 종류의
+#    숫자가 하나 더 생긴다 — 그 숫자는 한 달 뒤 2.1배로 반증됐다.
+# 🟥 **정직한 기대값은 «유입 차단» 이 아니라 «유입에 이름이 붙는다» 이다** (peer 재프레이밍).
+#    형식 검사는 침묵을 잡지 위조를 못 잡고, 저자는 압박받으면 `soul` 을 고른다
+#    (`crossfamily:` 가 이미 거짓 값이 레인을 통과한 실측을 갖고 있다).
+#    이름이 붙는 것만으로도 값이 있다 — **다음 감량이 무엇을 지울지 고를 수 있게 된다.**
+#
+# ── 손 캘리브레이션 (enum 이 실물에서 실제로 가르는가 · 2026-08-20) ──
+# 게이트는 기록을 보지 내용을 판정하지 않으므로, enum 의 판별력은 **손으로** 잰다.
+# 최근 5일 최대 유입 둘에 적용했더니 **서로 다른 답**이 나왔다:
+#   §Mechanization Boundary (10,157 B) → `soul`        — 「기계는 비가역 경계에만, 판단은
+#                                                        진화에」는 판단 좌표계다. 상주 정당
+#   §Expedition (5,748 B)              → `relocatable(knowledge/shared/rules/operations.md)`
+#                                        — 캐던스 절차 + 실측 이력. §Cadence Rules 가 이미 거기 있다
+# ⇒ 실물 두 건이 갈렸다. 같은 답만 나왔으면 이 enum 은 판별력이 0 이다.
+#
+# exit 0 = 통과(감량·무변경 포함) · 1 = 차단 · 2 = 하네스 오류(PASS 아님)
+
+set -uo pipefail
+
+RESIDENT_FILE="CLAUDE.md"
+BASELINE_BYTES=144138
+BASELINE_DATE="2026-08-20"
+# 🟥 사람이 읽는 출력은 enum 을 뱉지 않는다. 기계 어휘는 기계 안에만 둔다 —
+#    사용자가 우리 용어를 배우게 만들면 그 게이트는 이식 후 통과 불가가 된다
+#    (`count_check.sh:94-106` 이 같은 법칙을 README 렌더링에서 이미 실측했다).
+VALID="soul irreversible-gate disambiguator pointer relocatable"
+
+# 🟥 루트는 **스크립트 위치가 아니라 검사 대상 레포**다. 초판은 `dirname $0/..` 를 썼는데,
+#    소비자 설치에서 그건 `node_modules/@chrono-meta/fh-gate` 라 **소비자 레포의 CLAUDE.md 가
+#    아니라 패키지 안의 우리 CLAUDE.md** 를 검사한다. 정적으로 읽을 땐 안 보였고,
+#    팩을 풀어 돌려서 나왔다(§Local Execution First — 실행이 하중선인 이유).
+#    호출자(pre-commit)가 $1 로 레포 루트를 준다. 없으면 git 에게 묻는다.
+ROOT="${1:-}"
+if [ -z "$ROOT" ]; then
+  ROOT=$(git rev-parse --show-toplevel 2>/dev/null) || ROOT=""
+fi
+# ── 적용 가능성 판정 (🟥 «구조적으로 해당 없음» 과 «도구가 없음» 을 같은 값으로 접지 않는다) ──
+if [ -z "$ROOT" ]; then
+  echo "  SKIP  상주 유입 게이트 — git 레포가 아니다 (적용 대상 없음, 통과가 아니라 해당 없음)"
+  exit 0
+fi
+if [ ! -f "$ROOT/$RESIDENT_FILE" ]; then
+  echo "  SKIP  상주 유입 게이트 — 이 레포에 $RESIDENT_FILE 이 없다 (적용 대상 없음)"
+  exit 0
+fi
+
+# ── 순증 계산: 스테이징된 변경만 본다 ────────────────────────────────────────
+diffstat=$(git -C "$ROOT" diff --cached --numstat -- "$RESIDENT_FILE" 2>/dev/null)
+rc=$?
+[ "$rc" -ne 0 ] && { echo "❌ HARNESS ERROR: git diff 실패 (rc=$rc) — 미측정이지 통과 아님" >&2; exit 2; }
+[ -z "$diffstat" ] && exit 0                      # 이 커밋은 상주를 안 건드린다
+
+ins=$(printf '%s' "$diffstat" | awk '{print $1}')
+del=$(printf '%s' "$diffstat" | awk '{print $2}')
+case "$ins$del" in *-*) echo "ℹ️  $RESIDENT_FILE 이 바이너리로 보고됨 — 판정 불가"; exit 2 ;; esac
+net=$(( ins - del ))
+
+cur=$(wc -c < "$ROOT/$RESIDENT_FILE" | tr -d ' ')
+# 🟥 베이스라인은 **FH 자신의** CLAUDE.md 기준이다. 다른 레포에서 델타를 찍으면 남의 파일을
+#    우리 숫자로 재는 것이라 무의미하다 — 소비 레포에선 총량만 말한다.
+if [ "$cur" -lt $(( BASELINE_BYTES / 4 )) ] || [ "$cur" -gt $(( BASELINE_BYTES * 4 )) ]; then
+  printf '  상주 규모: %s bytes (이 레포 기준 · FH 베이스라인과 스케일이 달라 델타는 생략)\n' "$cur"
+  BASELINE_BYTES=0
+fi
+delta=$(( cur - BASELINE_BYTES ))
+if [ "$BASELINE_BYTES" -gt 0 ]; then pct=$(( delta * 1000 / BASELINE_BYTES )); else pct=0; fi
+if [ "$BASELINE_BYTES" -gt 0 ]; then
+  printf '  상주 규모: %s bytes (기준 %s @ %s · %+d, %+d.%d%%)\n' \
+    "$cur" "$BASELINE_BYTES" "$BASELINE_DATE" "$delta" "$((pct/10))" "$((pct%10<0?-pct%10:pct%10))"
+fi
+
+if [ "$net" -le 0 ]; then
+  echo "  ✅ 상주 순증 없음 (+$ins/-$del 줄) — 유입 게이트 해당 없음"
+  exit 0
+fi
+
+# ── 순증이다. 마커에 유형 선언이 있어야 한다 ─────────────────────────────────
+# 🟥 단, **이 레포가 4축 마커 체제를 돌릴 때만** 그렇다. 마커 디렉터리 자체가 없으면
+#    그건 소비 레포이고, 거기서 마커를 요구하면 **이식 이후 한 번도 통과 못 하는 검사**가 된다
+#    — 통과 불가능한 게이트는 게이트가 아니라 `--no-verify` 훈련기다
+#    (`count_check.sh:94-106` 이 README 렌더링에서 이미 실측한 법칙).
+#    소비자 트리 ARM 3 실행이 이걸 냈다: 소비자가 자기 CLAUDE.md 를 늘리자 rc=2 로 막혔다.
+if [ ! -d "$ROOT/tracks/_meta" ]; then
+  echo "  SKIP  상주 유입 게이트 — 이 레포는 4축 마커 체제를 안 돌린다 (적용 대상 없음)"
+  echo "        (순증 +$net 줄은 봤다. 판정하지 않는 이유는 마커 디렉터리 부재다)"
+  exit 0
+fi
+
+today=$(date +%Y-%m-%d)
+marker=$(ls -t "$ROOT"/tracks/_meta/.axes_23_passed_*_"$today".marker 2>/dev/null | head -1)
+if [ -z "$marker" ]; then
+  cat >&2 <<MSG
+❌ 상주 순증(+$net 줄)인데 오늘자 마커가 없다.
+   이 검사는 마커 위에 얹힌다 — 4축 마커를 먼저 쓴 다음 다시 커밋해라.
+MSG
+  exit 2
+fi
+
+line=$(grep -E '^residency:' "$marker" | head -1)
+if [ -z "$line" ]; then
+  cat >&2 <<MSG
+❌ $RESIDENT_FILE 이 +$net 줄 늘었는데, 그게 왜 **항상 로드되어야 하는지**가 안 적혀 있다.
+
+   늘어난 내용이 다음 중 무엇인가? 마커에 한 줄 적어라 — 근거를 같이.
+     · 판단 회로다 (무엇이 성공 · 어디로 기움 · 절대 안 함)      → residency: soul — <근거>
+     · 비가역 경계에서 발화해야 한다 (출하·삭제·이력 재작성)      → residency: irreversible-gate — <근거>
+     · 특정 오독 하나를 막는 줄이다                               → residency: disambiguator — <무엇을 막나>
+     · 상세로 보내는 포인터다                                     → residency: pointer — <어디로>
+     · 🟥 사실 다른 파일로 갈 수 있는 내용이다                     → residency: relocatable(<경로>)
+       (목적지를 적으면 이 커밋은 막힌다 — 거기로 옮기고 여기엔 포인터만 남겨라)
+
+   왜 묻나: 07-20 감량 이후 31일간 +73,380 bytes (약 2,367/일). 같은 기간 어블레이션이
+   낸 CUT 판정은 0건이다. 나가는 문은 사실상 닫혀 있으므로 들어오는 문에서 정한다.
+MSG
+  exit 1
+fi
+
+# 🟥 구분자는 «em-dash» 또는 «공백-하이픈-공백» 이다. 맨하이픈으로 자르면
+#    `detail-belongs-elsewhere` 가 `detail` 로 잘린다 — 되돌림 프로브가 이걸 잡았다
+#    (그 전까지 그 레인은 «못 알아듣는 값» 으로 **우연히** 초록이었다).
+val=$(printf '%s' "$line" | sed -E 's/^residency:[[:space:]]*//; s/[[:space:]]*—.*$//; s/[[:space:]]+-[[:space:]].*$//' | tr -d ' ')
+grounds=$(printf '%s' "$line" | sed -E 's/^residency:[^—]*—[[:space:]]*//; s/^residency:[^-]*[[:space:]]-[[:space:]]//')
+
+# 🟥 `relocatable(<경로>)` 는 **매개변수를 갖는다** — 정확 일치로만 보면 정상 사용이
+#    «못 알아듣는 값» 으로 막히고 자기 브랜치는 죽은 코드가 된다(되돌림 프로브가 지목).
+ok=0; for v in $VALID; do
+  case "$val" in "$v") ok=1 ;; "$v"'('*')') ok=1 ;; esac
+done
+if [ "$ok" -ne 1 ]; then
+  echo "❌ 마커의 residency 값 '$val' 을 못 알아듣는다. 위 다섯 중 하나로 적어라." >&2
+  exit 1
+fi
+
+case "$val" in
+  relocatable*)
+    dest=$(printf '%s' "$val" | sed -E 's/^relocatable\(?//; s/\)$//')
+    if [ -z "$dest" ] || [ "$dest" = "relocatable" ]; then
+      echo "❌ 옮길 곳을 안 적었다. 어느 파일로 가야 하나 — 경로를 괄호 안에 적어라." >&2
+      exit 1
+    fi
+    cat >&2 <<MSG
+🟥 저자가 «이건 $dest 로 갈 수 있다» 고 적었는데 상주가 +$net 줄 늘었다. 둘이 안 맞는다.
+   $dest 로 옮기고 $RESIDENT_FILE 엔 **명령형 포인터 한 줄**만 남겨라.
+MSG
+    exit 1 ;;
+esac
+
+if [ "${#grounds}" -lt 12 ] || [ "$grounds" = "$line" ]; then
+  echo "❌ residency: $val 인데 근거가 비었다. '— ' 뒤에 왜 상주여야 하는지 한 줄." >&2
+  exit 1
+fi
+
+# ── soul 흡수구 완충 (advisory · 절대 차단하지 않는다) ──────────────────────
+# peer 지적: 「판단 좌표계」는 저자가 자기 델타에 거의 항상 붙일 수 있는 라벨이라
+# `soul` 이 기본 흡수구가 된다. 🟥 게이트는 마커를 읽지 내용을 안 읽으므로 이건
+# **기계로 판정할 수 없다** — 픽스처를 만들어도 그냥 통과한다.
+# 대신 **재서 보여준다**: 추가된 줄의 «근거 표지»(날짜·실측·n=·반증·런 #) 밀도.
+# 캘리브레이션 실물 2점 (.claude/regression/fixtures/):
+#     §Mechanization Boundary → soul        근거표지  3%
+#     §Expedition             → relocatable 근거표지 16%
+# 🟥 **n=2 다. 판정에 쓰지 않는다** — 중점 10% 를 넘으면 한 줄 묻기만 한다.
+if [ "$val" = "soul" ]; then
+  addl=$(git -C "$ROOT" diff --cached -- "$RESIDENT_FILE" | grep -c '^+[^+]' 2>/dev/null)
+  provl=$(git -C "$ROOT" diff --cached -- "$RESIDENT_FILE" \
+          | grep '^+[^+]' \
+          | grep -cE '[0-9]{4}-[0-9]{2}-[0-9]{2}|실측|측정|n=[0-9]|반증|런 #[0-9]|PR #[0-9]' 2>/dev/null)
+  if [ "${addl:-0}" -gt 0 ]; then
+    d=$(( provl * 100 / addl ))
+    if [ "$d" -ge 10 ]; then
+      echo "  ⚠️ soul 로 선언했는데 추가분의 ${d}% 가 근거 서술이다(날짜·실측·n=)."
+      echo "     판단 좌표계가 맞나, 아니면 근거는 signal 로 보내고 결론 한 줄만 남길 수 있나?"
+      echo "     (참고 2점: 판단 좌표계 3%% · 이관 대상 16%%. n=2 — 판정 아니라 물음이다)"
+    fi
+  fi
+fi
+
+echo "  ✅ 상주 순증 +$net 줄 · 유형 선언됨 ($val)"
+exit 0

package/scripts/selfcheck.sh

@@ -416,6 +416,20 @@ else
   _absent_subject_verdict "test_adapter_lanes.sh" "scripts/test_adapter_lanes.sh" || fail=1
 fi
 
+# track→repo 해석기 단일화 레인 (2026-08-21 harness-doctor F-1).
+# 🟥 배선이 없으면 이 레인은 «만들고 배선 안 함» 이 된다. 그리고 이 수리는 특히 그 위험이 크다 —
+# 세 소비자가 전부 npm 으로 나가므로, 라이브러리가 files[] 나 selfcheck 어느 한쪽에서 빠지면
+# 소비자 install 에서만 조용히 수리 이전 동작으로 강등된다(로컬은 초록).
+if [ ! -f scripts/fh_track_resolve.sh ]; then
+  _absent_subject_verdict "test_track_resolve_lanes.sh" "scripts/fh_track_resolve.sh" || fail=1
+elif [ -f scripts/test_track_resolve_lanes.sh ]; then
+  if ! bash scripts/test_track_resolve_lanes.sh; then
+    fail=1
+  fi
+else
+  _absent_subject_verdict "test_track_resolve_lanes.sh" "scripts/test_track_resolve_lanes.sh" || fail=1
+fi
+
 if [ ! -f scripts/package_coverage_check.sh ]; then
   _absent_subject_verdict "test_package_coverage_lanes.sh" "scripts/package_coverage_check.sh" || fail=1
 elif [ -f scripts/test_package_coverage_lanes.sh ]; then
@@ -530,6 +544,7 @@ for _pair in \
   ".github/workflows/regression-guard.yml|scripts/test_regression_guard_ci_lanes.sh" \
   "templates/.git-hooks/pre-commit|scripts/test_marker_standpoint_lanes.sh" \
   "templates/.git-hooks/pre-commit|scripts/test_marker_thirdparty_lanes.sh" \
+  "templates/.git-hooks/pre-commit|scripts/test_marker_soul_check_lanes.sh" \
   "scripts/residency_closure_scan.py|scripts/test_residency_closure_lanes.sh" \
   "scripts/reviewer_capability_corpus.tsv|scripts/test_reviewer_capability_conformance.sh" \
   "scripts/field_canon_preload.sh|scripts/test_field_canon_lanes.sh" \
@@ -703,6 +718,37 @@ else
   fail=1
 fi
 
+# test_marker_defense_lanes — Wave 1-D 방어줄(`axis2-defense:`)의 known-pair (2026-08-20).
+# 🟥 이 레인이 존재하는 이유 자체가 기록이다: 절차를 흡수해온 sibling 문서가 «훅이 이 줄을 읽는다»·
+#    «marker_floor 레인이 핀한다» 고 적었는데 **둘 다 0 히트**였다(컨트롤 crossfamily 21).
+#    산문은 이식됐고 기계는 안 왔다. 그래서 FH 가 짓는다 — 우리가 그 주장을 할 땐 참이도록.
+if [ ! -f scripts/test_marker_defense_lanes.sh ]; then
+  echo "FAIL  test_marker_defense_lanes.sh: missing — axis2-defense 레인에 앵커 없음"
+  fail=1
+elif _out=$(bash scripts/test_marker_defense_lanes.sh < /dev/null 2>&1); then
+  echo "PASS  test_marker_defense_lanes.sh ($(printf '%s\n' "$_out" | grep -oE '[0-9]+ lanes hold' | tail -1))"
+else
+  echo "FAIL  test_marker_defense_lanes.sh: 방어줄 검증이 바뀌었다"
+  _show_failure "$_out"
+  fail=1
+fi
+
+# test_heavy_classifier_lanes — 4축 게이트의 **라우팅 판별자**에 대한 known-pair (2026-08-20).
+# 🟥 이 분류기가 놓치는 경로는 FAIL 하지 않는다 — 게이트가 **조용히 적용되지 않고** 커밋이
+#    초록으로 나간다. 가장 조용한 실패 형태이고, 실측상 이걸 시험하는 레인이 **0개**였다
+#    (컨트롤: 훅을 언급하는 test_*.sh 는 12개). sibling harness 에서 흡수했고, 핵심은
+#    픽스처 목록이 아니라 **훅에서 정규식을 실시간 추출**하는 설계다(픽스처가 대상에서 안 떨어진다).
+if [ ! -f scripts/test_heavy_classifier_lanes.sh ]; then
+  echo "FAIL  test_heavy_classifier_lanes.sh: missing — 게이트 라우팅 판별자에 앵커 없음"
+  fail=1
+elif _out=$(bash scripts/test_heavy_classifier_lanes.sh < /dev/null 2>&1); then
+  echo "PASS  test_heavy_classifier_lanes.sh (4-way routing known-pair + fail-closed extraction)"
+else
+  echo "FAIL  test_heavy_classifier_lanes.sh: 게이트 라우팅이 바뀌었다"
+  _show_failure "$_out"
+  fail=1
+fi
+
 # test_satellite_publish_gate_lanes — 위성 공개표면 게이트(2026-08-18, 원정 2차).
 # 🟥 이 배선이 없어서 CI 가 `lane-runner: lane suite(s) with no runner and no declaration` 로
 # 빨갰다. 스위트를 신설하고 아무 데서도 안 돌린 것 — 검사기의 표현대로
@@ -1018,6 +1064,22 @@ else
   fail=1
 fi
 
+# residency_admission — 같은 형태. 🟥 그리고 **또 같은 얼굴이었다**: 2026-08-20 에 이 레인을
+# 지으면서 여기 배선을 안 했고, `lane-runner` 가 «돌리는 게 없는 스위트는 산문이다» 로 CI 에서
+# 잡았다. 아래 target_freeze 주석이 기록한 그 형태의 **최소 세 번째**다 — 즉 이건 개인 부주의가
+# 아니라 «레인을 짓는 사람이 배선 지점을 안 본다» 는 구조적 순서 문제다.
+if [ ! -f scripts/residency_admission_check.sh ]; then
+  echo "FAIL  scripts/residency_admission_check.sh is wired into pre-commit but absent — a deleted subject, not a skip"
+  fail=1
+elif [ -f scripts/test_residency_admission_lanes.sh ]; then
+  if ! bash scripts/test_residency_admission_lanes.sh; then
+    fail=1
+  fi
+else
+  echo "FAIL  test_residency_admission_lanes.sh: residency_admission_check.sh present but its anchor is missing"
+  fail=1
+fi
+
 # target_freeze — 같은 형태(shipped subject + 자기 앵커). 🟥 이 블록이 없어서 `lane-runner`
 # 검사가 «돌리는 게 없는 스위트는 산문이다» 로 정확히 걸었다. 지은 사람이 자기 레인을 안
 # 배선한 것이고, 오늘 이 세션이 남의 코드에서 네 번 잡은 그 얼굴이다.
@@ -1200,6 +1262,32 @@ else
   fail=1
 fi
 
+# prior-art prompt (T2) — 새 메커니즘을 쓰기 직전 «내부·외부·숙고» 를 모델 컨텍스트에 넣는 훅.
+# 레인의 다수가 **음성**이다: 이 훅의 사활은 막는 것이 아니라 소음이 아닌 것이다.
+if [ ! -f scripts/prior_art_prompt.sh ]; then
+  _absent_subject_verdict "test_prior_art_prompt_lanes.sh" "scripts/prior_art_prompt.sh" || fail=1
+elif [ -f scripts/test_prior_art_prompt_lanes.sh ]; then
+  if ! bash scripts/test_prior_art_prompt_lanes.sh; then
+    fail=1
+  fi
+else
+  echo "FAIL  test_prior_art_prompt_lanes.sh: prior_art_prompt.sh present but its anchor is missing"
+  fail=1
+fi
+
+# outbound-query 위생 린트 — 나가는 질의에 내부 토큰이 실렸는지. 레인이 이 가드의 fail-closed
+# 분기 4개(라이브러리 부재·defaults 부재·override 부재·상태값 오염)에 각각 짝을 갖는다.
+if [ ! -f scripts/outbound_query_guard.sh ]; then
+  _absent_subject_verdict "test_outbound_query_lanes.sh" "scripts/outbound_query_guard.sh" || fail=1
+elif [ -f scripts/test_outbound_query_lanes.sh ]; then
+  if ! bash scripts/test_outbound_query_lanes.sh; then
+    fail=1
+  fi
+else
+  echo "FAIL  test_outbound_query_lanes.sh: outbound_query_guard.sh present but its anchor is missing"
+  fail=1
+fi
+
 if [ ! -f scripts/pipe_verdict_guard.sh ]; then
   _absent_subject_verdict "test_pipe_verdict_guard_lanes.sh" "scripts/pipe_verdict_guard.sh" || fail=1
 elif [ -f scripts/test_pipe_verdict_guard_lanes.sh ]; then

package/scripts/test_adapter_lanes.sh

@@ -268,6 +268,71 @@ echo
 #        부재로 HARNESS_ERROR(3) 를 낸다 — 기대값과 같은 값이다. 즉 R2 는 Q5 를 원리적으로
 #        구분하지 못한다. 그건 Q5 의 결함이 아니라 **이 프로브 축의 사각지대**이고,
 #        Q5 는 R1 이 아니라 별도 축(모호 판정 자체를 지우는 중화)으로만 흔들 수 있다.
+# ── P 레인: peer_resolve 자체의 이름 해석 (2026-08-21 신설) ─────────────────────
+# 🟥 이게 왜 필요한가: `peer_resolve.sh` 의 `FH_PROJECTS_HOME` 팔을 `fh_track_resolve.sh` 로
+#    배선하면서 **거짓 AMBIGUOUS 결함이 하나 닫혔는데, 그 변경을 되돌려도 빨개지는 레인이
+#    0개였다**(실측). 즉 기존 31 레인은 이 축에 대해 앵커가 아니다 —
+#    [[feedback_anchor_can_be_decorative]]. 픽스처는 **실제로 뚫려 있던 표기**(공백 이름)를 쓴다.
+#
+# 🟥 **초판 P 레인은 거짓 초록이었다 — 계기가 대상을 안 불렀다.** `peer_resolve.sh` 를
+#    `bash <파일> <이름>` 으로 «실행» 했는데 이 파일은 **sourced 라이브러리**라 실행하면
+#    아무것도 안 하고 rc=0 으로 끝난다. P1·P3 이 그 rc=0 을 «해소 성공» 으로 읽어 초록이었고,
+#    P2 의 빨강도 코드 결함이 아니라 내 하네스 결함이었다. 판별 근거는 **HEAD 에서도 같은
+#    값이 나왔다**는 것이다(변경 전후가 같으면 계기가 대상을 안 보고 있다).
+#    [[feedback_instrument_vs_target_and_budget]] — 이상하면 대상보다 계기를 먼저 의심해라.
+_PR="${FH_ADAPTER_DIR:-$REPO_ROOT/scripts/adapters}/peer_resolve.sh"
+if [ ! -f "$_PR" ]; then
+  echo "  SKIP P 레인 (peer_resolve.sh 없음) — PASS 가 아니라 미검사다"
+else
+  # shellcheck source=scripts/adapters/peer_resolve.sh
+  . "$_PR"
+  if ! type fh_peer_resolve >/dev/null 2>&1; then
+    echo "  ❌ P 레인 하네스 결함 — source 했는데 fh_peer_resolve 가 없다"
+    FAIL=1
+  else
+  _PW="$(mktemp -d)"
+  mkdir -p "$_PW/sp ace" "$_PW/aliased-dev" "$_PW/dual" "$_PW/dual-dev"
+  # P0 컨트롤 — 계기가 대상을 실제로 부르는가. 이게 초록이 아니면 아래 셋은 의미가 없다.
+  FH_PROJECTS_HOME="$_PW" fh_peer_resolve nosuchpeer >/dev/null 2>&1; _prc=$?
+  _lane P0 control "계기 생존 — 없는 peer 는 부재(1)로 온다(rc=0 무음이면 대상을 안 부른 것)" 1 "$_prc"
+  # P1 — 공백 이름 1건: 한 후보가 두 단어로 세어져 거짓 AMBIGUOUS(2) 가 나던 자리
+  FH_PROJECTS_HOME="$_PW" fh_peer_resolve 'sp ace' >/dev/null 2>&1; _prc=$?
+  _lane P1 resolve-guard "공백 이름 1건은 정상 해소 — 거짓 AMBIGUOUS 아님" 0 "$_prc"
+  # P2 컨트롤 — 진짜 모호는 여전히 거부해야 한다(P1 의 통과가 모호검출을 죽인 게 아니다)
+  FH_PROJECTS_HOME="$_PW" fh_peer_resolve dual >/dev/null 2>&1; _prc=$?
+  _lane P2 control "진짜 모호(dual + dual-dev)는 여전히 고르지 않는다" 2 "$_prc"
+  # P3 컨트롤 — 별칭 해소가 실제로 살아 있나(P 레인이 통째로 공허하지 않다는 증거)
+  FH_PROJECTS_HOME="$_PW" fh_peer_resolve aliased >/dev/null 2>&1; _prc=$?
+  _lane P3 resolve-alias "'-dev' 별칭이 해소된다" 0 "$_prc"
+  rm -rf "$_PW"
+  fi
+fi
+# 🟥 **명시 잔여 — 팔 A 는 안 닫혔다.** `FH_CLUSTER_ROOTS`(임의 절대경로의 basename 조회)는
+#    조회 모델이 달라 라이브러리로 통일하지 않았고, 거기 공백 거짓-AMBIGUOUS 가 **그대로 있다**
+#    (실측 확인). 별도 축의 독립 수리이므로 레인을 안 박았다 — 안 잰 것이지 통과한 게 아니다.
+
+# 🟥 **2026-08-21 — 사전등록 두 줄을 갱신했다. 이유를 적는 게 갱신 자체보다 중요하다.**
+#    (위 규율 그대로: 관측에 맞춰 «조용히» 고치면 프로브의 판별력 증거가 사라진다.)
+#      · **R1: `G1 G5 M1 Q1` → `G1 G5 M1 Q1 W1`** — **선재 오류**다. 사전등록이 `qasp_web_rules.sh`
+#        (W 레인) 도입 **이전**에 쓰였고, W1 도 부재 분기에 결박된 레인이라 빨간 게 맞다.
+#        내 변경 이전 HEAD 에서도 `--revert-probe` 는 이 차이로 RC=1 이었다(실측). 즉 이건
+#        내가 깬 게 아니라 **이미 틀려 있던 것을 이번에 갚는 것**이다.
+#      · **R2: 11개 → `M4 Q4 Q7 Q8`** — 이건 **내 변경이 원인**이고, 기대값을 낮추는 것으로
+#        끝내면 안 된다. `peer_resolve.sh` 의 `FH_PROJECTS_HOME` 팔이 이제 별칭을
+#        `fh_track_resolve.sh` 에서 받으므로 **`fh_peer_alias_candidates` 를 안 읽는다** →
+#        그걸 중화해도 안 흔들린다. 남은 넷은 전부 `FH_CLUSTER_ROOTS`(팔 A) 레인이다.
+#        🟥 **명시 잔여 — 커버리지가 줄었다**: R2 는 더 이상 «팔 B 가 별칭을 보는가» 를
+#        흔들지 못한다. 그 축의 앵커는 지금 `scripts/test_track_resolve_lanes.sh`(라이브러리
+#        레인 1~3 + 배선 레인 9)에만 있고, **어댑터 층에는 없다.** 팔 A 는 조회 모델이 달라
+#        (임의 절대경로의 basename) 통일하지 않았으므로 R2 는 그대로 유효하다.
+#        이 잔여를 닫으려면 라이브러리를 중화하는 별도 프로브 축(R3)이 필요하고,
+#        지금 프로브는 `scripts/adapters/` 만 사본으로 뜨므로 **그 축은 아직 없다.**
+#      · **P 레인 추가분(같은 날, 2차)**: `P0 P1` 이 R1 에, `P1` 이 R2 에 들어간다. 사전등록을
+#        P 레인 **추가 전에** 썼기 때문에 빠져 있었다. 기계적 설명: R1 은 부재 분기를 «순진한
+#        추측» 으로 바꾸므로 P0(없는 peer → rc=1 이어야 한다)이 rc=0 을 받아 빨개지고, P1 도
+#        그 조기 반환에 걸린다. R2 는 별칭 후보를 이름 하나로 줄이므로 P1(공백 이름 해소)이
+#        후보 루프를 못 탄다. 🟥 **둘 다 «레인이 그 중화에 실제로 반응한다»는 뜻이라 빨간 게
+#        맞다** — 이 갱신은 기대를 낮추는 게 아니라 **새 앵커를 사전등록에 등록하는 것**이다.
 # ★중화는 **실물 파일이 아니라 사본**에 건다(FH_ADAPTER_DIR). 실물 트리를 건드리지 않고,
 #  사본이 실물과 «중화한 줄 말고는 동일» 함을 적용확인 단계에서 대조한다.
 _revert_probe() {
@@ -317,14 +382,14 @@ case "${1:-}" in
     _revert_probe R1 \
       's|^    printf .peer-resolve: peer|    printf "%s" "${FH_PROJECTS_HOME:-$HOME/projects}/$n"; return 0  # NEUTRALIZED_R1\n    printf '"'"'peer-resolve: peer|' \
       'NEUTRALIZED_R1' \
-      'G1 G5 M1 Q1' \
+      'G1 G5 M1 P0 P1 Q1 W1' \
       '«부재» 분기 중화 → 부재 분기에 결박된 레인만 빨개져야 한다' || RP=1
     echo
     # R2: 별칭 후보를 이름 자신 하나로 줄인다 — `-dev` 를 못 찾게 된다.
     _revert_probe R2 \
       's|^  printf .%s\\n. "\$1" "\$1-dev".*$|  printf "%s\\n" "$1"   # NEUTRALIZED_R2|' \
       'NEUTRALIZED_R2' \
-      'M2 M3 M4 M5 M6 Q2 Q3 Q4 Q6 Q7 Q8' \
+      'M4 P1 Q4 Q7 Q8' \
       '별칭 목록 중화 → mate/qasp 쪽 레인만 빨개져야 한다(gstack 은 별칭이 필요 없다)' || RP=1
     echo
     [ "$RP" -eq 0 ] || FAIL=1

package/scripts/test_heavy_classifier_lanes.sh

@@ -0,0 +1,144 @@
+#!/usr/bin/env bash
+# test_heavy_classifier_lanes.sh — known-pair anchor for the pre-commit HEAVY/LIGHT path classifier.
+#
+# WHY: the classifier is three `grep -E` lines, and everything downstream of it — Axes 2+3, the
+# marker, the whole full-gate path — is gated on what they match. A term missing from those lines
+# does not FAIL; it makes the gate **silently not apply**, and the commit goes green. There is no
+# 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.
+#
+# 🟥 FH's classifier is FOUR-WAY, not two-way like the sibling's. The port is not a copy:
+#     HEAVY     → full gate
+#     CARVEOUT  → knowledge/ · docs/*.md · AGENTS.md — promoted to HEAVY only if the diff is
+#                 substantive (adds a fenced block or a citation), else demoted to LIGHT
+#     LIGHT     → CATALOG.md · tracks/
+#     uncovered → matches none of the three. **This class is real and is pinned below** — a path
+#                 nobody classified is the quietest way for a surface to leave the gate.
+#
+# This lane pins all four directions. Over-matching is a defect too: a gate that fires on every
+# commit is the one people learn to bypass with `--no-verify`, which disarms the Destructive-Op
+# gate living in the same hook.
+#
+# Usage: bash scripts/test_heavy_classifier_lanes.sh   → exit 0 if all pairs hold, 1 otherwise.
+set -uo pipefail
+
+REPO_ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+HOOK="$REPO_ROOT/templates/.git-hooks/pre-commit"
+[ -r "$HOOK" ] || { echo "❌ FAIL — $HOOK not readable"; exit 1; }
+
+FAILED=0
+
+# Extract the LIVE regexes from the hook rather than restating them. A lane that hard-codes its own
+# copy of the pattern passes forever while the real classifier drifts away underneath it — that is
+# testing the fixture instead of the subject, and it is the failure this whole file exists to catch.
+_extract() { # $1 = variable name as it appears at column 0 in the hook
+  sed -n "/^$1=\\\$(echo \"\\\$STAGED\"/,/|| true)/p" "$HOOK" \
+    | grep -o 'grep -E "[^"]*"' | head -1 | sed 's/^grep -E "//; s/"$//'
+}
+HEAVY_RE=$(_extract HEAVY)
+CARVE_RE=$(_extract CARVEOUT)
+LIGHT_RE=$(_extract LIGHT)
+
+# 🟥 Fail CLOSED on extraction failure. An empty regex makes `grep -qE ""` match EVERYTHING, so a
+# silent extraction failure would turn this lane green while classifying every path as heavy.
+for v in HEAVY_RE CARVE_RE LIGHT_RE; do
+  if [ -z "${!v}" ]; then
+    echo "❌ FAIL — could not extract \$$v from the hook."
+    echo "   The hook's shape changed. Fix THIS extraction — do not delete the lane, and do not"
+    echo "   inline a copy of the pattern here (that is how a lane stops covering its subject)."
+    exit 1
+  fi
+done
+
+classify() { # <path> → heavy | carveout | light | uncovered
+  # Order mirrors the hook: HEAVY wins, then CARVEOUT (which the hook excludes
+  # knowledge/shared/rules/ from, since that is already HEAVY), then LIGHT.
+  if printf '%s\n' "$1" | grep -qE "$HEAVY_RE"; then echo heavy
+  elif printf '%s\n' "$1" | grep -qE "$CARVE_RE"; then echo carveout
+  elif printf '%s\n' "$1" | grep -qE "$LIGHT_RE"; then echo light
+  else echo uncovered; fi
+}
+
+check() { # <expect> <path> <why>
+  local expect="$1" path="$2" why="$3" got
+  got=$(classify "$path")
+  if [ "$got" = "$expect" ]; then
+    printf '  ✅ %-9s %-52s %s\n' "$expect" "$path" "$why"
+  else
+    printf '  ❌ %-9s %-52s expected %s, got %s\n' "$expect" "$path" "$expect" "$got"
+    FAILED=1
+  fi
+}
+
+echo "[heavy-classifier] known-pair anchor (4-way)"
+echo "  ── must be HEAVY (full 4-axis gate applies) ──"
+check heavy "plugins/fh-meta/skills/steel-quench/SKILL.md"        "skill spec"
+check heavy "plugins/fh-meta/skills/goal-quench/SKILL_detail.md"  "detail file — the salience-split half"
+check heavy "plugins/fh-meta/skills/fh/assets/note.md"            "any md under a skill dir"
+check heavy "plugins/fh-meta/agents/challenger.md"                "agent definition"
+check heavy ".claude/agents/local.md"                             "repo-local agent definition"
+check heavy ".claude/rules/fh_4axis_gate.md"                      "gate rule"
+check heavy "knowledge/shared/rules/operations.md"                "shared rules — HEAVY, not carveout"
+check heavy "templates/.git-hooks/pre-commit"                     "the gate machinery itself"
+check heavy "templates/CLAUDE.md"                                 "propagated field asset"
+check heavy "CLAUDE.md"                                           "the resident layer"
+check heavy "scripts/selfcheck.sh"                                "shipped executable"
+check heavy "scripts/adapters/qasp_web_rules.sh"                  "nested script still matches"
+
+echo "  ── CARVEOUT (heavy only if the diff is substantive) ──"
+check carveout "knowledge/shared/harness-core/sonnet_floor_doctrine.md" "doctrine prose"
+check carveout "docs/USER_GUIDE.md"                                    "published guide"
+check carveout "AGENTS.md"                                             "Codex entry point"
+
+echo "  ── must stay LIGHT (over-firing trains --no-verify) ──"
+check light "CATALOG.md"                     "index entry"
+check light "tracks/_meta/fh_completed.md"   "session record"
+check light "tracks/qasp/NEXT_ACTION.md"     "field track record"
+
+echo "  ── honestly UNCOVERED — pinned so the residual cannot be believed closed ──"
+check uncovered "README.md"                  "🟥 a README-only commit takes NO 4-axis path"
+check uncovered "package.json"               "files[] / version changes are unclassified"
+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"
+
+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 "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
+#    subject — pick a path outside every class when the claim is "matches none of them".
+
+# 🟥 KNOWN OVER-MATCH, pinned deliberately as `heavy` rather than "fixed" (2026-08-20).
+# `SKILL(_detail)?\.md` is written WITHOUT a `$` anchor, so any path merely CONTAINING that
+# substring classifies HEAVY — `SKILL.md.bak`, `SKILL.md.orig`, `SKILL.md~`. Recorded, not
+# repaired, for three reasons, and the reasons are the point:
+#   ⓐ the error direction is fail-SAFE — it adds gate coverage, never removes it. The classifier's
+#     dangerous direction is under-matching (the gate silently not applying), which this is not.
+#   ⓑ those paths are not committed in practice, so the over-block the hook warns about
+#     ("a gate that always fires is the one people learn to bypass") does not actually fire here.
+#   ⓒ anchoring it is a live change to gate routing, and gate routing is exactly what this lane
+#     exists to detect changes in. Changing the subject in the same commit that first measures it
+#     leaves no before-state.
+# This row is therefore a RECORD, not an endorsement: if someone anchors the pattern later, this
+# line goes red and they will read this comment — which is the whole job of a known-pair.
+check heavy "docs/skills/SKILL.md.bak"       "🟥 over-match: pattern is unanchored (see comment)"
+
+echo
+echo "🟥 NOT COVERED BY THIS LANE (named, not silently absent):"
+echo "   · \`diff_is_substantive\` — whether a CARVEOUT file is promoted depends on diff CONTENT,"
+echo "     not path. This lane pins the PATH class only. That test needs its own anchor."
+echo "   · the hook's behaviour once classified (marker required, manifest required). Pinned"
+echo "     elsewhere (test_marker_*_lanes.sh); this lane covers only the routing decision."
+
+if [ "$FAILED" -eq 0 ]; then
+  echo "✅ heavy-classifier: all pairs hold"
+  exit 0
+fi
+echo "❌ heavy-classifier: at least one pair broke — the gate's routing changed"
+exit 1