@chrono-meta/fh-gate 2.2.0 → 2.4.0

package/scripts/test_target_freeze_lanes.sh

@@ -0,0 +1,203 @@
+#!/usr/bin/env bash
+# test_target_freeze_lanes.sh — known pairs for scripts/target_freeze.sh
+#
+# 🟥 이 레인이 실제로 재는 것: 「대상이 움직였음을 **가르는가**」. 양성만 재면 «항상 다르다고
+#    하는 계기» 와 구분되지 않고, 그 계기는 매 라운드 판정을 무효화해 아무도 안 쓰게 된다
+#    (= 선행 실패 ①의 배경-소음 경로). 그래서 **복원 후 MATCH** 레인이 이 파일의 핵심이다.
+#
+# 🟥 그리고 이 스크립트가 존재하는 이유인 **선행 실패 2종**을 각각 한 레인으로 고정한다:
+#    A  줄 수가 같은 in-place 편집  — `base-SHA + diff 줄 수` 지문이 못 잡던 것
+#    B  untracked 파일 추가         — 같은 지문이 구조적으로 맹목이던 것
+#    이 둘이 빠지면 3번째 시도도 같은 자리에서 무너진다.
+
+set -u
+T="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/target_freeze.sh"
+pass=0; fail=0
+WORK=$(mktemp -d)
+trap 'rm -rf "$WORK"' EXIT
+R="$WORK/repo"
+
+# run <label> <expect MATCH|WRONG|UNKNOWN> <cmd...>
+run() {
+  local label="$1" want="$2"; shift 2
+  local out rc got
+  out=$("$@" 2>&1); rc=$?
+  case "$rc" in
+    0)  got=MATCH ;;
+    1)  got=WRONG ;;
+    10) got=UNKNOWN ;;
+    *)  got="rc$rc" ;;
+  esac
+  if [ "$got" = "$want" ]; then
+    printf '  ✅ %-52s %s (expected %s)\n' "$label" "$got" "$want"; pass=$((pass+1))
+  else
+    printf '  ❌ %-52s %s (expected %s)\n     out: %s\n' "$label" "$got" "$want" "$out"; fail=$((fail+1))
+  fi
+}
+
+echo "[target-freeze] fixture build"
+mkdir -p "$R" && git init -q "$R"
+git -C "$R" config user.email t@t; git -C "$R" config user.name t
+printf 'a\n' >"$R/a.txt"
+git -C "$R" add -A && git -C "$R" commit -qm init
+
+echo "[target-freeze] lanes"
+run "pin (최초)"                        MATCH   bash "$T" pin "$R" demo
+
+# ── A. 선행 실패 ②-1: 줄 수 불변 in-place 편집 ─────────────────────────────
+printf 'b\n' >"$R/a.txt"
+run "A 줄 수 같은 in-place 편집 → WRONG"  WRONG   bash "$T" verify "$R" demo
+printf 'a\n' >"$R/a.txt"
+
+# ── C. 판별력 컨트롤 — 되돌리면 다시 MATCH («항상 다르다» 계기가 아님) ────────
+run "C 복원 후 → MATCH (판별력 컨트롤)"   MATCH   bash "$T" verify "$R" demo
+
+# ── B. 선행 실패 ②-2: untracked 추가 ────────────────────────────────────────
+printf 'new\n' >"$R/untracked.txt"
+run "B untracked 추가 → WRONG"          WRONG   bash "$T" verify "$R" demo
+rm -f "$R/untracked.txt"
+run "B 제거 후 → MATCH"                 MATCH   bash "$T" verify "$R" demo
+
+# ── gitignore 된 파일은 대상이 아니다 (오탐 경로 — 산출물 디렉토리가 매 런 바뀐다) ──
+printf 'out/\n' >"$R/.gitignore"
+git -C "$R" add .gitignore && git -C "$R" commit -qm ignore
+run "pin (ignore 커밋 후 재핀)"          MATCH   bash "$T" pin "$R" demo
+mkdir -p "$R/out" && printf 'noise\n' >"$R/out/run.log"
+run "ignored 산출물 생성 → MATCH (오탐 없음)" MATCH bash "$T" verify "$R" demo
+
+# ── ⓑ 은폐 비트: 잴 수 없으면 «일치» 를 낼 자격이 없다 ──────────────────────
+git -C "$R" update-index --assume-unchanged a.txt
+printf 'HIDDEN\n' >"$R/a.txt"
+run "assume-unchanged → UNKNOWN (통과 아님)" UNKNOWN bash "$T" verify "$R" demo
+git -C "$R" update-index --no-assume-unchanged a.txt
+printf 'a\n' >"$R/a.txt"
+
+# ── ⓒ 미측정을 통과로 접지 않는다 ───────────────────────────────────────────
+run "핀 없는 라벨 → UNKNOWN"             UNKNOWN bash "$T" verify "$R" nolabel
+run "git 레포 아님 → UNKNOWN"            UNKNOWN bash "$T" verify "$WORK" demo
+
+# ── 스테이징만 해도 대상은 움직인 것이다 ────────────────────────────────────
+printf 'staged\n' >"$R/a.txt"; git -C "$R" add a.txt
+run "staged 변경 → WRONG"                WRONG   bash "$T" verify "$R" demo
+
+# ══════════════════════════════════════════════════════════════════════════════
+# cross-family(codex, 2026-08-18)가 **뚫은** 경로들 — 전부 재현 확인 후 여기 고정한다.
+# 🟥 위 11 레인이 초록인 채로 아래가 전부 통과했다: 컨트롤이 있다는 것과 판별력이 있다는
+#    것은 다르다. 이 블록이 없으면 다음 수리가 같은 자리를 조용히 다시 연다.
+# ══════════════════════════════════════════════════════════════════════════════
+echo
+echo "[target-freeze] cross-family 가 뚫은 경로 (fail-open 3 · 오탐 1)"
+
+# ── S: 라벨 별칭 — `a/b` 와 `a_b` 가 같은 핀 파일이면 «핀한 적 없는 라벨» 이 MATCH ──
+bash "$T" pin "$R" a_b >/dev/null 2>&1
+run "S 라벨 별칭 a/b (핀 없음) → UNKNOWN"  UNKNOWN bash "$T" verify "$R" a/b
+
+# ── S: `ls-files -o` 실패가 파이프에 먹혀 «untracked 없음» 으로 접히던 것 ──────────
+FAKEBIN="$WORK/fakebin"; mkdir -p "$FAKEBIN"
+REALGIT=$(command -v git)
+printf '#!/usr/bin/env bash
+if [ "$1" = "-C" ] && [ "$3" = "ls-files" ] && [ "$4" = "-o" ]; then exit 42; fi
+exec %q "$@"
+' "$REALGIT" >"$FAKEBIN/git"
+chmod +x "$FAKEBIN/git"
+bash "$T" pin "$R" lsfail >/dev/null
+printf 'new
+' >"$R/u2.txt"
+run "S ls-files -o 고장 → UNKNOWN (MATCH 아님)" UNKNOWN env PATH="$FAKEBIN:$PATH" bash "$T" verify "$R" lsfail
+rm -f "$R/u2.txt"
+
+# ── S: untracked 중첩 git repo — 안의 내용 변경을 못 보므로 **fail-closed** ────────
+mkdir -p "$R/nested" && git init -q "$R/nested"
+git -C "$R/nested" config user.email t@t; git -C "$R/nested" config user.name t
+printf 'one
+' >"$R/nested/x.txt"
+run "S untracked 디렉토리 → UNKNOWN (못 잰다고 말한다)" UNKNOWN bash "$T" pin "$R" nested
+rm -rf "$R/nested"
+
+# ── A: 깨진 심볼릭 링크 재지정 — 링크가 가리키는 문자열이 내용이다 ─────────────────
+ln -s missing-one "$R/link"
+run "A 심볼릭 링크 pin"                     MATCH   bash "$T" pin "$R" symlink
+ln -sfn missing-two "$R/link"
+run "A 링크 재지정 → WRONG"                 WRONG   bash "$T" verify "$R" symlink
+ln -sfn missing-one "$R/link"
+run "A 링크 복원 → MATCH (판별력 컨트롤)"    MATCH   bash "$T" verify "$R" symlink
+rm -f "$R/link"
+
+# ── S: 서브모듈 **워킹트리** 내용 변경 (커밋 없이) ────────────────────────────────
+#    🟥 `submodule status` 만으로는 못 잡는다 — 그 줄은 서브모듈의 HEAD 를 말하므로,
+#    커밋 없이 파일만 고치면 SHA 가 그대로다. 수리 1차본이 정확히 여기서 뚫렸다.
+SUB="$WORK/sub"; mkdir -p "$SUB" && git init -q "$SUB"
+git -C "$SUB" config user.email t@t; git -C "$SUB" config user.name t
+printf 'v1\n' >"$SUB/s.txt"; git -C "$SUB" add -A; git -C "$SUB" commit -qm sub
+SR="$WORK/subhost"; mkdir -p "$SR" && git init -q "$SR"
+git -C "$SR" config user.email t@t; git -C "$SR" config user.name t
+printf 'a\n' >"$SR/a.txt"; git -C "$SR" add -A; git -C "$SR" commit -qm init
+if git -C "$SR" -c protocol.file.allow=always submodule add -q "$SUB" sub 2>/dev/null; then
+  git -C "$SR" commit -qm addsub
+  printf 'v2\n' >"$SR/sub/s.txt"
+  run "S 서브모듈 pin"                        MATCH   bash "$T" pin "$SR" sm
+  printf 'v3\n' >"$SR/sub/s.txt"
+  run "S 서브모듈 워킹트리 변경 → WRONG"       WRONG   bash "$T" verify "$SR" sm
+  printf 'v2\n' >"$SR/sub/s.txt"
+  run "S 서브모듈 복원 → MATCH (판별력 컨트롤)" MATCH   bash "$T" verify "$SR" sm
+else
+  printf '  ⚠️  서브모듈 레인 skip — 이 git 이 file:// 서브모듈을 거부한다(미측정, 통과 아님)\n'
+fi
+
+# ── A: 오탐 — 빈 커밋은 **내용을 안 바꾼다**. 트리 해시를 쓰므로 MATCH 여야 한다 ────
+# ★앞 레인이 스테이징을 남겨 뒀다. 그대로 `--allow-empty` 하면 **그 스테이징이 커밋되어**
+#   트리가 실제로 바뀐다 — 초판에서 이 레인이 빨갰던 이유는 스크립트가 아니라 픽스처였다.
+git -C "$R" reset -q --hard HEAD
+bash "$T" pin "$R" emptycommit >/dev/null
+git -C "$R" commit --allow-empty -qm noop
+run "A 빈 커밋(같은 tree) → MATCH (오탐 아님)" MATCH  bash "$T" verify "$R" emptycommit
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 2번째 계열(agy, 2026-08-18)이 **다른 축**에서 뚫은 것 — codex 지적 목록을 주고 «그 밖»을
+# 요구했다. 계열을 나눈 것이 값을 냈다(같은 계열 둘이면 같은 사각이 남는다).
+# ══════════════════════════════════════════════════════════════════════════════
+echo
+echo "[target-freeze] 2번째 계열이 뚫은 축"
+
+# ── S: `GIT_DIR` 이 `git -C` 를 이긴다 — 엉뚱한 레포를 재고 «동결했다» 고 보고하던 것 ──
+OTHER="$WORK/other"; mkdir -p "$OTHER" && git init -q "$OTHER"
+git -C "$OTHER" config user.email t@t; git -C "$OTHER" config user.name t
+printf 'other\n' >"$OTHER/o.txt"; git -C "$OTHER" add -A; git -C "$OTHER" commit -qm other
+git -C "$R" reset -q --hard HEAD
+bash "$T" pin "$R" gitdir >/dev/null
+printf 'moved\n' >"$R/a.txt"
+# 환경변수가 살아 있으면 $R 이 아니라 $OTHER 를 재서 «변화 없음»(MATCH)이 나왔다.
+run "S GIT_DIR 오염 상태에서도 대상은 R → WRONG" WRONG \
+    env GIT_DIR="$OTHER/.git" GIT_WORK_TREE="$OTHER" bash "$T" verify "$R" gitdir
+git -C "$R" checkout -q -- a.txt
+run "S 오염 제거 후 복원 → MATCH (판별력 컨트롤)" MATCH bash "$T" verify "$R" gitdir
+
+# ── S: `_sha` 가 `| awk` 로 rc 를 잃던 것 — 해시 실패가 «빈 지문» 으로 접히면 MATCH ──────
+#    🟥 이 레인은 **되돌림 프로브가 만들었다**: `_sha` 의 rc 검사를 되돌렸는데 26 레인이
+#    전부 초록이었다 = 그 수리를 덮는 앵커가 하나도 없었다(장식 앵커). 계기가 스스로를
+#    못 재는 자리를 되돌림이 짚어낸 것이다.
+SHABIN="$WORK/shabin"; mkdir -p "$SHABIN"
+REALSHA=$(command -v shasum || true)
+if [ -n "$REALSHA" ]; then
+  printf '#!/usr/bin/env bash\ninput=$(cat)\ncase "$input" in boom*) exit 7 ;; esac\nprintf %%s "$input" | %q "$@"\n' "$REALSHA" >"$SHABIN/shasum"
+  chmod +x "$SHABIN/shasum"
+  git -C "$R" reset -q --hard HEAD
+  printf 'boom1\n' >"$R/u4.txt"
+  run "S 해시 도구 실패 → UNKNOWN (pin)"      UNKNOWN env PATH="$SHABIN:$PATH" bash "$T" pin "$R" shafail
+  rm -f "$R/u4.txt"
+  run "S 정상 도구로는 pin 됨 (판별력 컨트롤)" MATCH   bash "$T" pin "$R" shafail
+else
+  printf '  ⚠️  _sha 레인 skip — shasum 부재(미측정, 통과 아님)\n'
+fi
+
+# ── B: untracked 파일의 실행 비트 — 이 레포가 이미 데인 축 ────────────────────────
+printf '#!/bin/sh\necho hi\n' >"$R/u3.sh"; chmod 644 "$R/u3.sh"
+run "B 실행비트 pin"                        MATCH   bash "$T" pin "$R" execbit
+chmod +x "$R/u3.sh"
+run "B chmod +x → WRONG (내용은 그대로다)"   WRONG   bash "$T" verify "$R" execbit
+chmod 644 "$R/u3.sh"
+run "B 비트 복원 → MATCH (판별력 컨트롤)"    MATCH   bash "$T" verify "$R" execbit
+rm -f "$R/u3.sh"
+
+printf '\n[target-freeze] pass=%d fail=%d\n' "$pass" "$fail"
+[ "$fail" -eq 0 ]

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

@@ -717,6 +717,217 @@ validate_crossfamily_leg() { # $1 = marker path
   return 0
 }
 
+# ── standpoint: typed value lane (2026-08-17) ────────────────────────────────
+# Grammar:  standpoint: <VALUE>[ — <reason>]
+#
+# WHY NOW. This field shipped 2026-08-14 with its value DELIBERATELY unvalidated — the doctrine
+# said "mechanize on the first recorded false value, not before". That value is now on record:
+# a `release_2.3.0` marker wrote `not-applicable` on a delta whose OWN grounds line concedes
+# "소비자 install 의 게이트 수용은 바뀐다 (BREAKING 2건)", and two 2026-08-14 deltas that changed
+# shipped gate scripts / a shipped SKILL.md carried no line at all. The threshold this field set
+# for itself is met.
+#
+# SCOPE — channel, not judgment (CLAUDE.md §Mechanization Boundary). This asserts properties of the
+# RECORD: present · single · a member of the closed enum · non-vacuous · not wearing the OTHER
+# axis's tokens. It never asserts the value is CORRECT — that stays with the reader, by design.
+#
+# 🟥 NAMED RESIDUAL — the EXECUTION claim warns, it does not block. tier2/tier2b/tier3 assert that
+# something was RUN in the target, which §7 calls "the load-bearing half". Blocking on that needs a
+# vocabulary grep, and on first contact with the real corpus that grep over-blocked a legitimate
+# marker whose grounds read "그 레포에서 실제로 호출해 양·음 arm 을 확인했다" — it did not know 「호출」.
+# Over-blocking trains `--no-verify`, which would disarm the Destructive-Op gate in this same hook.
+# So the cost is stated instead of hidden: a fabricated tier2 with a fluent reason PASSES this lane.
+# Closing that is §4-b's job (cross-family reads the marker), not this lane's.
+#
+# 🟥 DOGFOOD RESULT, STATED SO NOBODY READS THIS AS MORE THAN IT IS — the very marker whose false
+# value MET this field's mechanization threshold (`release_2.3.0`, which wrote `not-applicable` on a
+# release delta) **PASSES this lane**, because its grounds sentence is long and specific. That is not
+# a bug in the lane; it is the Mechanization Boundary holding: the channel is checked, the judgment
+# is not. Anyone reporting that this wiring "closed the self-report axis" is wrong. What closed is
+# the shape of the record; what remains open is whether the recorded answer is true.
+#
+# Calibration before wiring (2026-08-17): known-pair 12/12 both directions; run against all 24
+# corpus markers carrying the field → 7 blocked, every one a real defect (6 bare `not-applicable`,
+# independently matching a hand count, + 1 marker carrying TWO contradictory standpoint lines),
+# 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=""
+  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."
+    echo "     State the answer, whatever it is — the gate blocks silence, not a modest value."
+    echo "     Settle the TARGET CLASS first (§7 Q0), then the tier:"
+    echo "       standpoint: not-applicable — <what you checked to conclude no target exists>"
+    echo "       standpoint: tier1b(pmh-dev) — read the target's own files, executed nothing"
+    echo "       standpoint: tier2(qasp-dev) — ran <command> there, saw <output>"
+    echo "       standpoint: DEGRADED_NOT_RUN — target reachable, not run (<why>)"
+    echo "     Append one line to: $m"
+    return 1
+  fi
+  # Duplicate guard — same defect class the crossfamily lane closes: a marker is append-only in
+  # practice and readers take the FIRST match, so an appended correction is silently shadowed.
+  # Measured in this corpus: one marker carries `tier1` at :32 and `not-applicable` at :89.
+  if [ "$n" -gt 1 ]; then
+    echo "  ❌ FAIL — marker carries MORE THAN ONE 'standpoint:' line."
+    grep -nE '^[[:space:]]*standpoint:' "$m" | sed 's/^/       /'
+    echo "     A later line does not supersede an earlier one — the reader takes the first."
+    echo "     Delete the stale line and leave exactly one."
+    return 1
+  fi
+  line=$(grep -m1 -E '^[[:space:]]*standpoint:' "$m" | sed -E 's/^[[:space:]]*standpoint:[[:space:]]*//')
+  case "$line" in '"'*|"'"*) quoted=" [format: value wrapped in quotes — an auditor's grep for
+       'standpoint: tier2' misses it; drop the quotes next time]";; esac
+  line=$(printf '%s' "$line" | sed -E 's/^["'"'"']//; s/["'"'"']$//')
+  val=$(printf '%s' "$line" | sed -E 's/[[:space:]]*(—|--).*$//' | sed -E 's/[[:space:]]+$//')
+  reason=$(printf '%s' "$line" | sed -E 's/^[^—-]*((—|--)[[:space:]]*)?//')
+  # Cross-axis contamination. `crossfamily:` and `standpoint:` each carry a three-way degrade
+  # triad and the doctrine says the literals are DISTINCT ON PURPOSE. Borrowing the other axis's
+  # token records the wrong axis while looking well-formed.
+  case "$val" in
+    DEGRADED_SINGLE_FAMILY*|DEGRADED_PANEL_UNUSED*|panel\(*|declined)
+      echo "  ❌ FAIL — '$val' belongs to the crossfamily: axis, not standpoint:."
+      echo "     crossfamily = WHICH MODEL FAMILY reviewed. standpoint = WHOSE REPO was ground truth."
+      echo "     standpoint's own triad: DEGRADED_NO_TARGET_ACCESS (could not) /"
+      echo "     DEGRADED_NOT_RUN (did not) / UNKNOWN (did not look)."
+      return 1 ;;
+  esac
+  case "$val" in
+    tier1)
+      echo "  ✅ standpoint leg: tier1 (content-only — a scoping fact, not a failure)$quoted" ;;
+    tier1b\(*\)|tier2\(*\)|tier2b\(*\)|tier3\(*\))
+      case "$val" in
+        tier2\(*\)|tier2b\(*\)|tier3\(*\))
+          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)."
+          else
+            echo "  ✅ standpoint leg: $val$quoted"
+          fi ;;
+        *) echo "  ✅ standpoint leg: $val$quoted" ;;
+      esac ;;
+    not-applicable)
+      # §7: asserting non-applicability without naming what was checked is indistinguishable from
+      # UNKNOWN wearing a permissive label. Measured: 6 bare instances in this corpus.
+      if [ "${#reason}" -lt 20 ]; then
+        echo "  ❌ FAIL — bare 'not-applicable' with no grounds on the same line."
+        echo "     That is UNKNOWN wearing a permissive label. Name what you checked:"
+        echo "     no named peer carries this surface AND it changes no consumer-visible behavior."
+        return 1
+      fi
+      echo "  ✅ standpoint leg: not-applicable$quoted" ;;
+    DEGRADED_NO_TARGET_ACCESS*|DEGRADED_NOT_RUN*|UNKNOWN*)
+      if [ "${#reason}" -lt 20 ]; then
+        echo "  ❌ FAIL — $val without substantive grounds on the same line."
+        echo "     could-not / did-not / did-not-look are separate values on purpose; collapsing"
+        echo "     them renders an unrun probe as a zero finding. Name what you probed."
+        return 1
+      fi
+      echo "  ⚠️  standpoint leg: $val — recorded, not silent" ;;
+    *)
+      echo "  ❌ FAIL — '$val' is not a member of the standpoint: enum."
+      echo "     Closed enum: tier1 · tier1b(<h>) · tier2(<h>) · tier2b(<h>) · tier3(<h>) ·"
+      echo "     not-applicable · DEGRADED_NO_TARGET_ACCESS · DEGRADED_NOT_RUN · UNKNOWN"
+      echo "     Default-deny: an unrecognised value is UNDECIDABLE, never assumed benign."
+      return 1 ;;
+  esac
+  return 0
+}
+
+# ── thirdparty: typed value lane (2026-08-17) ────────────────────────────────
+# Grammar:  thirdparty: <VALUE>(<grounds>)      ·  UNKNOWN takes no parenthetical
+#
+# WHAT THIS AXIS IS — and it has TWO halves, which is what made getting it wrong so easy.
+# The 6-axis canon (fh_three_layer_canon.md:243) defines ⓓ by what it RECEIVES: «문제 + 남의
+# 코드베이스», and it asks two questions:
+#   ① prior art        — has this claimed-new thing already been solved outside?   checked/none-found
+#   ② harness-level     — how does my change look from ANOTHER HARNESS's repo and   peer-review
+#      adversarial        persona? (operator: put Sonnet in gstack, wear the gstack
+#                         persona, review the qasp change — a cross-FAMILY, harness-scoped
+#                         adversarial review. FH is the GOVERNOR: it creates the situation,
+#                         observes, and judges. What the 4-axis gate verifies is the OPINION
+#                         that third harness produced, judged LOCALLY — it does not put a gate
+#                         on someone else's repo.)
+# It is NOT "I talked to another session". The canonical spec
+# (`.claude/rules/fh_4axis_gate.md`) has said so since the field shipped, and the evidence that
+# created it was 6 presentation claims that turned out to have prior art (mutation testing,
+# promptfoo/DeepEval, an official cross-family plugin, …).
+#
+# WHY NOW — the first recorded false values exist, and they are the author's own. Measured across
+# the marker corpus 2026-08-17: 4 markers used the enum correctly; **2 wrote free prose about
+# peer-session contact** and matched no enum member at all. That is the field-canon failure this
+# repo already names — normalizing a harness term into a general concept ("third party" → "another
+# session"). Presence was checked; the value was not; nothing caught it.
+#
+# SCOPE — channel, not judgment (CLAUDE.md §Mechanization Boundary). This asserts the RECORD is a
+# member of the closed enum and names non-vacuous grounds. It never asserts the prior-art search
+# was thorough, nor that what a third party told you is TRUE — 🟥 that second one is deliberate and
+# load-bearing: the axis exists to surface information you could not predict, and the truth of what
+# comes back is adjudicated by the OTHER axes (adversarial · grounding · first-real-use), which is
+# what the 4-axis gate is for. A wrong answer from a third party is that party's defect, possibly
+# one to go fix; it is not something this field should be asked to certify.
+#
+# TRIGGER — validate IF PRESENT. Presence stays pointer-driven (`ⓓ=→thirdparty`), deliberately:
+# requiring the field on every load-bearing change would force a prior-art search per commit, and
+# over-blocking trains the override that disarms the Destructive-Op gate in this same hook.
+#
+# Calibration before wiring: the corpus supplied BOTH arms — peer-authored markers 4/4 PASS,
+# author's own malformed 2/2 BLOCK, plus 6 synthetic shapes, 0 over-blocks. An earlier draft DID
+# over-block 3 legitimate markers by looking for the closing paren on the first line when the
+# grounds wrap across lines; the corpus caught it. Anchor: scripts/test_marker_thirdparty_lanes.sh
+validate_thirdparty_leg() { # $1 = marker path
+  local m="$1" line val reason n
+  n=$(grep -cE '^[[:space:]]*thirdparty:' "$m" 2>/dev/null); n=${n:-0}
+  [ "$n" -eq 0 ] && return 0   # absent is governed by the ⓓ pointer check above, not here
+  if [ "$n" -gt 1 ]; then
+    echo "  ❌ FAIL — marker carries MORE THAN ONE 'thirdparty:' line."
+    grep -nE '^[[:space:]]*thirdparty:' "$m" | sed 's/^/       /'
+    echo "     Readers take the first, so an appended correction is silently shadowed."
+    return 1
+  fi
+  line=$(grep -m1 -E '^[[:space:]]*thirdparty:' "$m" | sed -E 's/^[[:space:]]*thirdparty:[[:space:]]*//')
+  val=$(printf '%s' "$line" | sed -E 's/\(.*$//' | sed -E 's/[[:space:]]*(—|--).*$//' | sed -E 's/[[:space:]]+$//')
+  # Cross-axis contamination — standpoint's tiers and crossfamily's tokens are different axes.
+  case "$val" in
+    tier1|tier1b|tier2|tier2b|tier3|panel|declined|DEGRADED_SINGLE_FAMILY|DEGRADED_PANEL_UNUSED|DEGRADED_NO_TARGET_ACCESS)
+      echo "  ❌ FAIL — '$val' belongs to another axis, not thirdparty:."
+      echo "     standpoint = whose repo was ground truth · crossfamily = which model family reviewed"
+      echo "     thirdparty = was this claimed-new thing already done OUTSIDE this repo."
+      return 1 ;;
+  esac
+  case "$val" in
+    UNKNOWN)
+      echo "  ⚠️  thirdparty leg: UNKNOWN — 안 봤다. Recorded, not silent." ;;
+    peer-review|checked|none-found|not-applicable|DEGRADED_NO_ACCESS|DEGRADED_NOT_RUN)
+      # The parenthetical may wrap across lines; only require that it OPENS with content after it.
+      case "$line" in *\(*) ;; *)
+        echo "  ❌ FAIL — '$val' without a (<grounds>) parenthetical."
+        echo "     none-found without naming WHAT you searched is indistinguishable from not looking."
+        return 1 ;;
+      esac
+      reason=$(printf '%s' "$line" | sed -E 's/^[^(]*\(//')
+      if [ "${#reason}" -lt 12 ]; then
+        echo "  ❌ FAIL — '$val(...)' grounds are vacuous. Name what was searched and what came back."
+        return 1
+      fi
+      echo "  ✅ thirdparty leg: $val" ;;
+    *)
+      echo "  ❌ FAIL — '$val' is not a member of the thirdparty: enum."
+      echo "     Closed enum: peer-review(<harness>/<persona> -> <target>, <what came back>) ·"
+      echo "     checked(<searched/found>) · none-found(<searched>) ·"
+      echo "     DEGRADED_NO_ACCESS(<why>) · DEGRADED_NOT_RUN(<why>) · UNKNOWN · not-applicable(<why>)"
+      echo "     🟥 ⓓ3자대면 = third-party PRIOR ART, not 'I talked to another session'. The two"
+      echo "     markers that made this lane necessary both made exactly that substitution."
+      return 1 ;;
+  esac
+  return 0
+}
+
+
+
 # ── 4축 자기 대조 — «어느 축을 돌렸고 어느 축을 안 돌렸나» 형식 검사 ────────────
 # CLAUDE.md §3층 자기 대조가 마커에 3줄을 요구한다. 그중 **기계로 볼 수 있는 두 줄**만 여기서
 # 강제한다. 나머지(①영혼을 «설계 전에» 썼는가)는 **원리적으로 확인 불가**라 안 넣는다 —
@@ -866,6 +1077,26 @@ validate_marker_axes_run() { # $1 = marker path
       echo "       standpoint: not-applicable"
       return 1
     fi
+
+    # ⓓ3자대면도 같은 형태 — 값은 `thirdparty:` 자기 필드가 나른다 (2026-08-17 신설).
+    # 🟥 왜 자기 필드가 필요한가: `axes-run` 한 칸은 **토큰**만 담는다. ⓓ가 실제로 내는 것은
+    #    «무엇을 검색해서 무엇을 찾았나» 라 한 토큰에 안 들어간다. 자리가 없으면 안 적히고,
+    #    안 적히면 다음 세션이 «이 축을 돌렸나»를 물을 수도 확인할 수도 없다.
+    #    실측(2026-08-17): 이 축을 처음 제대로 돌린 세션에서 발표 주장 **6건**이 선행자산에
+    #    걸렸는데, 그 결과를 기록할 필드가 없었다.
+    # ⚠️ ⓑ 와 **똑같은 fail-open 을 반복하지 않는다** — 화살표를 필수로 보지 않고
+    #    «ⓓ 값이 thirdparty 를 참조하는가» 로 넓힌다(ⓑ가 그렇게 뚫렸던 실측이 바로 위에 있다).
+    #    같은 명시 잔여도 그대로 상속한다: 참조어가 다른 토큰에 있으면 안 잡힌다.
+    if echo "$line" | grep -qE "(^|[[:space:]])ⓓ=[^[:space:]]*thirdparty" \
+       && ! grep -qE '^[[:space:]]*thirdparty:[[:space:]]*[^[:space:]]' "$m" 2>/dev/null; then
+      echo "  ❌ MARKER — 'ⓓ=→thirdparty' 라고 적었는데 'thirdparty:' 줄이 없다"
+      echo "     포인터가 가리키는 곳이 비어 있으면 그건 기록이 아니라 죽은 포인터다."
+      echo "       thirdparty: checked(promptfoo·DeepEval 훑음 — 겹침 없음)"
+      echo "       thirdparty: none-found(<무엇을 검색했나>)   ← 찾았는데 없음. «안 봤다»와 다르다"
+      echo "       thirdparty: UNKNOWN                        ← 안 봤다"
+      echo "       thirdparty: not-applicable"
+      return 1
+    fi
   fi
 
   line=$(grep -m1 -E '^[[:space:]]*controls:' "$m" 2>/dev/null \
@@ -1283,6 +1514,8 @@ if [ -n "$LOADBEARING" ]; then
   fi
   MARKER_LB="$REPO_ROOT/tracks/_meta/.axes_23_passed_${BRANCH_SLUG}_${TODAY}.marker"
   if validate_crossfamily_leg "$MARKER_LB"; then :; else FAILED=1; fi
+  if validate_standpoint_leg "$MARKER_LB"; then :; else FAILED=1; fi
+  if validate_thirdparty_leg "$MARKER_LB"; then :; else FAILED=1; fi
 fi
 
 # ── staged-blob materializer (advisory linters) ───────────────────────────────
@@ -1391,6 +1624,35 @@ if [ -f "$PL_LINT" ]; then
   fi
 fi
 
+# ── Pre-ship read reminder (advisory) ─────────────────────────────────────────
+# WHY (2026-08-17, ⓓ3자대면 첫 실사용의 답습분). A third harness (gstack), wearing its own
+# `/plan-devex-review` persona, reviewed a peer harness's change and asked a question neither FH
+# nor that harness asks: **who opens this file, and what do they see in the first eight lines?**
+# Its finding: a human-facing report had been shipped to three surfaces where the body was 3 lines
+# under 21 lines of fixed template, the answer to "did it pass?" was buried in the 4th bullet, and
+# the last impression was "readers may skip this". The delta that shipped it was correct code.
+#
+# FH reached the same place independently the same day from a different axis — "readability is
+# measured only by rendering it or by a person; a static scan catches what is ABSENT, never what is
+# UNREADABLE", with 12 findings and 0 caught by static scanners. **Two independent arrivals** is
+# why this was the one item the internalization filter accepted out of four
+# (`harness_incubator_doctrine.md` §4-c).
+#
+# 🟥 WHAT THIS IS NOT. It does not judge readability, and it never blocks. Judging "is this
+# readable" is exactly the frozen-judgment class §Mechanization Boundary reserves for people, and a
+# vocabulary test for "human-facing document" over-blocked a legitimate case the same day it was
+# first tried. The trigger is therefore a PATH SET (what actually ships to readers), not a
+# vocabulary guess, and its whole output is one line of salience.
+_PRESHIP=$(printf '%s\n' "$STAGED" | grep -E '^(README([._a-z]*)?\.md|CHEATSHEET\.md|CATALOG\.md|docs/[^/]*\.md|templates/[^/]*\.md)$' || true)
+if [ -n "$_PRESHIP" ]; then
+  echo "[Gate] reader-facing surface staged — pre-ship read reminder (advisory)..."
+  printf '%s\n' "$_PRESHIP" | sed 's/^/       /'
+  echo "  ⚠️  이 파일들은 «사람이 연다». 나가기 전에 한 번 «독자로서» 읽었나?"
+  echo "     첫 8줄에 결론이 있나 · 본문이 템플릿에 안 덮이나 · 마지막 인상이 무엇인가"
+  echo "     렌즈가 이미 있다: /sim-conductor A-1 (beginner cold-read) 또는 직접 렌더해서 읽기"
+  echo "  (advisory — 막지 않는다. 「읽었는가」는 이 훅이 보증할 수 없고 보증하려 들지도 않는다.)"
+fi
+
 # ── Novelty-claim ledger (advisory) ───────────────────────────────────────────
 # "Ask the world before asserting novelty" is an INTENT trigger — un-hookable, like the
 # repo-go-public surface. So this does not force the asking; it makes NOT having asked visible

package/templates/PRE-PUBLISH-CHECKLIST.md

@@ -83,3 +83,25 @@ A pre-publish catch is a process win worth logging:
 
 **Done when**: Step 0 pre-flags clean (or escalated to full scan) · Step 1 both gates non-LEAK ·
 publish executed *after* the gates passed, never before.
+
+## Read it as a reader, once, before it goes out
+
+Not a correctness check — the code can be right and this still fails. Open the thing a **reader**
+opens and look at what they see:
+
+- [ ] Is the **conclusion in the first ~8 lines**, or is it buried under banners, metadata and
+      "how to read this table"?
+- [ ] Does the **body survive the template**? (measured case: 3 lines of content under 21 lines of
+      fixed boilerplate)
+- [ ] What is the **last impression**? (measured case: the final line told the reader they could
+      skip it)
+- [ ] Does it say **what the reader should do next**?
+
+A lens already exists — `/sim-conductor` A-1 (`beginner` cold-read) — or just render it and read it.
+
+🟥 **Why this is a human step and not a scan**: a static check catches what is ABSENT, never what is
+UNREADABLE. Two independent measurements arrived here the same day (2026-08-17): one harness axis
+found 12 readability defects with **0** caught by static scanners; a third-harness review
+(`harness_incubator_doctrine.md` §4-c) found a shipped report whose answer to "did it pass?" sat in
+the fourth bullet. The pre-commit hook prints an advisory reminder when a reader-facing surface is
+staged — it reminds, it does not certify.

package/templates/regression_guard.sh

@@ -64,13 +64,41 @@ if [ "${1:-}" = "--pr" ]; then
   fi
   PR_BRANCH="$2"
   BASE_BRANCH="${3:-main}"
-  BASE_REF=$(git merge-base "$BASE_BRANCH" "$PR_BRANCH" 2>/dev/null)
+  # Resolve each side to a ref that actually EXISTS in this checkout.
+  #
+  # WHY (measured 2026-08-17, 5 of 5 SAMPLED CI runs — not an exhaustive audit): a bare branch
+  # NAME does not resolve in a GitHub Actions PR checkout. actions/checkout lands on a DETACHED
+  # HEAD and creates refs/remotes/origin/*, not local branches — so `git merge-base main <branch>`
+  # found neither side, returned empty, and this block exited 3. `fetch-depth: 0` was already set
+  # and is NOT the cause; the history was present, the NAMES were not. The workflow then rendered
+  # that instrument error as a green PASS (fixed in the same commit).
+  #
+  # 🟥 THE FIRST FIX FOR THIS INTRODUCED A WORSE HOLE, caught by cross-family review before it
+  # shipped. It resolved `ref -> origin/ref -> refs/remotes/origin/ref` and fell back to HEAD.
+  # `github.head_ref` is only a branch NAME, not owner-qualified, so a **fork PR whose branch is
+  # named `main`** resolved the PR side to the BASE repo's `main` — merge-base(main, main) = main,
+  # empty diff, SKIP, green. A guard silently comparing a branch to itself is worse than one that
+  # errors. So: NO name-guessing and NO silent HEAD fallback. Callers pass something
+  # unambiguous (a SHA, or an explicit `origin/<ref>`); anything that does not resolve EXACTLY
+  # is an instrument error, and the workflow now fails closed on that.
+  _rg_resolve_ref() { # $1 = ref-ish; echoes it iff it resolves EXACTLY as given (rc=1 otherwise)
+    git rev-parse --verify --quiet "${1}^{commit}" >/dev/null 2>&1 && printf '%s' "$1"
+  }
+  _BASE_RESOLVED=$(_rg_resolve_ref "$BASE_BRANCH") || _BASE_RESOLVED=""
+  _HEAD_RESOLVED=$(_rg_resolve_ref "$PR_BRANCH")  || _HEAD_RESOLVED=""
+  if [ -z "$_BASE_RESOLVED" ] || [ -z "$_HEAD_RESOLVED" ]; then
+    echo "ERROR: ref does not resolve — base='$BASE_BRANCH'->'${_BASE_RESOLVED:-<none>}' head='$PR_BRANCH'->'${_HEAD_RESOLVED:-<none>}'" >&2
+    echo "       Pass an unambiguous ref (a SHA, or origin/<branch>). Guessing is how a fork PR" >&2
+    echo "       branch named 'main' silently compared the base repo's main to itself." >&2
+    exit 3
+  fi
+  BASE_REF=$(git merge-base "$_BASE_RESOLVED" "$_HEAD_RESOLVED" 2>/dev/null)
   if [ -z "$BASE_REF" ]; then
-    echo "ERROR: cannot compute merge-base for $PR_BRANCH vs $BASE_BRANCH" >&2
+    echo "ERROR: cannot compute merge-base for $_HEAD_RESOLVED vs $_BASE_RESOLVED" >&2
     exit 3
   fi
-  HEAD_REF="$PR_BRANCH"
-  echo "PR MODE: merge-base=$(git rev-parse --short "$BASE_REF") branch=$PR_BRANCH"
+  HEAD_REF="$_HEAD_RESOLVED"
+  echo "PR MODE: merge-base=$(git rev-parse --short "$BASE_REF") base=$_BASE_RESOLVED head=$_HEAD_RESOLVED"
 elif [ "${1:-}" = "--staged" ]; then
   # Pre-commit context: evaluate the staged index against HEAD. On a direct-to-main
   # workflow, --pr's merge-base(main,main)=HEAD yields an empty diff, so staged changes