@chrono-meta/fh-gate 3.0.0 → 3.1.0

package/scripts/validate_yaml.sh

@@ -133,6 +133,33 @@ if [ "$_skills" -eq 0 ] || [ "$_agents" -eq 0 ]; then
 fi
 echo "  (scanned: $_skills skill(s), $_agents agent(s))"
 
+# ── Whole-file YAML documents that machinery READS (not frontmatter) ─────────────────────────
+# The dispatch ledger is parsed by session_close_check ④-e / activity_log / round/gatecheck_qset and
+# by the 60/40 promotion gate. Measured 2026-09-04: PR #611 merged an entry whose unquoted scalar
+# carried `: ` (`… API error: 529»`) and the file had been UNPARSEABLE at HEAD since — while its own
+# marker cited "validate_yaml 레인" as the live control. That lane never read this file: it checks
+# SKILL/agent FRONTMATTER only. This block closes that gap for the files listed here. Known pair at
+# wiring time: the #611 HEAD ledger → ❌ (line 3090), the quoted fix → ✅.
+_LEDGERS="knowledge/shared/learnings/subagent_invocations_log.yaml"
+for f in $_LEDGERS; do
+  [ -f "$f" ] || { echo "  ❌ ledger missing: $f (not found ≠ empty)"; ERRORS=$((ERRORS + 1)); continue; }
+  if [ -z "$PARSER" ]; then
+    echo "  ⚠️  $f: UNCALIBRATED — no YAML parser, NOT verified"; UNCALIBRATED=$((UNCALIBRATED + 1)); continue
+  fi
+  out=$(python3 - "$f" <<'PY' 2>&1
+import sys, yaml
+try:
+    d = yaml.safe_load(open(sys.argv[1], encoding='utf-8'))
+except yaml.YAMLError as e:
+    print('PARSE ' + str(e).replace('\n', ' ')[:160]); sys.exit(1)
+if not isinstance(d, list) or not d:
+    print('NOTLIST-OR-EMPTY'); sys.exit(2)
+print('OK %d entries' % len(d))
+PY
+  ); rc=$?
+  if [ "$rc" -eq 0 ]; then echo "  ✅ $f: $out"; else echo "  ❌ $f: $out"; ERRORS=$((ERRORS + 1)); fi
+done
+
 echo ""
 if [ "$UNCALIBRATED" -gt 0 ]; then
   echo "  ⚠️  UNCALIBRATED — $UNCALIBRATED skill(s) unverified (no parser). Not a pass."

package/scripts/worktree_reclaim.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+# worktree_reclaim.sh — reclaim gitignored `tracks/**` artifacts from a git worktree BEFORE it is removed.
+#
+# WHY (N=2, so a script — 2026-09-02 signal + 2026-09-05 push-zone dispatch): the Destructive-Op gate
+# enumerates COMMITS, and `tracks/**` is gitignored, so a worktree removal can delete a session's only
+# copy of a signal file / governance log / dispatch report without any gate ever seeing it. Both
+# incidents lost real files (51-line signal · a day's governance log). The manual recipe that replaced
+# them — `diff -rq <wt>/tracks tracks | grep "^Only in <wt>"` → list to a FILE → copy → only then
+# remove — is exactly what this script does, in that order, because after the copy «never existed»
+# and «already moved» are indistinguishable (the list file is the evidence).
+#
+# USAGE
+#   bash scripts/worktree_reclaim.sh <worktree-path>            # enumerate only (writes the list file)
+#   bash scripts/worktree_reclaim.sh <worktree-path> --apply    # enumerate + copy + verify
+#
+# EXIT  0 = nothing to reclaim, or everything reclaimed and byte-verified
+#       1 = files exist on BOTH sides with different content — a human must merge (listed, not copied)
+#       2 = usage / not a worktree of a main checkout
+#       10 = harness error (list file unwritable, copy failed verification)
+#
+# NEVER removes the worktree. Removal stays an explicit `git worktree remove` after this exits 0.
+set -uo pipefail
+# bash 3.2 + `set -u`: expanding an EMPTY array with "${a[@]}" is a fatal unbound-variable error, so every
+# array loop below uses the ${a[@]+"${a[@]}"} idiom (measured on the first fixture run, 2026-09-05).
+
+WT="${1:-}"; MODE="${2:-}"
+[ -n "$WT" ] || { echo "usage: $0 <worktree-path> [--apply]" >&2; exit 2; }
+[ -d "$WT" ] || { echo "🟥 not a directory: $WT" >&2; exit 2; }
+case "$MODE" in ''|--apply) ;; *) echo "usage: $0 <worktree-path> [--apply]" >&2; exit 2 ;; esac
+
+COMMON="$(git -C "$WT" rev-parse --git-common-dir 2>/dev/null)" || { echo "🟥 not a git worktree: $WT" >&2; exit 2; }
+GITDIR="$(git -C "$WT" rev-parse --git-dir 2>/dev/null)"
+case "$COMMON" in /*) ;; *) COMMON="$WT/$COMMON" ;; esac
+case "$GITDIR" in /*) ;; *) GITDIR="$WT/$GITDIR" ;; esac
+COMMON="$(cd "$COMMON" && pwd -P)"; GITDIR="$(cd "$GITDIR" && pwd -P)"
+if [ "$COMMON" = "$GITDIR" ]; then
+  echo "🟥 $WT is the MAIN checkout (git-dir == git-common-dir), not a worktree — nothing to reclaim from itself" >&2; exit 2
+fi
+ROOT="$(dirname "$COMMON")"           # main checkout root = parent of the shared .git
+WT="$(cd "$WT" && pwd -P)"
+SRC="$WT/tracks"; DST="$ROOT/tracks"
+[ -d "$SRC" ] || { echo "ℹ️  no tracks/ in worktree — nothing to reclaim (rc=0)"; exit 0; }
+mkdir -p "$DST/_meta/dispatch" 2>/dev/null || { echo "🟥 cannot create $DST/_meta/dispatch" >&2; exit 10; }
+
+NAME="$(basename "$WT")"; TS="$(date +%Y%m%d-%H%M%S)"
+LIST="$DST/_meta/dispatch/reclaim_${NAME}_${TS}.txt"
+
+# 1. ENUMERATE — the list lands in a file FIRST (the evidence that survives the copy)
+ONLY=(); DIFF=()
+while IFS= read -r line; do
+  case "$line" in
+    "Only in $SRC"*)
+      d="${line#Only in }"; dir="${d%%: *}"; f="${d#*: }"
+      rel="${dir#$SRC}"; rel="${rel#/}"
+      p="${rel:+$rel/}$f"
+      if [ -d "$SRC/$p" ]; then
+        while IFS= read -r ff; do ONLY+=("${ff#$SRC/}"); done < <(find "$SRC/$p" -type f)
+      else
+        ONLY+=("$p")
+      fi ;;
+    "Files $SRC"*" differ") DIFF+=("$(printf '%s' "${line#Files }" | sed "s# and .*##; s#^$SRC/##")") ;;
+  esac
+done < <(diff -rq "$SRC" "$DST" 2>/dev/null)
+
+{
+  echo "# worktree_reclaim — $WT → $ROOT  ($TS)"
+  echo "# only-in-worktree: ${#ONLY[@]}   differ-both-sides: ${#DIFF[@]}   mode: ${MODE:-enumerate}"
+  for p in ${ONLY[@]+"${ONLY[@]}"}; do echo "ONLY	$p"; done
+  for p in ${DIFF[@]+"${DIFF[@]}"}; do echo "DIFF	$p"; done
+} > "$LIST" || { echo "🟥 cannot write list file $LIST" >&2; exit 10; }
+echo "── worktree_reclaim: $NAME ──"
+echo "   only-in-worktree: ${#ONLY[@]} · differ-both-sides: ${#DIFF[@]} · list: ${LIST#$ROOT/}"
+for p in ${ONLY[@]+"${ONLY[@]}"}; do echo "   ONLY  $p"; done
+for p in ${DIFF[@]+"${DIFF[@]}"}; do echo "   DIFF  $p   (both sides exist and differ — NOT copied, merge by hand)"; done
+
+# 2. RECLAIM (--apply) — copy, then verify byte-identical; a copy that cannot be verified is a harness error
+if [ "$MODE" = "--apply" ] && [ "${#ONLY[@]}" -gt 0 ]; then
+  bad=0
+  for p in ${ONLY[@]+"${ONLY[@]}"}; do
+    mkdir -p "$(dirname "$DST/$p")" && cp -p "$SRC/$p" "$DST/$p" && cmp -s "$SRC/$p" "$DST/$p" \
+      && echo "   ✅ reclaimed $p" || { echo "   🟥 copy/verify FAILED $p"; bad=$((bad+1)); }
+  done
+  [ "$bad" -eq 0 ] || { echo "🟥 $bad file(s) not reclaimed — do NOT remove the worktree" >&2; exit 10; }
+fi
+
+if [ "${#DIFF[@]}" -gt 0 ]; then
+  echo "⚠️  ${#DIFF[@]} file(s) differ on both sides — reconcile by hand before removing the worktree (rc=1)"
+  exit 1
+fi
+if [ "${#ONLY[@]}" -gt 0 ] && [ "$MODE" != "--apply" ]; then
+  echo "ℹ️  ${#ONLY[@]} file(s) exist only in the worktree — re-run with --apply to copy them (rc=1 until reclaimed)"
+  exit 1
+fi
+echo "✅ nothing left only in the worktree — safe to: git worktree remove $WT"
+exit 0

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

@@ -780,8 +780,32 @@ validate_defense_leg() { # $1 = marker path — fires ONLY at the floor tiers (s
   return 0
 }
 
+# ── residency= token inside crossfamily grounds (2026-09-05, operator-approved) ──────────────
+# WHY: `scripts/residency_closure_scan.py` screens a payload for organizational identifiers
+# before it leaves this family boundary — but until now "was it screened" was a claim with no
+# channel: auto-decorrelation's own Step 5 note ("Residency still governs … sanitize before any
+# external-family dispatch") was prose with nothing downstream reading it back
+# ([[feedback_half_externalization_slot_without_consumer]] shape — a slot with no consumer). This
+# wires the scan's own exit code into the SAME typed field the crossfamily lane already validates,
+# rather than opening a new marker line — one channel, not two.
+#
+# GRAMMAR (inside crossfamily's own grounds, after the em-dash):
+#   crossfamily: panel(codex) — residency=CLEAN(files=7) · R1..R2, 4 findings
+#   crossfamily: DEGRADED_SINGLE_FAMILY — residency=TAINTED(2 files, stripped=no) → not sent · …
+#   crossfamily: DEGRADED_SINGLE_FAMILY — residency=NOT_SCANNED(scanner absent) → not sent · …
+#
+# SCOPE — same Mechanization Boundary as the rest of this function: a channel check on the
+# RECORD (present when a panel claim is made, closed-enum shaped whenever it appears at all),
+# never a truth check. Whether the CLEAN verdict was ACCURATE is not this lane's question — that
+# stays with the reader (cross-family reads the marker), identical ceiling to `standpoint:`.
+#
+# 🟥 NO RETROACTIVITY. Same pattern as `DEFEATER_GRACE_DATE` below: a marker dated before this
+# constant is validated exactly as it was before this change existed. Forcing it retroactively
+# 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"
 validate_crossfamily_leg() { # $1 = marker path
-  local m="$1" line val reason fams
+  local m="$1" line val reason fams mdate _res_active _res_tokens _res_ntok _res_wellformed _res_kind
   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"
@@ -817,6 +841,33 @@ validate_crossfamily_leg() { # $1 = marker path
   reason=$(printf '%s' "$line" | sed -E 's/^[^—-]*(—|--)[[:space:]]*//')
   [ "$reason" = "$line" ] && reason=""
 
+  # residency= token — computed once, consumed by whichever branch below needs it (REQUIRED for
+  # panel(...), format-only-if-present for declined/DEGRADED_*/UNKNOWN). See the comment above
+  # RESIDENCY_TOKEN_GRACE_DATE for the grammar and why this rides inside crossfamily's own grounds
+  # rather than opening a new marker line.
+  mdate=$(printf '%s' "$m" | sed -nE 's/.*_([0-9]{4}-[0-9]{2}-[0-9]{2})\.marker$/\1/p')
+  _res_active=1
+  # Same "can't-read-date → NOT exempt" rule as validate_defeater_leg, same reason: the hook
+  # stamps TODAY's date into every marker filename it creates, so an unparseable date is an
+  # unexpected shape, not evidence of age ([[feedback_not_found_is_not_zero_family]]).
+  if [ -n "$mdate" ] && [ "$mdate" \< "$RESIDENCY_TOKEN_GRACE_DATE" ]; then _res_active=0; fi
+  # Presence counts EVERY `residency=` occurrence (any shape); well-formedness is a SEPARATE grep for
+  # the full token `residency=<KIND>(...)` with its closing paren. The first draft grepped the prefix
+  # `residency=<KIND>(` only, so a malformed token could hide by FAILING the shape grep — cross-family
+  # (codex gpt-5.5, 2026-09-05) showed `residency=CLEAN (files=2)` (space) and `residency=CLEAN(files=1`
+  # (no close paren) passing the optional-token path as if absent. Presence-first closes that: a
+  # `residency=` that is not one well-formed token is malformed, never invisible.
+  _res_tokens=$(printf '%s' "$reason" | grep -oE 'residency=[^[:space:]]*' 2>/dev/null || true)
+  _res_ntok=0
+  [ -n "$_res_tokens" ] && _res_ntok=$(printf '%s\n' "$_res_tokens" | grep -c .)
+  _res_full=$(printf '%s' "$reason" | grep -oE 'residency=(CLEAN|TAINTED|NOT_SCANNED)\([^)]*\)' 2>/dev/null || true)
+  _res_nfull=0
+  [ -n "$_res_full" ] && _res_nfull=$(printf '%s\n' "$_res_full" | grep -c .)
+  _res_wellformed=0
+  [ "$_res_ntok" -eq 1 ] && [ "$_res_nfull" -eq 1 ] && _res_wellformed=1
+  _res_kind=""
+  [ "$_res_wellformed" -eq 1 ] && _res_kind=$(printf '%s' "$_res_full" | sed -E 's/^residency=([A-Za-z_]*)\(.*$/\1/')
+
   case "$val" in
     declined)
       # `declined` means ONE thing: the OPERATOR declined sidecars (UAP), a chosen floor. It was
@@ -872,6 +923,22 @@ validate_crossfamily_leg() { # $1 = marker path
         [ "${#reason}" -ge 20 ] && echo "     (grounds were substantive but named no resolvable path)"
         return 1
       fi
+      if [ "$_res_active" -eq 1 ] && [ "$_res_ntok" -gt 0 ]; then
+        if [ "$_res_ntok" -gt 1 ]; then
+          echo "  ❌ FAIL — grounds carries MORE THAN ONE 'residency=' token."
+          printf '%s\n' "$_res_tokens" | sed 's/^/       /'
+          echo "     Same trap as two crossfamily: lines — the reader takes the first, so an"
+          echo "     appended correction is silently shadowed. Leave exactly one."
+          return 1
+        fi
+        if [ "$_res_wellformed" -ne 1 ]; then
+          echo "  ❌ FAIL — 'residency=' token present but not one of CLEAN|TAINTED|NOT_SCANNED:"
+          printf '%s\n' "$_res_tokens" | sed 's/^/       /'
+          echo "     Closed set, same reason crossfamily's own value is one — free prose here is"
+          echo "     read as measured by a later session."
+          return 1
+        fi
+      fi
       echo "  ✅ cross-family leg: declined (operator-chosen floor, first-class — not a degrade)"
       echo "     $(printf '%s' "$reason" | cut -c1-80)" ;;
     panel*)
@@ -922,6 +989,38 @@ validate_crossfamily_leg() { # $1 = marker path
         echo "     pattern here in the same commit that first uses it."
         return 1
       fi
+      if [ "$_res_active" -eq 1 ]; then
+        if [ "$_res_ntok" -gt 1 ]; then
+          echo "  ❌ FAIL — grounds carries MORE THAN ONE 'residency=' token."
+          printf '%s\n' "$_res_tokens" | sed 's/^/       /'
+          echo "     Same trap as two crossfamily: lines — the reader takes the first. Leave"
+          echo "     exactly one."
+          return 1
+        fi
+        if [ "$_res_ntok" -eq 0 ]; then
+          echo "  ❌ FAIL — panel(...) with no 'residency=CLEAN(' token in grounds."
+          echo "     A panel claim means a payload left this family boundary. Screen it first"
+          echo "     (scripts/residency_closure_scan.py --files <payload>) and record the result:"
+          echo "       crossfamily: panel($fams) — residency=CLEAN(files=7) · R1..R3, ..."
+          echo "     A TAINTED or NOT_SCANNED payload must not have been sent — if that is what"
+          echo "     actually happened, the honest crossfamily value is DEGRADED_*, not panel(...)."
+          return 1
+        fi
+        if [ "$_res_wellformed" -ne 1 ]; then
+          echo "  ❌ FAIL — 'residency=' token present but not one of CLEAN|TAINTED|NOT_SCANNED:"
+          printf '%s\n' "$_res_tokens" | sed 's/^/       /'
+          echo "     Closed set, same reason crossfamily's own value is one — free prose here is"
+          echo "     read as measured by a later session."
+          return 1
+        fi
+        if [ "$_res_kind" != "CLEAN" ]; then
+          echo "  ❌ FAIL — panel(...) (payload WAS sent) with residency=$_res_kind(...) (NOT clean"
+          echo "     / not screened) on the SAME line — a contradiction in the record."
+          echo "     A sent payload must carry residency=CLEAN(...). If it was actually TAINTED or"
+          echo "     NOT_SCANNED, it should not have shipped — the honest value is DEGRADED_*."
+          return 1
+        fi
+      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.
@@ -940,6 +1039,18 @@ validate_crossfamily_leg() { # $1 = marker path
         echo "       crossfamily: $val — probed codex/agy/gemini, <what came back>"
         return 1
       fi
+      if [ "$_res_active" -eq 1 ] && [ "$_res_ntok" -gt 0 ]; then
+        if [ "$_res_ntok" -gt 1 ]; then
+          echo "  ❌ FAIL — grounds carries MORE THAN ONE 'residency=' token."
+          printf '%s\n' "$_res_tokens" | sed 's/^/       /'
+          return 1
+        fi
+        if [ "$_res_wellformed" -ne 1 ]; then
+          echo "  ❌ FAIL — 'residency=' token present but not one of CLEAN|TAINTED|NOT_SCANNED:"
+          printf '%s\n' "$_res_tokens" | sed 's/^/       /'
+          return 1
+        fi
+      fi
       echo "  ⚠️  cross-family leg: $val — recorded, not silent (weekly audit re-queues these)"
       echo "     $(printf '%s' "$reason" | cut -c1-80)"
       # 🟥 수락 경로에도 «안 짚은 채널»을 띄운다. 실패 메시지에만 채널 목록이 있으면,
@@ -1360,6 +1471,206 @@ validate_defeater_leg() { # $1 = marker path
 }
 
 
+# ── ⑤ affected: — 「이 변경이 건드리는 것 + 열린 질문」 (2026-09-04, frontier absorption) ──
+# tenet: FH-T02 (기록의 속성) · FH-T07 (행위자가 읽는 자리)
+#
+# WHY: Anthropic AI-Native SDLC playbook `intent.md` 는 «Affected users and systems» ·
+# «Open questions» 두 칸을 싣는다. FH 는 두 칸으로 쪼개지 않는다 — 별도 필드마다 빈 칸이 하나씩
+# 늘어나는 것이 이 절 전체(soul-check·tenets·thirdparty)가 이미 피하는 모양이다. 한 줄 자유
+# 산문 안에 「건드리는 것」과 「열린 질문 = …」 관례를 같이 담는다.
+#
+# SCOPE — **채널 검사만**. `defeater:` 와 같은 형태(단일 줄·중복 차단·비공허)이지만 한 가지
+# 다르다: `defeater:` 는 「없음」을 정직한 선언으로 인정한다(반증 조건이 실제로 없을 수 있다).
+# `affected:` 는 다르다 — 어떤 변경이든 반드시 무언가를 건드린다(제로 영향은 명제상 없다). 그래서
+# 「없음/TBD/-」류 자리표시자만 있는 값은 정직한 부재가 아니라 **안 채운 것**이고, 차단한다.
+#
+# 옵셔널 필드다 — **없으면 통과**(soul-check:/tenets: 와 같은 패턴. 채택은 점진적이다).
+validate_affected_leg() { # $1 = marker path
+  local m="$1" n line body words
+  n=$(grep -cE '^[[:space:]]*affected:' "$m" 2>/dev/null); n=${n:-0}
+  if [ "$n" -eq 0 ]; then
+    # near-miss: 키 오타는 부재가 아니라 오타다 (defeater: 와 같은 이유 — 저자는 적었다고
+    # 믿는데 게이트는 못 읽는 것이 가장 조용한 실패다).
+    if grep -qE '^[[:space:]]*(affects:|affected[[:space:]]+:|affeted:|affcted:|effected:)' "$m" 2>/dev/null; then
+      echo "  ❌ FAIL — affected 키처럼 보이지만 정확히 'affected:' 가 아닌 줄이 있다."
+      grep -nE '^[[:space:]]*(affects:|affected[[:space:]]+:|affeted:|affcted:|effected:)' "$m" | sed 's/^/       /'
+      echo "     읽는 쪽은 정확히 'affected:' 만 읽는다."
+      return 1
+    fi
+    return 0   # 진짜 부재 — 옵셔널 필드, 채택은 점진적이다(soul-check:/tenets: 와 같은 형태)
+  fi
+  if [ "$n" -gt 1 ]; then
+    echo "  ❌ FAIL — 마커에 'affected:' 줄이 둘 이상이다."
+    grep -nE '^[[:space:]]*affected:' "$m" | sed 's/^/       /'
+    echo "     읽는 쪽은 첫 줄을 취하므로 나중에 붙인 정정이 조용히 가려진다."
+    return 1
+  fi
+  line=$(grep -m1 -E '^[[:space:]]*affected:' "$m" | sed -E 's/^[[:space:]]*affected:[[:space:]]*//')
+  body=$(printf '%s' "$line" | sed -E 's/^[[:space:]]+//; s/[[:space:]]+$//')
+  # 양끝 구두점/공백만 벗긴다 — 클래스 파싱(`tr -d '[:punct:]'` 류)은 한글 바이트를 지우는
+  # 이식성 결함을 낸 전례가 있다(defeater 의 2026-08-30 CI 리트로). 파라미터 확장만 쓴다.
+  _av="$body"
+  while :; do
+    case "$_av" in
+      ' '*|'	'*) _av="${_av# }"; _av="${_av#	}" ;;
+      *' '|*'	') _av="${_av% }"; _av="${_av%	}" ;;
+      *'.'|*'·'|*'—'|*'-'|*']') _av="${_av%?}" ;;
+      *) break ;;
+    esac
+  done
+  case "$(printf '%s' "$_av" | tr 'A-Z' 'a-z')" in
+    없음|none|n/a|na|tbd|todo|-|해당없음|'')
+      echo "  ❌ FAIL — affected 가 자리표시자뿐이다 ('$body')."
+      echo "     이 변경이 건드리는 것(사람·하네스·표면)과 아직 열린 질문을 한 줄로 적어라."
+      echo "       affected: 소비자 install 의 pre-commit 사용자(마커 형식) · 열린 질문 = 필드 강제 시점"
+      echo "     Append to: $m"
+      return 1 ;;
+  esac
+  # 🟥 헬퍼 부재를 «잔여 없음»으로 렌더하지 않는다 — 레인 스위트가 이 함수만 추출하면 헬퍼가
+  # 안 따라오고, 정의되지 않은 명령은 거짓이 되어 fail-open 이 된다(defeater 가 이미 겪었다).
+  if ! declare -f _marker_template_residue >/dev/null 2>&1; then
+    echo "  ❌ HARNESS-ERROR — _marker_template_residue 가 정의돼 있지 않다."
+    echo "     격리 실행이면 그 헬퍼도 같이 추출해야 한다. 부재는 «통과»가 아니다."
+    return 1
+  fi
+  if _marker_template_residue "$body"; then
+    echo "  ❌ FAIL — affected 가 힌트의 자리표시자 그대로다 (기록이 아직 안 쓰였다)."
+    return 1
+  fi
+  words=$(printf '%s' "$body" | wc -w | tr -d ' '); words=${words:-0}
+  if [ "$words" -lt 3 ]; then
+    echo "  ❌ FAIL — affected 가 공허하다 ($words 낱말). 건드리는 것 · 열린 질문을 적어라."
+    return 1
+  fi
+  echo "  ✅ affected 기록됨 ($words 낱말)"
+  return 0
+}
+
+
+# ── ⑥ oracle: — 「기대값을 무엇으로 정했나」 오라클 유형 (2026-09-05, ISO/IEC TR 29119-11 정렬 · crosswalk §4 M1) ──
+# tenet: FH-T02 (기록의 속성) · FH-T07 (행위자가 읽는 자리)
+#
+# WHY: TR 29119-11 의 핵심이 «테스트 오라클 문제»(기대값을 정할 수 없을 때 무엇으로 판정하나)다.
+# FH 는 known-pair · 결과 전 채점기 · «미측정 ≠ 0» 으로 그 문제를 다루지만, 마커는 «컨트롤이
+# 살아 있다» 까지만 적고 **어떤 종류의 오라클**로 판정했는지는 안 적었다 — 외부 독자가 첫 번째로
+# 묻는 칸이 비어 있었다(knowledge/shared/harness-core/iso_ai_standards_crosswalk.md §4 M1,
+# 운영자 승인 2026-09-05 «오라클 채널을 넣는 게 좋아 보인다면 마다할 이유가 없지»).
+#
+# SCOPE — **채널 검사만** (§Mechanization Boundary): 닫힌 enum(6) · 비공허 근거 · 단일 줄 · 근사키
+# 차단. 값의 진위(그 오라클이 정말 그 종류였나)는 안 본다. `none` 은 합법이되 **사유가 필수**다 —
+# «오라클 없이 판정했다» 는 기록이고, 사유 없는 none 은 «안 봤다» 와 구분이 안 된다.
+#
+# enum (형식: `oracle: <kind> — <근거>` · kind 뒤는 공백 · — · : · · · ( · . 중 하나, 또는 줄 끝)
+#   known-pair    양성·음성 컨트롤이 같은 실행에 있다 (계기 보정)
+#   metamorphic   입력 변환 → 기대 출력 변화 «관계»로 판정 (기대값 없이)
+#   back-to-back  다른 구현/계열이 같은 입력에 낸 출력을 대조 (cross-family 가 같은 diff 를 읽는 것)
+#   a-b           한 변수 ARM/CTRL 비교 (reps≥3). `A/B` 는 허용 표기
+#   human         사람이 기대값을 판정 (운영자 눈검증 · HITL)
+#   none          오라클 없음 — 사유 필수 (문서만 · 측정 없음 …)
+#
+# 근사키 규칙(한 문장, 여섯 문서면이 같은 문장을 쓴다): **키가 `oracle` 로 시작하는데 정확히 `oracle:`
+# 이 아닌 줄 전부**(`Oracle:` `oracles:` `oracle :` `oracle　:` `oracle_type:` `oracle-type:` 키만 있는
+# `oracle`) **+ 오타 `orcale:` `oralce:` `오라클:`** — 정상 `oracle:` 줄이 있어도 같이 있으면 차단한다
+# (cross-family codex #2: 정상 줄 뒤의 `Oracle: …` 정정이 조용히 가려지는 형태).
+#
+# 옵셔널 필드다 — **없으면 통과**(affected:/soul-check:/tenets: 와 같은 패턴. 채택은 점진적이다).
+# 힌트 템플릿에는 넣지 않는다 — 옵셔널 필드마다 빈 칸이 하나씩 느는 모양을 이 절이 피한다.
+# 소비처(정직하게): 오늘은 마커 grep 감사와 표준 정렬 증거뿐, 기계가 읽는 곳은 없다.
+# 명명된 잔여: 근거에 힌트 자리표시자 리터럴(`<...>`)이 있으면 차단된다(affected/defeater 와 같은 경계 —
+# 다른 표기로 적어라) · 전각 공백으로 «시작하는» 줄은 [[:space:]] 밖이라 못 본다.
+validate_oracle_leg() { # $1 = marker path
+  local m="$1" n nm line body kind k rest words
+  # near-miss — n 과 무관하게 항상 본다. `-n` 접두(N:) 뒤에서 정확한 소문자 `oracle:` 줄만 제외한다.
+  nm=$(grep -niE '^[[:space:]]*(oracle:|oracle([^:]|$)|orcale:|oralce:|오라클:)' "$m" 2>/dev/null | grep -vE '^[0-9]+:[[:space:]]*oracle:')
+  if [ -n "$nm" ]; then
+    echo "  ❌ FAIL — oracle 키처럼 보이지만 정확히 'oracle:' 가 아닌 줄이 있다."
+    printf '%s\n' "$nm" | sed 's/^/       /'
+    echo "     읽는 쪽은 정확히 'oracle:'(소문자, 콜론 바로 뒤) 만 읽는다 — 저자는 적었다고 믿는데 게이트는 못 읽는 것이 가장 조용한 실패다."
+    return 1
+  fi
+  n=$(grep -cE '^[[:space:]]*oracle:' "$m" 2>/dev/null); n=${n:-0}
+  if [ "$n" -eq 0 ]; then
+    return 0   # 진짜 부재 — 옵셔널 필드, 채택은 점진적이다
+  fi
+  if [ "$n" -gt 1 ]; then
+    echo "  ❌ FAIL — 마커에 'oracle:' 줄이 둘 이상이다."
+    grep -nE '^[[:space:]]*oracle:' "$m" | sed 's/^/       /'
+    echo "     읽는 쪽은 첫 줄을 취하므로 나중에 붙인 정정이 조용히 가려진다."
+    return 1
+  fi
+  line=$(grep -m1 -E '^[[:space:]]*oracle:' "$m" | sed -E 's/^[[:space:]]*oracle:[[:space:]]*//')
+  body=$(printf '%s' "$line" | sed -E 's/^[[:space:]]+//; s/[[:space:]]+$//')
+  if [ -z "$body" ]; then
+    echo "  ❌ FAIL — oracle 값이 비어 있다."
+    echo "     형식: oracle: <kind> — <근거>   kind ∈ known-pair · metamorphic · back-to-back · a-b · human · none"
+    return 1
+  fi
+  # kind = 앞쪽 [A-Za-z/-] 연속 — 하이픈은 kind 안에 있다(known-pair · back-to-back · a-b).
+  # 매치가 없으면 sed 가 body 를 그대로 돌려주고 enum 검사가 잡는다.
+  kind=$(printf '%s' "$body" | sed -E 's/^([A-Za-z/-]+).*$/\1/')
+  case "$kind" in "$body") rest="" ;; *) rest="${body#"$kind"}" ;; esac
+  # kind 바로 뒤는 구분자이거나 줄 끝이어야 한다 — enum 멤버가 «접두어»로만 맞는 값(known-pair2 ·
+  # human_review)이 통과하던 구멍(cross-family codex #1·#3).
+  case "$rest" in
+    ''|' '*|'	'*|'—'*|':'*|'·'*|'('*|'.'*) ;;
+    *)
+      echo "  ❌ FAIL — oracle kind 뒤에 구분자 없이 다른 문자가 붙어 있다 ('$body')."
+      echo "     형식: oracle: <kind> — <근거>   kind 뒤는 공백 · — · : · · · ( 중 하나 (예: known-pair2 · human_review 는 enum 밖)"
+      return 1 ;;
+  esac
+  k=$(printf '%s' "$kind" | tr 'A-Z' 'a-z'); [ "$k" = "a/b" ] && k="a-b"
+  case "$k" in
+    known-pair|metamorphic|back-to-back|a-b|human|none) ;;
+    *)
+      echo "  ❌ FAIL — oracle kind '$kind' 는 enum 밖이다."
+      echo "     kind ∈ known-pair · metamorphic · back-to-back · a-b · human · none   (형식: oracle: <kind> — <근거>)"
+      return 1 ;;
+  esac
+  # 근거 = kind 뒤. 양끝 구분자·공백만 벗긴다 — 리터럴 접두/접미 제거만 쓴다(`${x#?}` 는 C 로케일에서
+  # 다바이트 구분자의 한 바이트만 깎고, 클래스 파싱은 한글 바이트를 지운 전례가 있다 — affected 참조).
+  while :; do
+    case "$rest" in
+      ' '*) rest="${rest# }" ;;   '	'*) rest="${rest#	}" ;;
+      '—'*) rest="${rest#—}" ;;   '-'*) rest="${rest#-}" ;;   ':'*) rest="${rest#:}" ;;
+      '·'*) rest="${rest#·}" ;;   '('*) rest="${rest#(}" ;;   '.'*) rest="${rest#.}" ;;
+      *' ') rest="${rest% }" ;;   *'	') rest="${rest%	}" ;;
+      *')') rest="${rest%)}" ;;   *'.') rest="${rest%.}" ;;
+      *) break ;;
+    esac
+  done
+  case "$(printf '%s' "$rest" | tr 'A-Z' 'a-z')" in
+    없음|none|n/a|na|tbd|todo|-|해당없음|'')
+      if [ "$k" = none ]; then
+        echo "  ❌ FAIL — oracle: none 은 사유가 필수다 (지금: '$body')."
+        echo "     예: oracle: none — 문서만 변경, 측정 없음"
+      else
+        echo "  ❌ FAIL — oracle 근거가 자리표시자뿐이다 ('$body')."
+        echo "     예: oracle: known-pair — 레인 PASS/BLOCK 픽스처 양쪽 + 되돌림"
+      fi
+      echo "     Append to: $m"
+      return 1 ;;
+  esac
+  # 🟥 헬퍼 부재를 «잔여 없음»으로 렌더하지 않는다 — 격리 추출이 헬퍼를 안 가져오면 정의되지 않은
+  # 명령은 거짓이 되어 fail-open 이 된다(defeater·affected 가 이미 겪었다). 레인 o31 이 이 가지를 잰다.
+  if ! declare -f _marker_template_residue >/dev/null 2>&1; then
+    echo "  ❌ HARNESS-ERROR — _marker_template_residue 가 정의돼 있지 않다."
+    echo "     격리 실행이면 그 헬퍼도 같이 추출해야 한다. 부재는 «통과»가 아니다."
+    return 1
+  fi
+  if _marker_template_residue "$rest"; then
+    echo "  ❌ FAIL — oracle 근거가 힌트의 자리표시자 그대로다 (기록이 아직 안 쓰였다)."
+    return 1
+  fi
+  words=$(printf '%s' "$rest" | wc -w | tr -d ' '); words=${words:-0}
+  if [ "$words" -lt 2 ]; then
+    echo "  ❌ FAIL — oracle 근거가 공허하다 ($words 낱말). 무엇을 무엇과 대조했는지 적어라."
+    return 1
+  fi
+  echo "  ✅ oracle 기록됨 ($k · 근거 $words 낱말)"
+  return 0
+}
+
+
 SOUL_PRESENT_GRACE_DATE="2026-08-21"
 validate_soul_present_leg() { # $1 = marker path
   # ── ①영혼 존재 검사 (2026-08-21) ──────────────────────────────────────────────
@@ -2057,6 +2368,8 @@ if [ "$GATE_MODE" = "full" ]; then
     #    ([[feedback_built_but_not_wired]] — 오늘만 다섯 번째 얼굴).
     validate_soul_tenet_refs "$MARKER" || _SOUL_OK=0
     validate_defeater_leg "$MARKER" || _SOUL_OK=0
+    validate_affected_leg "$MARKER" || _SOUL_OK=0
+    validate_oracle_leg "$MARKER" || _SOUL_OK=0
     if [ "$_DEFENSE_OK" -eq 1 ] && [ "$_SOUL_OK" -eq 1 ] && validate_marker_floor "$MARKER" && validate_marker_axes_run "$MARKER" && validate_first_use_leg "$MARKER"; then
       echo "  ✅ PASS (marker confirmed + floor/axes fields valid:"
       echo "     .axes_23_passed_${BRANCH_SLUG}_${TODAY}.marker)"
@@ -2739,6 +3052,41 @@ else
   echo "  ⚠️  상주 유입 게이트 미설치 (scripts/residency_admission_check.sh) — skipped, not passed"
 fi
 
+# ── 수용-근거 한 줄 (보고 전용 — 절대 안 막는다) ────────────────────────────
+# WHY (2026-09-06, digest 답습 · arXiv:2609.04167 SWE-Gate): 그 논문은 «기능 테스트 통과»와
+# «리뷰 제약 충족»을 **따로** 채점하라고 처방한다 — 실측에서 기능 테스트를 통과한 수리 644 건 중
+# **221 건(34%)** 이 실제 PR 리뷰 코멘트에서 뽑은 제약을 어겼다. 한 숫자로 합치면 그 34% 가 안 보인다.
+# FH 도 같은 형태였다: 이 훅은 Axis 1(회귀)·레인·매니페스트가 통과하면 «ALL AXES PASSED» 라는
+# **합성 판정 하나**를 찍었고, 그동안 마커의 `crossfamily: DEGRADED_PANEL_UNUSED` 같은 값은
+# 출력 어디에도 안 나왔다. 통과는 통과인데 «무엇이 기록됐나»는 안 보이는 것이다.
+# 그래서 판정을 둘로 찍는다 — 위는 «초록인가», 아래는 «무엇이 기록됐나».
+# 🟥 §Mechanization Boundary: 이건 **채널**이다. 기록의 속성(어떤 값이 적혔나)만 찍고,
+#    그 값이 참인지는 판정하지 않으며 아무것도 막지 않는다. 차단은 기존 다리들이 그대로 한다.
+# Anchor: scripts/test_gate_two_verdicts_lanes.sh
+_acceptance_evidence_line() {   # $1 = marker path (비었거나 없으면 n/a)
+  local m="${1:-}" f v out=""
+  if [ -z "$m" ] || [ ! -f "$m" ]; then
+    printf 'acceptance-evidence: n/a (경량 게이트 — 이 경로는 마커를 읽지 않는다)\n'
+    return 0
+  fi
+  for f in crossfamily standpoint thirdparty oracle; do
+    v=$(sed -n "s/^[[:space:]]*${f}:[[:space:]]*\([^[:space:]][^[:space:]]*\).*/\1/p" "$m" | head -1)
+    # 🟥 첫 실사용(이 훅의 첫 두-판정 커밋)이 즉시 잡은 것: 값이 `checked(확인한 것 = …)` 처럼
+    #    **괄호 안에 공백**을 담으면 첫 토큰이 `checked(확인한` 으로 잘려, 값도 아니고 문법도
+    #    깨져 보이는 문자열이 찍힌다. 반면 `panel(codex,gemini)` · `tier2(qasp)` 는 괄호가 값의
+    #    일부라 살려야 한다. 판별자는 **괄호가 닫혔는가** 하나뿐이다 — 안 닫혔으면 여는 괄호
+    #    앞까지가 값이다. (마커 defeater 에 «관측될 것»으로 적어 둔 그 줄이 그대로 발화했다.)
+    case "$v" in
+      *'('*')'*) : ;;                      # panel(codex,gemini) — 괄호가 값의 일부
+      *'('*)     v="${v%%(*}" ;;           # checked(확인한 … — 잘린 괄호는 값이 아니다
+    esac
+    [ -n "$v" ] || v='(없음)'
+    out="${out}${out:+ · }${f}=${v}"
+  done
+  printf 'acceptance-evidence: %s\n' "$out"
+}
+
+
 # ── Verdict ───────────────────────────────────────────────────────────────────
 echo ""
 echo "══════════════════════════════════════════════"
@@ -2751,6 +3099,10 @@ if [ "$FAILED" -eq 1 ]; then
 fi
 
 echo " ✅ ALL AXES PASSED — commit allowed"
+echo "    functional         : PASS (Axis 1 회귀 · 레인 · 매니페스트)"
+echo "    $(_acceptance_evidence_line "${MARKER:-}")"
+echo "    🟥 둘은 한 판정이 아니다 — 위는 «초록인가», 아래는 «무엇이 기록됐나»다."
+echo "       형식이 통과했다는 뜻이지 그 값이 참이라는 뜻이 아니다 (arXiv:2609.04167)."
 echo "══════════════════════════════════════════════"
 echo ""
 exit 0