@chrono-meta/fh-gate 1.4.88 → 1.4.90

package/scripts/reviewer_capability_corpus.tsv

@@ -0,0 +1,124 @@
+# reviewer_capability_corpus.tsv — SHARED known-pair corpus for "can this model be an
+
+# adversarial reviewer?". Language-neutral DATA, deliberately not code.
+#
+# WHY DATA AND NOT A SHARED LIBRARY. The same judgment lives in at least three places, in
+# three languages, across a public/private repo boundary: a public gate hook (bash), a
+# field probe (shell), and a review backend (python). They cannot import each other —
+# different repos, and the private side's vocabulary contains identifiers that must not
+# reach a public repo. So the shareable artifact is the CORPUS, not the classifier: each
+# side implements in its own language and proves agreement by running these rows.
+#
+# Measured drift 2026-08-08, before this file existed: 19 probe ids, **10 disagreements**
+# between two of the implementations — and asymmetrically, 9 of them were the private side
+# reading INCAPABLE models as CAPABLE. A permissive drift on the side that faces a real
+# model catalog is the dangerous direction: it inflates panel size and family-diversity
+# counts simultaneously, so the defense reports green while the panel cannot review.
+#
+# RESIDENCY: this file is PUBLIC. Generic capability classes and publicly-documented model
+# families only. A corp/internal model id NEVER goes here — carry those in a local overlay
+# corpus alongside (gitignored), same two-layer shape as the public-surface pattern file.
+#
+# NAMESPACES — declare what you own, skip what you do not (OPA-bundle `roots` shape).
+# Two different things get classified under the same question and they are NOT interchangeable:
+#   ns:cli       sidecar / CLI names a panel is composed of  — `codex`, `gemini`, `agy`
+#   ns:model-id  concrete served model identifiers            — `voyage-3`, `glm-ocr`
+# A consumer that classifies model ids has no opinion on `codex`; a consumer that composes
+# panels has no opinion on `bge-m3`. Mixing them silently is a defect: measured 2026-08-08,
+# the first draft of this corpus put both in one list and a model-id classifier failed the
+# `codex` row — reported as implementation drift when it was corpus scope error. An adapter
+# MUST declare its namespaces and SKIP rows outside them EXPLICITLY (a skipped row is
+# reported, never silently counted as passing — unmeasured is not clean).
+#
+# FORMAT (tab-separated):  id <TAB> expected <TAB> ns:<namespace>/<class> <TAB> why
+#   expected ∈ CAPABLE | INCAPABLE | UNDECIDABLE
+#     CAPABLE      a generative model of a family known to return prose findings
+#     INCAPABLE    emits vectors / scores / labels / transcripts — cannot return a finding
+#     UNDECIDABLE  unrecognised. NOT "capable by default" — default-deny, because a
+#                  denylist cannot know that `voyage-3` is an embedding model. An
+#                  implementation that answers CAPABLE here is failing open.
+#
+#   THE CORPUS STATES GROUND TRUTH, NOT WHAT ANY IMPLEMENTATION CAN SEE. `voyage-3` IS an
+#   embedding model, so the row says INCAPABLE — even though a pattern classifier cannot
+#   tell from the string. Grading is therefore on OUTCOME SAFETY, not label identity:
+#
+#     hard FAIL   want ∈ {INCAPABLE, UNDECIDABLE} and got = CAPABLE     (permissive — ships a
+#                 broken panel; the only direction that can actually hurt)
+#     hard FAIL   want = CAPABLE and got ≠ CAPABLE                      (over-block — an
+#                 always-red gate teaches --no-verify)
+#     DEVIATION   INCAPABLE ↔ UNDECIDABLE in either direction           (reported, not failed:
+#                 both BLOCK under default-deny, so the outcome is identical)
+#
+#   This rule exists because the first draft graded on label identity and was silently fitted
+#   to one implementation's regex — `armorm` was written UNDECIDABLE and `voyage-3` INCAPABLE
+#   purely because that regex caught one and not the other. Two ids with the same property,
+#   two different standards, and the corpus was grading itself. Worse, it made "delete the
+#   row" the rational move for whoever maintained the weaker classifier.
+#
+# ORDERING INVARIANT the rows enforce: ineligibility must be tested BEFORE eligibility.
+# Rows marked `overlap` match a valid family AND an incapable class simultaneously; an
+# eligibility-first implementation admits them silently. They are the anchor for the ORDER,
+# not for the list.
+
+# ── CONTRACT PIN ───────────────────────────────────────────────────────────────
+#CORPUS-VERSION	2
+#CORPUS-SHA256	e0d8d83b9ae042e4
+#  Hash covers the DATA rows only (comments/format may be reworded without a version bump).
+#  Recompute EXACTLY this way — two ways of computing it is itself a drift source, and the
+#  first draft of this pin failed on a trailing-newline difference between two implementations:
+#      grep -E '^[^#[:space:]]' reviewer_capability_corpus.tsv | shasum -a 256 | cut -c1-16
+#  Every consumer recomputes it and compares. A mismatch is HARNESS_ERROR — not PASS, not FAIL:
+#  it means the consumer is reading a DIFFERENT corpus than the one this contract names, and a
+#  drifted local copy is the failure mode that makes every downstream instrument report healthy
+#  while nothing is actually shared. (Independent precedent: OPA bundle `roots`, test262/CNCF
+#  conformance-suite-as-contract; failure taxonomy: local-first resolution · silent skipping ·
+#  drifted duplicates.)
+
+# ── capable: generative families ────────────────────────────────────────────────
+codex	CAPABLE	ns:cli/generative	GPT-family agent CLI
+gpt-5.5	CAPABLE	ns:model-id/generative	GPT family
+gemini	CAPABLE	ns:cli/generative	Gemini family
+qwen3-32b	CAPABLE	ns:model-id/generative	Qwen family, generative variant
+glm-4.6	CAPABLE	ns:model-id/generative	GLM family, generative variant
+deepseek-v3	CAPABLE	ns:model-id/generative	DeepSeek family
+mistral-large	CAPABLE	ns:model-id/generative	Mistral family
+llama-4-70b	CAPABLE	ns:model-id/generative	Llama family
+
+# ── incapable: named by class token ─────────────────────────────────────────────
+text-embedding-3-large	INCAPABLE	ns:model-id/embedding	emits vectors
+some-reranker-v1	INCAPABLE	ns:model-id/reranker	emits scores
+generic-ocr-2b	INCAPABLE	ns:model-id/ocr	emits transcribed text, not judgment
+acme-safeguard-8b	INCAPABLE	ns:model-id/safeguard	classifier — emits labels
+text-moderation-latest	INCAPABLE	ns:model-id/moderation	classifier — emits labels
+whisper-large-v3	INCAPABLE	ns:model-id/speech	speech-to-text
+
+# ── incapable WITHOUT a class token in the name (the denylist's blind spot) ─────
+# These are why a denylist alone is insufficient and default-deny is required: nothing in
+# the string says "embedding". Every one is a real, publicly-documented model.
+voyage-3	INCAPABLE	ns:model-id/embedding	embedding model; name carries no class token
+bge-m3	INCAPABLE	ns:model-id/embedding	embedding model; name carries no class token
+gte-large	INCAPABLE	ns:model-id/embedding	embedding model; name carries no class token
+all-minilm-l6-v2	INCAPABLE	ns:model-id/embedding	embedding model; name carries no class token
+armorm	INCAPABLE	ns:model-id/reward	reward model — emits a scalar; opaque name, no class token
+starling-rm	INCAPABLE	ns:model-id/reward	reward model — emits a scalar
+cohere-rank-v3	INCAPABLE	ns:model-id/reranker	reranker named `rank`, not `rerank`
+
+# ── overlap: matches a VALID family AND an incapable class (ordering anchor) ────
+glm-ocr	INCAPABLE	ns:model-id/overlap	matches `glm` (capable) and `ocr` (incapable) — order decides
+qwen3-embedding-8b	INCAPABLE	ns:model-id/overlap	matches `qwen` (capable) and `embed` (incapable)
+snowflake-arctic-embed-l-v2.0	INCAPABLE	ns:model-id/overlap	family prefix unrecognised; `embed` decides
+
+# ── undecidable: unrecognised → default-deny, never assumed capable ─────────────
+some-new-model-x	UNDECIDABLE	ns:model-id/unknown	no known family; answering CAPABLE here is fail-open
+internal-model-7	UNDECIDABLE	ns:model-id/unknown	no known family
+codeguardian	UNDECIDABLE	ns:cli/unknown	NOT auto-incapable — a bare `guard` substring rule blocks this legitimately-named review tool; unrecognised, so default-deny applies, but as UNDECIDABLE not INCAPABLE
+
+# ── same-family exclusion (decorrelation, not capability) ──────────────────────
+# Capable models that must still be REJECTED as panel members when the governor is of that
+# family. Capability and decorrelation are different axes; an implementation that only
+# checks capability passes a same-family panel. Marked separately so an adapter that does
+# not own the decorrelation axis can skip this block explicitly rather than silently.
+#SAMEFAMILY	claude
+#SAMEFAMILY	opus
+#SAMEFAMILY	sonnet
+#SAMEFAMILY	haiku

package/scripts/selfcheck.sh

@@ -25,6 +25,74 @@ check() { # check <label> <cmd...>
     fail=1
   fi
 }
+# ⚠️ KNOWN DEFECT, NOT FIXED HERE — `check()` above has the same evidence-discarding shape the
+# lane blocks below were repaired for (2026-08-05): it decides on `"$@" 2>/dev/null` (stderr of the
+# DECIDING run is destroyed) and then re-runs to print. It is left alone deliberately: `check()` is
+# called by every `node --check` / `bash -n` line in this file, so changing it changes the whole
+# surface at once, which is a different job from repairing the four lane blocks (CLAUDE.md
+# §Added-Scope Gate question 2). `scripts/probe_scope_check.sh`'s caller near the probe-scope block
+# carries the same shape. Both are tracked separately — do NOT read the lane-block repair below as
+# having cleared this file.
+
+# _show_failure <captured-output> — print a FAILING suite's evidence without truncating it away.
+# Single source for all four lane blocks (a second copy would drift; the divergent-normalizer class).
+# WHY NOT `tail -N`: measured 2026-08-05 on sync_from_be_lanes.sh — output is 98 lines and a planted
+# lane failure at line ~22 is INVISIBLE to `tail -20` (0 hits), while the summary banner still reads
+# "1 failed". The reader gets a FAIL verdict sitting on top of passing log lines — the exact shape
+# this whole repair exists to remove. The failing-line extraction finds it (1 hit, known pair).
+# All four suites mark failures with `❌` (`no()` in sync_from_be_lanes.sh:21, `chk()` in the other
+# three) or an early `FAIL ` line when a subject is missing; grep handles the multi-byte glyph
+# (known pair: 1 hit on a ❌ line, 0 on a ✅-only line — verified, not assumed).
+_show_failure() {
+  local out="$1" fails n banner shown nonblank
+  # Whitespace-only counts as empty: guarding with [ -z "$out" ] alone let a suite emitting "   "
+  # fall into the died-early branch and print indented blank lines — silence rendered as evidence.
+  # SHELL PATTERN, NOT `tr`: the obvious `tr -d '[:space:]'` is a measured defect on BSD. Given a
+  # line containing invalid UTF-8, macOS `tr` aborts with `tr: Illegal byte sequence` and emits
+  # NOTHING, so the guard concludes "empty" and reports "no output captured" while real evidence is
+  # sitting in $out — the exact mis-report this helper exists to prevent, reintroduced by the guard
+  # against it. (GNU tr passes the bytes through; the arms disagree, and the failing arm is the
+  # author's own machine.) Case-matching is a shell builtin: no subprocess, no charset decoding, so
+  # invalid bytes cannot make it lie. Known pair: invalid-byte→nonblank, spaces/tabs/newlines→blank,
+  # ""→blank, "hello"→nonblank (4/4), while the tr form returns 0 bytes on arm 1.
+  case "$out" in *[![:space:]]*) nonblank=1 ;; *) nonblank= ;; esac
+  # NO LOCALE PIN HERE, and its absence is a measured result — same disposition, and same reasoning,
+  # as the pin `.github/workflows/validate.yml` removed after refuting its own locale hypothesis.
+  # Two model families independently suspected that matching the multi-byte `❌` would break under a
+  # C/POSIX locale (one filed it as UNCALIBRATED for the GNU arm, the other as an unpinned-locale
+  # defect), so `LC_ALL=C` was added — then both arms were actually measured:
+  #   BSD grep (macOS)      : C, UTF-8              → 1 hit each
+  #   GNU grep 3.12 (Linux) : C, C.UTF-8, unset     → 1 hit each; and with invalid UTF-8 bytes mixed
+  #                                                   in, the ❌ line still extracts (no binary-file
+  #                                                   collapse, the specific feared mode)
+  # The hypothesis is REFUTED on both arms, so the pin demonstrated nothing and was removed rather
+  # than kept as insurance — a knob retained because it might help is indistinguishable from one
+  # that does, and the next reader would inherit it as evidence that the danger is real.
+  fails=$(printf '%s\n' "$out" | grep -E '❌|^FAIL ' || true)
+  banner=$(printf '%s\n' "$out" | grep -E '════' | tail -1 || true)
+  if [ -n "$fails" ]; then
+    shown=$(printf '%s\n' "$fails" | head -25)
+    printf '%s\n' "$shown" | sed 's/^/     /'
+    n=$(printf '%s\n' "$fails" | wc -l | tr -d ' ')
+    [ "$n" -gt 25 ] && echo "     … ($((n - 25)) more failing lines not shown)"
+  elif [ -z "$nonblank" ]; then
+    echo "     (no output captured — the suite produced nothing before failing)"
+  else
+    echo "     (no ❌/FAIL line found — suite likely died early; showing tail)"
+    printf '%s\n' "$out" | tail -12 | sed 's/^/     /'
+  fi
+  # Summary banner: matched by shape, not by position. A blind `tail -2` re-printed lines already
+  # shown above (measured: a ❌ within the last 2 lines appeared twice, and the "N more not shown"
+  # notice was immediately followed by one of the lines it had just declined to show), and on empty
+  # input it emitted a stray indented line. Print it only when it exists and is not already on screen.
+  # Dedupe against what was ACTUALLY PRINTED ($shown), not against the full $fails set. Searching
+  # $fails suppressed the banner whenever a failing line beyond the head -25 cut merely contained
+  # the banner text — i.e. it hid the banner precisely because a line the reader never saw mentioned
+  # it. $shown is empty in the non-fails branches, so the banner prints there as before.
+  if [ -n "$banner" ] && ! printf '%s\n' "${shown:-}" | grep -qF -- "$banner"; then
+    printf '     %s\n' "$banner"
+  fi
+}
 
 # Node executables (npm-shipped)
 for f in bin/*.js; do
@@ -34,7 +102,18 @@ done
 # Codex adapter drift: the thin Codex runtime must keep reading canonical FH
 # skill/agent surfaces without silently accepting Claude-native primitives as
 # Codex-native.
-check "fh-codex-doctor --strict" bash -c 'node bin/fh-codex-doctor.js --strict >/dev/null'
+# NOT via check(): that helper decides on a run whose stderr is discarded, and this call site used to
+# additionally discard the subject's STDOUT (`--strict >/dev/null`). fh-codex-doctor writes 100% of
+# its drift diagnostics to stdout (measured 2026-08-05: 686 B stdout / 0 B stderr), so a failure
+# printed a bare `FAIL` line carrying no diagnosis at all — worse than the truncation this session
+# repaired in the lane blocks. Fixed at the call site; check() itself is a separate job (see above).
+if _out=$(node bin/fh-codex-doctor.js --strict 2>&1); then
+  echo "PASS  fh-codex-doctor --strict"
+else
+  echo "FAIL  fh-codex-doctor --strict"
+  _show_failure "$_out"
+  fail=1
+fi
 
 # Bash surface: npm-shipped scripts + local bin wrappers + gate-chain infra
 for f in scripts/*.sh bin/fh-gate bin/fh-run bin/fh-goal \
@@ -132,6 +211,45 @@ else
   fail=1
 fi
 
+# embedded --self-test suites (compaction_probe · judgment_circuit_lint · novelty_claim_check).
+# These three carry their lanes INSIDE the script (`--self-test`) rather than in a sibling
+# test_*_lanes.sh, so the name-list wiring above skipped them silently: 48 lanes existed and ran
+# only when a human typed the command. That is built-but-not-wired applied to the anchors themselves
+# — a later edit that breaks a lane stays green everywhere the project actually checks
+# (high re-review 2026-08-08). Same shape as the block above: subject absent → SKIP, subject present
+# but self-test missing → FAIL, never a silent pass.
+for _subj in compaction_probe judgment_circuit_lint novelty_claim_check; do
+  if [ ! -f "scripts/$_subj.sh" ]; then
+    echo "SKIP  $_subj --self-test (subject scripts/$_subj.sh absent)"
+  else
+    # ⚠️ **문자열 존재로 판정하지 마라.** 초판은 `grep -q -- '--self-test'` 였는데, 그 문자열은
+    # 헤더 주석과 usage echo 에도 있어서 **디스패처 한 줄만 지워도 여전히 매치**한다. 그리고
+    # 인식 못 한 모드에서 스크립트가 usage 를 찍고 exit 0 을 내므로, selfcheck 는 rc=0 을 보고
+    # 조용히 통과했다 — 25개 레인이 통째로 사라져도 `npm test` 는 PASS (high 3차 리뷰 실측).
+    # 존재검사가 진위를 못 본다는 그 클래스의 재발이다. **실행이 일어났다는 증거**를 요구한다.
+    # `< /dev/null` 필수: 인식 못 한 모드로 떨어지면 스크립트가 stdin 을 기다려 **무한 대기**한다
+    # (실측 — 디스패처 제거 known-negative 가 2분 타임아웃). CI 를 멈추는 건 조용한 통과보다 나쁘다.
+    # `timeout` 은 GNU coreutils 이고 **stock macOS 에 없다**. 가용성 확인 없이 부르면 rc=127 +
+    # 빈 출력 → 아래 `*)` 가 발동해 "dispatcher missing?" 이라는 **틀린 원인**으로 거짓 FAIL 이
+    # 난다(실측: homebrew 없는 PATH 에서 3개 subject 전부). 소비자 머신에서 `npm test` 와
+    # `prepublishOnly` 를 깨뜨리는 경로다. 정답 폼은 이미 레포에 있다(sync-from-be.sh:134).
+    # 없으면 무한대기 방지를 잃는 대신 도는 쪽을 택한다 — `< /dev/null` 이 그 방어의 본체다.
+    local _to=""; command -v timeout >/dev/null 2>&1 && _to="timeout 120"
+    _st_out="$($_to bash "scripts/$_subj.sh" --self-test < /dev/null 2>&1)"; _st_rc=$?
+    case "$_st_out" in
+      *캘리브레이션*) : ;;
+      *) echo "FAIL  $_subj: --self-test produced no calibration verdict (dispatcher missing?)"
+         printf '%s\n' "$_st_out" | head -3 | sed 's/^/      /'
+         fail=1; _st_rc=0 ;;   # 이미 FAIL 로 셌으니 아래서 중복 계상 안 한다
+    esac
+    if [ "$_st_rc" -ne 0 ]; then
+      echo "FAIL  $_subj --self-test (exit $_st_rc)"
+      printf '%s\n' "$_st_out" | tail -6 | sed 's/^/      /'
+      fail=1
+    fi
+  fi
+done
+
 # memory-link-check — the memory store is a GRAPH (memory_intent_recall.md: nodes=files,
 # edges=[[links]], recall walks one hop). Measured 2026-07-28: 50 of 872 edges pointed at a note
 # that existed under a different separator and 22 at nothing — a dead edge returns nothing and is
@@ -441,34 +559,81 @@ else
   fail=1
 fi
 
+# utterance landing check — the close chain's CONTENT anchor, and it has to be RUN, not parsed.
+# Measured 2026-08-08 on the branch that introduced it: the only thing in this file that touched
+# `scripts/utterance_landing_check.sh` was the `bash -n` syntax sweep at the top. Syntax passing is
+# not the instrument working, so the script shipped via files[] with zero behavioural callers —
+# [[feedback_built_but_not_wired]] in its purest form, where the sole caller is prose in CLAUDE.md.
+#
+# What the self-test defends is specifically the DEGRADE DIRECTION. This checker's whole reason for
+# existing is that a dead grep prints zero hits and zero hits read as "nothing landed" — a fail-open
+# that manufactures a clean verdict out of a broken instrument. Its known-pair set pins that apart:
+# a genuine miss must exit 1 while a dead control must exit 10, and 10 must never collapse into 1.
+# Left unrun, the file rots exactly where it is load-bearing and nothing here would notice.
+# Absence is a FAIL, not a SKIP — and the distinction is mechanical, not stylistic. The SKIP arm
+# above for `probe_scope_check.sh` is correct because that file genuinely never ships; this one is
+# listed in package.json files[], so in BOTH a source tree and an installed package it must be here.
+# A SKIP would convert `rm scripts/utterance_landing_check.sh` into a green run — deletion as a
+# clean bill of health, which is the same fail-open shape the checker itself exists to refuse.
+if [ ! -f scripts/utterance_landing_check.sh ]; then
+  echo "FAIL  utterance_landing_check.sh: missing — it ships via package.json files[], so absence is deletion, not package mode"
+  fail=1
+elif _out=$(bash scripts/utterance_landing_check.sh --self-test 2>&1); then
+  echo "PASS  utterance_landing_check.sh (known-pair self-test: control-death → 10, target-miss → 1)"
+else
+  echo "FAIL  utterance_landing_check.sh: self-test failed — the close-chain content anchor cannot be trusted"
+  _show_failure "$_out"
+  fail=1
+fi
+
 # tag/version consistency guard. Wired with the guard it anchors: the guard exists because a wrong
 # tag reached the remote and a publish from the wrong tree was stopped only by npm's own collision
 # check, so an unrun anchor here would be the same luck-as-floor arrangement one layer up.
 if [ ! -f templates/.git-hooks/pre-push ]; then
   echo "SKIP  test_tag_version_lanes.sh (subject templates/.git-hooks/pre-push absent)"
 elif [ -f scripts/test_tag_version_lanes.sh ]; then
-  if ! bash scripts/test_tag_version_lanes.sh >/dev/null 2>&1; then
+  # RUN-ONCE, CAPTURE (2026-08-05) — rationale in the sync_from_be_lanes block later in this file.
+  if _out=$(bash scripts/test_tag_version_lanes.sh 2>&1); then
+    echo "PASS  test_tag_version_lanes.sh (mismatch blocks · match silent · scope · override)"
+  else
     echo "FAIL  test_tag_version_lanes.sh: the tag/version guard would mis-route"
-    bash scripts/test_tag_version_lanes.sh 2>&1 | tail -12
+    _show_failure "$_out"
     fail=1
-  else
-    echo "PASS  test_tag_version_lanes.sh (mismatch blocks · match silent · scope · override)"
   fi
 else
   echo "FAIL  test_tag_version_lanes.sh: pre-push present but its anchor is missing"
   fail=1
 fi
 
+# Shipped-manifest version lockstep. Distinct from the tag lane above: that one compares the git TAG
+# to package.json; this one compares package.json to every version string it SHIPS — including the
+# per-plugin entries inside marketplace.json, which the tag lane never opens. Measured 2026-08-06:
+# a bump left the second marketplace entry behind and the tag lane passed 8/8 straight through it.
+if [ ! -f scripts/version_lockstep_check.sh ]; then
+  echo "SKIP  test_version_lockstep_lanes.sh (subject scripts/version_lockstep_check.sh absent)"
+elif [ -f scripts/test_version_lockstep_lanes.sh ]; then
+  if _out=$(bash scripts/test_version_lockstep_lanes.sh 2>&1); then
+    echo "PASS  test_version_lockstep_lanes.sh (drift blocks · aligned silent · unreadable = exit 2, not pass)"
+  else
+    echo "FAIL  test_version_lockstep_lanes.sh: the shipped-manifest lockstep guard would mis-route"
+    _show_failure "$_out"
+    fail=1
+  fi
+else
+  echo "FAIL  test_version_lockstep_lanes.sh: version_lockstep_check.sh present but its anchor is missing"
+  fail=1
+fi
+
 # ④-e dispatch-log reconciliation + its tally hook. Wired in the same commit that ships them: the
 # obligation they mechanize lost 20/20 in a single session, so leaving the checker itself unrun
 # would be the same defect one layer up.
 if [ -f scripts/test_dispatch_log_lanes.sh ]; then
-  if ! bash scripts/test_dispatch_log_lanes.sh >/dev/null 2>&1; then
+  if _out=$(bash scripts/test_dispatch_log_lanes.sh 2>&1); then
+    echo "PASS  test_dispatch_log_lanes.sh (date-spelling + verdict + tally-hook lanes)"
+  else
     echo "FAIL  test_dispatch_log_lanes.sh: the dispatch-log reconciliation would mis-report"
-    bash scripts/test_dispatch_log_lanes.sh 2>&1 | tail -14
+    _show_failure "$_out"
     fail=1
-  else
-    echo "PASS  test_dispatch_log_lanes.sh (date-spelling + verdict + tally-hook lanes)"
   fi
 fi
 
@@ -477,12 +642,12 @@ fi
 # through in silence, then a package discriminator keyed on a file that actually ships. Both are
 # known-POSITIVEs in the suite, so neither can come back green.
 if [ -f scripts/test_selfcheck_state_lanes.sh ]; then
-  if ! bash scripts/test_selfcheck_state_lanes.sh >/dev/null 2>&1; then
+  if _out=$(bash scripts/test_selfcheck_state_lanes.sh 2>&1); then
+    echo "PASS  test_selfcheck_state_lanes.sh (four input states + both shipped mis-routings)"
+  else
     echo "FAIL  test_selfcheck_state_lanes.sh: a subject-presence discriminator would mis-route"
-    bash scripts/test_selfcheck_state_lanes.sh 2>&1 | tail -12
+    _show_failure "$_out"
     fail=1
-  else
-    echo "PASS  test_selfcheck_state_lanes.sh (four input states + both shipped mis-routings)"
   fi
 fi
 
@@ -495,12 +660,34 @@ fi
 if [ ! -f scripts/sync-from-be.sh ]; then
   echo "SKIP  sync_from_be_lanes.sh (subject scripts/sync-from-be.sh absent)"
 elif [ -f scripts/sync_from_be_lanes.sh ]; then
-  if ! bash scripts/sync_from_be_lanes.sh >/dev/null 2>&1; then
+  # ── RUN-ONCE, CAPTURE — canonical note for the four LANE BLOCKS (2026-08-05) ─────────────────
+  # SCOPE, stated precisely because the first draft of this note over-claimed: this covers the four
+  # lane blocks only (tag-version · dispatch-log · selfcheck-state · sync_from_be). The same
+  # evidence-discarding shape SURVIVES in `check()` at the top of this file and in the
+  # probe_scope_check caller — both named there, both deliberately out of scope, both still open.
+  # An adversarial round caught the original "all four sites in this file" wording as a false
+  # completion claim: it would have stopped the next reader from re-searching. Half a fix with a
+  # done-label on it is worse than half a fix.
+  # The old form ran the suite twice: once discarded to /dev/null to decide, once re-run to print.
+  # For a DETERMINISTIC suite that is merely wasteful. For a non-deterministic one it destroys the
+  # evidence: the failing run's output goes to /dev/null and the reader is shown the SECOND run,
+  # which may pass. Measured here 2026-08-04 (run 30955950695) — CI printed
+  #     FAIL  sync_from_be_lanes.sh: return-path lanes failed
+  #     ════ lanes: 70 passed · 0 failed ════
+  # i.e. a FAIL verdict over a PASSING transcript, and the actual failure was never recorded
+  # anywhere. That is why this lane sat "flaky, cause unknown" on the session card for two days:
+  # the instrument was discarding the only evidence that could close it. Reproduced as a known
+  # pair before this edit (arm A run-twice → evidence lost + self-contradiction; arm B run-once →
+  # evidence preserved), so the fix is anchored, not asserted.
+  # NOTE this does NOT make the suite deterministic — the underlying non-determinism is still
+  # UNDIAGNOSED and stays an open item. It makes the next occurrence diagnosable instead of
+  # self-erasing. Do not read a green CI after this change as the flake being fixed.
+  if _out=$(bash scripts/sync_from_be_lanes.sh 2>&1); then
+    echo "PASS  sync_from_be_lanes.sh (return-path lanes)"
+  else
     echo "FAIL  sync_from_be_lanes.sh: return-path lanes failed"
-    bash scripts/sync_from_be_lanes.sh 2>&1 | tail -20
+    _show_failure "$_out"
     fail=1
-  else
-    echo "PASS  sync_from_be_lanes.sh (return-path lanes)"
   fi
 else
   echo "FAIL  sync_from_be_lanes.sh: sync-from-be.sh present but its anchor is missing"

package/scripts/session_close_check.sh

@@ -15,6 +15,9 @@
 
 set -uo pipefail
 
+# 상속된 git 환경변수를 끊는다 — export 된 GIT_DIR 이 있으면 `git -C "$FH"` 가 인자로 받은
+# 레포가 아니라 그 레포를 잰다(Axis 2 at-floor LOW, 2026-08-06). READ-ONLY 체커라 부작용 없음.
+unset GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE
 FH="${1:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
 TODAY=$(date +%Y-%m-%d)
 CARD="$FH/tracks/_meta/reference_next_session_starter.md"
@@ -25,11 +28,58 @@ _mtime() { stat -c %Y "$1" 2>/dev/null || stat -f %m "$1" 2>/dev/null || echo 0;
 echo "── session close check: $FH ($TODAY) ──"
 
 # ① status snapshot — uncommitted / unpushed work must be known, not forgotten
-DIRTY=$(git -C "$FH" status --porcelain 2>/dev/null | wc -l | tr -d ' ')
-UNPUSHED=$(git -C "$FH" log --oneline @{u}.. 2>/dev/null | wc -l | tr -d ' ')
-[ "$DIRTY" -gt 0 ] && echo "⚠️  ① $DIRTY uncommitted path(s) — decide: commit or leave deliberately"
-[ "$UNPUSHED" -gt 0 ] && echo "⚠️  ① $UNPUSHED unpushed commit(s) — push before close or record why"
-[ "$DIRTY" -eq 0 ] && [ "$UNPUSHED" -eq 0 ] && echo "✅ ① working tree clean, nothing unpushed"
+# DIRTY 도 같은 형태였다 — `status --porcelain 2>/dev/null | wc -l` 은 git 이 죽어도 0 을 세어
+# "깨끗함"으로 승격된다(재현: `.git/index` 손상 → exit 128, 출력 0줄). 종료코드를 먼저 본다.
+# ⚠️ 이 줄은 **바로 아래 UNPUSHED 수리와 같은 결함**이었고, 처음엔 아래만 고쳤다 —
+# 반쪽 수리를 고치는 커밋에서 반쪽 수리를 할 뻔했다(Axis 2 챌린저가 잡음, 2026-08-06).
+# `--untracked-files=all` 은 `status.showUntrackedFiles=no` config 를 덮어쓴다. 그 config 아래에서는
+# git 이 **성공적으로 침묵**해(exit 0 · 빈 출력) 종료코드 가드로도 안 잡힌다 — 부재가 다시
+# "깨끗함"으로 렌더된다(Axis 2 at-floor MED, 재현: 미추적 파일 1건이 0 으로 보고됨).
+if _st=$(git -C "$FH" status --porcelain --untracked-files=all 2>/dev/null); then
+  DIRTY_KNOWN=1
+  DIRTY=$(printf '%s' "$_st" | grep -c . || true)
+else
+  DIRTY_KNOWN=0
+  DIRTY=0
+fi
+# upstream 유무를 **먼저 판정**한다. `@{u}..` 는 upstream 이 없으면 실패해 0줄을 내고, 그 0을
+# `wc -l` 이 0으로 세어 "nothing unpushed" 로 승격된다 — **한 번도 머신을 떠난 적 없는 커밋이
+# '푸시할 것 없음'으로 읽히는 fail-open**. 부재를 깨끗함으로 읽는 것이라 0 을 신뢰하면 안 된다.
+# (downstream fork's review lane caught it first; this file is the upstream original — 2026-08-06.)
+if git -C "$FH" rev-parse --abbrev-ref '@{u}' >/dev/null 2>&1; then
+  UPSTREAM_KNOWN=1
+  UNPUSHED=$(git -C "$FH" log --oneline @{u}.. 2>/dev/null | wc -l | tr -d ' ')
+else
+  UPSTREAM_KNOWN=0
+  UNPUSHED=0
+fi
+[ "$DIRTY_KNOWN" -eq 0 ] && echo "⚠️  ① UNMEASURED — git status failed; working-tree cleanliness is UNKNOWN, not clean"
+[ "$DIRTY_KNOWN" -eq 1 ] && [ "$DIRTY" -gt 0 ] && echo "⚠️  ① $DIRTY uncommitted path(s) — decide: commit or leave deliberately"
+[ "$UPSTREAM_KNOWN" -eq 0 ] && echo "⚠️  ① UNMEASURED — no upstream for this branch; unpushed count is UNKNOWN, not zero"
+[ "$UPSTREAM_KNOWN" -eq 1 ] && [ "$UNPUSHED" -gt 0 ] && echo "⚠️  ① $UNPUSHED unpushed commit(s) — push before close or record why"
+# "as of last fetch" — 원격을 조회하지 않는다. 로컬 remote-tracking ref 가 낡았으면 이 0 도 낡은 값이다
+# (Axis 2 챌린저 MED, 2026-08-06). fetch 를 넣지 않은 것은 마감 체커가 READ-ONLY·오프라인 안전이기 때문.
+# 추적 파일이 assume-unchanged/skip-worktree 로 마킹돼 있으면 그 수정은 porcelain 에 **안 뜬다** —
+# `-uall` 로도 안 잡히는 별개 계기다(Axis 2 at-floor MED, 재현 확인).
+MASKED=$(git -C "$FH" ls-files -v 2>/dev/null | grep -c '^[a-z]' || true)
+[ "${MASKED:-0}" -gt 0 ] \
+  && echo "⚠️  ① $MASKED file(s) assume-unchanged/skip-worktree — their edits are INVISIBLE here"
+
+# ★ 잰 범위 ≠ 주장 범위 (Axis 2 at-floor HIGH, 2026-08-06).
+# `@{u}..` 는 **현재 브랜치만** 잰다. 다른 로컬 브랜치에만 있는 미푸시 커밋은 통째로 안 보이는데
+# 화면 문구는 "nothing unpushed"(레포 전체)라고 말한다 — 이 파일의 존재 이유 정중앙이다.
+# 재현: 다른 브랜치에 미푸시 커밋 1건 → `✅ nothing unpushed` 가 그대로 떴다.
+# 원격이 하나도 없으면 이 값이 전 커밋 수로 부풀므로 원격 존재를 먼저 가드한다.
+OTHER_UNPUSHED=0
+if [ -n "$(git -C "$FH" remote 2>/dev/null)" ]; then
+  OTHER_UNPUSHED=$(git -C "$FH" log --branches --not --remotes --oneline 2>/dev/null | wc -l | tr -d ' ')
+fi
+[ "${OTHER_UNPUSHED:-0}" -gt 0 ] \
+  && echo "⚠️  ① $OTHER_UNPUSHED commit(s) on local branches never pushed anywhere (all-branch scan)"
+
+[ "$DIRTY_KNOWN" -eq 1 ] && [ "$DIRTY" -eq 0 ] && [ "$UPSTREAM_KNOWN" -eq 1 ] && [ "$UNPUSHED" -eq 0 ] \
+  && [ "${OTHER_UNPUSHED:-0}" -eq 0 ] && [ "${MASKED:-0}" -eq 0 ] \
+  && echo "✅ ① working tree clean, nothing unpushed anywhere (as of last fetch)"
 
 # ①-b open-PR sweep (surface-not-auto — requires gh; skip silently offline)
 if command -v gh >/dev/null 2>&1; then

package/scripts/test_marker_crossfamily_lanes.sh

@@ -0,0 +1,132 @@
+#!/usr/bin/env bash
+# test_marker_crossfamily_lanes.sh — regression fixtures for pre-commit's
+# validate_crossfamily_leg (typed cross-family verdict, 2026-08-08).
+#
+# WHY: the `crossfamily:` marker line has been REQUIRED on load-bearing changes since
+# 2026-06 (commit c1fa459) — but only its PRESENCE was checked, so the value was free
+# prose. That is how a false one shipped: a sibling harness recorded
+# `crossfamily: none this round — 도달 불가` (unreachable), the claim was later found
+# FALSE, and a later session cited it as grounds. Presence-checking catches silence; it
+# cannot catch a confident wrong answer. This lane types the value.
+#
+# Fixtures assert BOTH directions (known-pair): every intended shape is admitted, and
+# every hole the lane closes still blocks. A test that only asserts BLOCK cannot tell
+# "blocked" from "blocked for the wrong reason"; one that only asserts PASS cannot see a
+# lane that admits everything.
+#
+# Usage: bash scripts/test_marker_crossfamily_lanes.sh   Exit: 0 = all behave; 1 = regression.
+
+set -uo pipefail
+REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+HOOK="$REPO_ROOT/templates/.git-hooks/pre-commit"
+T=$(mktemp -d); trap 'rm -rf "$T"' EXIT
+
+sed -n '/^validate_crossfamily_leg()/,/^}/p' "$HOOK" > "$T/fn.sh"
+
+# Instrument calibration: an empty extraction would let every fixture "pass" against
+# nothing. Assert the function body actually arrived before measuring anything.
+if ! grep -q 'DEGRADED_PANEL_UNUSED' "$T/fn.sh"; then
+  echo "❌ HARNESS-ERROR — validate_crossfamily_leg did not extract from $HOOK."
+  echo "   Fixtures below would measure an empty function. Aborting rather than reporting green."
+  exit 1
+fi
+
+mk() { printf "$1" > "$T/$2"; }   # $1 = marker body, $2 = fixture name
+run() { bash -c "source '$T/fn.sh'; validate_crossfamily_leg '$1'" >/dev/null 2>&1; }
+
+FAIL=0; N=0
+check() { # $1=fixture $2=expected(PASS|BLOCK) $3=label
+  N=$((N+1))
+  if run "$T/$1"; then got=PASS; else got=BLOCK; fi
+  if [ "$got" = "$2" ]; then echo "✅ $3 → $got"; else echo "❌ $3 → $got (expected $2)"; FAIL=1; fi
+}
+
+echo "── admitted shapes (must PASS) ──"
+mk 'crossfamily: panel(codex,gemini) — R1..R3, 9 findings, 8 fixed 1 refuted, CONVERGED\n' k1
+check k1 PASS "panel() with family list + verdict"
+mk 'crossfamily: panel(codex, gemini) — spaced list, the S-grade over-block\n' k1b
+check k1b PASS "panel(codex, gemini) — SPACE after comma (was truncated to 'panel(codex,')"
+mk 'crossfamily: declined\n' k3
+check k3 PASS "declined (operator chose this floor — not a degrade)"
+mk 'crossfamily: DEGRADED_SINGLE_FAMILY — probed codex/agy/4090, 0 capable reachable\n' k4
+check k4 PASS "DEGRADED_SINGLE_FAMILY + substantive reason"
+mk 'crossfamily: UNKNOWN — consent unset, panel not probed this round\n' k5
+check k5 PASS "UNKNOWN + reason naming why it was not probed"
+mk 'crossfamily: DEGRADED_PANEL_UNUSED — codex/agy/gemini reachable, not recruited (scope)\n' k6
+check k6 PASS "DEGRADED_PANEL_UNUSED + reason naming the reachable families"
+mk 'crossfamily: panel(qwen,gpt-oss,glm) — clean, 0 findings\n' k7
+check k7 PASS "capable families only — guard does not over-block a real panel"
+
+echo "── closed holes (must BLOCK) ──"
+mk 'axis2-evidence: PASS no-S\n' b1
+check b1 BLOCK "no crossfamily line at all (silence — the original guard, still intact)"
+mk 'crossfamily: none this round — 인라인 same-family\n' b2
+check b2 BLOCK "'none' free prose (the shape found on disk)"
+mk 'crossfamily: none this round — 도달 불가\n' b3
+check b3 BLOCK "'none' asserting unreachable (the FALSE one that shipped)"
+mk 'crossfamily: none\n' b4
+check b4 BLOCK "bare 'none' (merges could-not / did-not / did-not-look)"
+mk 'crossfamily: DEGRADED_SINGLE_FAMILY\n' b5
+check b5 BLOCK "degrade value with no reason (silent degrade — the whole point)"
+mk 'crossfamily: UNKNOWN\n' b6
+check b6 BLOCK "UNKNOWN with no reason (unprobed rendered as zero)"
+mk 'crossfamily: DEGRADED_PANEL_UNUSED\n' b7
+check b7 BLOCK "PANEL_UNUSED with no reason ('did not' passing as 'could not')"
+mk 'crossfamily: DEGRADED_SINGLE_FAMILY — degraded\n' b8
+check b8 BLOCK "reason too vacuous (names no probe and no grounds)"
+mk 'crossfamily: panel\n' b9
+check b9 BLOCK "bare panel claim naming no family"
+mk 'crossfamily: panel()\n' b10
+check b10 BLOCK "panel() with empty family list"
+mk 'crossfamily: DEGRADED\n' b11
+check b11 BLOCK "near-miss token (not an enum value)"
+mk 'crossfamily: codex/gpt-5.5 — R1..R4, 16 findings, CONVERGED\n' b12
+check b12 BLOCK "legacy free-form engine string (pre-typed convention) now rejected"
+
+echo "── cross-family review findings (agy/Gemini 3.1 Pro, 2026-08-08) ──"
+mk 'crossfamily: panel(claude) — reviewed by another claude session\n' x1
+check x1 BLOCK "panel names the AUTHOR'S own family (decorrelation gate not seeing decorrelation)"
+mk 'crossfamily: panel(opus,sonnet) — two claude tiers\n' x2
+check x2 BLOCK "two same-family tiers dressed as a 2-family panel"
+mk 'crossfamily: panel(none)\n' x3
+check x3 BLOCK "panel(none) — a non-run laundered through the parens"
+mk 'crossfamily: panel(unprobed)\n' x4
+check x4 BLOCK "panel(unprobed) — same laundering, other token"
+mk 'crossfamily: single-family\n' x5
+check x5 BLOCK "single-family on a LOAD-BEARING change (free no-ack bypass of the lane)"
+mk 'crossfamily: UNKNOWN — 0\n' x6
+check x6 BLOCK "grounds '0' (porous non-vacuity: bare digit passed)"
+mk 'crossfamily: UNKNOWN — problem\n' x7
+check x7 BLOCK "grounds 'problem' (matched on substring 'prob')"
+mk 'crossfamily: UNKNOWN — client error\n' x8
+check x8 BLOCK "grounds 'client error' (matched on substring 'cli')"
+mk 'crossfamily: panel(voyage-3,bge-m3) — 2 families\n' x9
+check x9 BLOCK "embedding models WITHOUT 'embed' in the name (denylist false negative)"
+mk 'crossfamily: panel(armorm,starling-rm) — 2 families\n' x10
+check x10 BLOCK "reward models emitting scalars, not findings"
+mk 'crossfamily: panel(cohere-rank-v3) — reranker named 'rank' not 'rerank'\n' x11
+check x11 BLOCK "reranker named 'rank' (denylist false negative)"
+mk 'crossfamily: DEGRADED_SINGLE_FAMILY — agy sidecar daemon crashed on startup, none reachable\n' x12
+check x12 PASS  "grounds naming agy (was rejected — keyword list omitted it)"
+
+mk 'crossfamily: single-family\ncrossfamily: DEGRADED_SINGLE_FAMILY — probed codex/agy, 0 reachable\n' x13
+check x13 BLOCK "two crossfamily lines — appended correction shadowed by stale first (codex net-new)"
+
+echo "── review-capability guard (pmh-dev #41 field measurement) ──"
+mk 'crossfamily: panel(qwen,embed,embed) — 3 families\n' c1
+check c1 BLOCK "embeddings counted as panel members (the measured false panel)"
+mk 'crossfamily: panel(embed,rerank,ocr) — 3 families\n' c2
+check c2 BLOCK "every member incapable — '3 families', 0 reviewers"
+mk 'crossfamily: panel(gpt-oss,safeguard) — 2 families\n' c3
+check c3 BLOCK "safeguard classifier padding one real family"
+# Ordering invariant: ineligibility is tested FIRST. Both tokens ALSO match a valid
+# family (glm-ocr → glm, qwen-embedding → qwen), so an eligibility-first implementation
+# admits them silently. This pair anchors the ORDER, not the list.
+mk 'crossfamily: panel(glm-ocr) — glm family\n' c4
+check c4 BLOCK "glm-ocr — matches a valid family AND an incapable class"
+mk 'crossfamily: panel(qwen-embedding-8b) — qwen family\n' c5
+check c5 BLOCK "qwen-embedding — same overlap, other direction"
+
+echo
+if [ "$FAIL" -eq 0 ]; then echo "✅ all $N fixtures behave"; else echo "❌ regression ($N fixtures run)"; fi
+exit "$FAIL"