@chrono-meta/fh-gate 2.15.1 → 3.0.0

package/scripts/test_package_coverage_lanes.sh

@@ -36,7 +36,9 @@ trap 'rm -rf "$TMP"' EXIT
 
 pass=0; fail=0; skipped=0
 ok()  { printf '  ✅ %s\n' "$1"; pass=$((pass+1)); }
-bad() { printf '  ❌ %s\n' "$1"; fail=$((fail+1)); }
+# $2 (optional) = the actual stdout/stderr/rc this case caught — printed so a red lane in CI is
+# diagnosable without re-running it by hand. Truncated/flattened like the node-check lanes' bad().
+bad() { printf '  ❌ %s\n' "$1"; [ -n "${2:-}" ] && printf '     got: %s\n' "$(printf '%s' "$2" | tr '\n' '|' | cut -c1-220)"; fail=$((fail+1)); }
 # A skip is COUNTED and reported. An uncounted skip is how "could not run" becomes indistinguishable
 # from "ran and passed" in the summary line — measured on this very suite in review round 2, where a
 # broken git produced "7 passed, 0 failed" and exit 0 while the real-worktree claim went untested.
@@ -70,23 +72,30 @@ make_tree() { # make_tree <dir> <git_shape> <cover_target:yes|no> [omit_manifest
 }
 
 run_tree() { bash "$1/scripts/package_coverage_check.sh" 2>&1; }
-rc_tree()  { bash "$1/scripts/package_coverage_check.sh" >/dev/null 2>&1; echo $?; }
+# 🟥 no more rc_tree(): it used to re-run the subject a SECOND time just to get $? (`out=$(run_tree
+# ...); rc=$(rc_tree ...)` — two executions of the same script, so a nondeterministic subject could
+# report an (out, rc) pair that never co-occurred in either real run). Every call site below now
+# does `out=$(run_tree ...); rc=$?` — one execution, $? read off THAT command substitution.
 
 # Assert a POSITIVE outcome, never merely the absence of the SKIP line. Cross-family review caught
 # the first draft here: it checked only that `SKIP  package-coverage` was missing, so a checker that
 # exited 1 on every worktree — the opposite defect, equally broken — would have passed the lane that
 # exists to prove the worktree path works. "Did not say the wrong thing" is not "did the right
 # thing"; a lane phrased as a negative can only ever fail one way.
+# Both functions below stash their single execution's output/rc in _LAST_OUT/_LAST_RC (not `local`,
+# deliberately — the caller reads them straight off the one run instead of re-invoking the subject a
+# second time just to build a diagnostic string, which would be the same two-executions-for-one-
+# verdict shape the L3–L7 dual-execution fix below removes).
 ran_clean() { # ran_clean <dir> -> 0 iff the check actually ran AND reported a clean scan
-  local d="$1" o rc
-  o=$(bash "$d/scripts/package_coverage_check.sh" 2>&1); rc=$?
-  [ "$rc" -eq 0 ] && printf '%s' "$o" | grep -q 'PASS  package-coverage' \
-    && ! printf '%s' "$o" | grep -q 'SKIP  package-coverage'
+  local d="$1"
+  _LAST_OUT=$(bash "$d/scripts/package_coverage_check.sh" 2>&1); _LAST_RC=$?
+  [ "$_LAST_RC" -eq 0 ] && printf '%s' "$_LAST_OUT" | grep -q 'PASS  package-coverage' \
+    && ! printf '%s' "$_LAST_OUT" | grep -q 'SKIP  package-coverage'
 }
 caught_defect() { # caught_defect <dir> -> 0 iff the check FOUND the planted omission
-  local d="$1" o rc
-  o=$(bash "$d/scripts/package_coverage_check.sh" 2>&1); rc=$?
-  [ "$rc" -eq 1 ] && printf '%s' "$o" | grep -q 'scripts/helper.sh'
+  local d="$1"
+  _LAST_OUT=$(bash "$d/scripts/package_coverage_check.sh" 2>&1); _LAST_RC=$?
+  [ "$_LAST_RC" -eq 1 ] && printf '%s' "$_LAST_OUT" | grep -q 'scripts/helper.sh'
 }
 # A CLEAN LANE ALONE PROVES NOTHING ABOUT THE WORKTREE PATH. Cross-family review round 2 demonstrated
 # this by EXECUTION: it replaced the subject with a mutant that printed `PASS  package-coverage`
@@ -99,11 +108,11 @@ wt_pair() { # wt_pair <label> <dir> <git_shape>
   local label="$1" d="$2" shape="$3"
   make_tree "$d" "$shape" yes
   if ! ran_clean "$d"; then
-    bad "$label — clean leg: did not run to a PASS ($(run_tree "$d" | head -1))"; return
+    bad "$label — clean leg: did not run to a PASS (rc=$_LAST_RC)" "$_LAST_OUT"; return
   fi
   make_tree "$d" "$shape" no        # identical tree, files[] no longer covers the referenced path
   if ! caught_defect "$d"; then
-    bad "$label — DEFECT leg: planted omission not caught, so the clean PASS proved nothing"; return
+    bad "$label — DEFECT leg: planted omission not caught, so the clean PASS proved nothing (rc=$_LAST_RC)" "$_LAST_OUT"; return
   fi
   ok "$label"
 }
@@ -171,15 +180,20 @@ else
     esac
   }
   mkdir -p "$TMP/emptytpl"
-  if git "${GIT_ISO[@]}" -C "$TMP/realrepo" init -q --template="$TMP/emptytpl" . >/dev/null 2>&1 \
+  # The whole fixture-build chain runs as ONE group so its combined stdout+stderr lands in one
+  # variable instead of /dev/null — a failed build used to report only "could not be built", with
+  # no way to tell which of the four steps broke or why.
+  _l1b_ok=1
+  _l1b_out="$( { git "${GIT_ISO[@]}" -C "$TMP/realrepo" init -q --template="$TMP/emptytpl" . \
      && _gitdir_ok \
-     && git "${GIT_ISO[@]}" -C "$TMP/realrepo" commit -q --allow-empty -m init >/dev/null 2>&1 \
-     && git "${GIT_ISO[@]}" -C "$TMP/realrepo" worktree add -q --detach "$TMP/realwt" >/dev/null 2>&1 \
-     && [ -f "$TMP/realwt/.git" ]; then
+     && git "${GIT_ISO[@]}" -C "$TMP/realrepo" commit -q --allow-empty -m init \
+     && git "${GIT_ISO[@]}" -C "$TMP/realrepo" worktree add -q --detach "$TMP/realwt" \
+     && [ -f "$TMP/realwt/.git" ]; } 2>&1 )" || _l1b_ok=0
+  if [ "$_l1b_ok" -eq 1 ]; then
     wt_pair "L1-b real \`git worktree add\` (.git is a genuine gitdir pointer): scans for real" \
             "$TMP/realwt" none          # the REAL .git file is already in place; do not overwrite it
   else
-    bad "L1-b git IS installed but the real-worktree fixture could not be built — the claim was testable and was not tested"
+    bad "L1-b git IS installed but the real-worktree fixture could not be built — the claim was testable and was not tested" "$_l1b_out"
   fi
 fi
 
@@ -190,11 +204,11 @@ wt_pair "L2 ordinary checkout (.git is a DIR): scans for real — both legs" "$T
 # The widening from -d to -e must not cost the legitimate skip. An installed npm package has no
 # .git of either kind; making it fail there would fire on every consumer running `npm test`.
 make_tree "$TMP/l3" none yes
-out=$(run_tree "$TMP/l3"); rc=$(rc_tree "$TMP/l3")
+out=$(run_tree "$TMP/l3"); rc=$?
 if printf '%s' "$out" | grep -q 'SKIP  package-coverage' && [ "$rc" -eq 0 ]; then
   ok "L3 package mode (no .git): still skips, exit 0"
 else
-  bad "L3 package mode (no .git): expected SKIP+0, got rc=$rc / $(printf '%s' "$out" | head -1)"
+  bad "L3 package mode (no .git): expected SKIP+0, got rc=$rc" "$out"
 fi
 
 # ── L4 · a checkout with no manifest is UNMEASURED, not clean ────────────────────────
@@ -203,48 +217,60 @@ fi
 # file list cannot be read, which is "cannot measure", not "nothing to measure". An anchor that
 # pins the wrong direction is worse than no anchor — it makes the hole look deliberate.
 make_tree "$TMP/l4" dir yes omit
-out=$(run_tree "$TMP/l4"); rc=$(rc_tree "$TMP/l4")
+out=$(run_tree "$TMP/l4"); rc=$?
 if [ "$rc" -eq 1 ] && printf '%s' "$out" | grep -q 'UNMEASURED, not clean'; then
   ok "L4 .git present but no package.json: FAILS as unmeasured, not a clean skip"
 else
-  bad "L4 no package.json: expected exit 1 (unmeasured), got rc=$rc / $(printf '%s' "$out" | head -1)"
+  bad "L4 no package.json: expected exit 1 (unmeasured), got rc=$rc" "$out"
 fi
 
 # ── L5/L6 · KNOWN PAIR ───────────────────────────────────────────────────────────────
 # Same tree twice; the ONLY difference is whether files[] covers the referenced path.
 # L5 known-POSITIVE: referenced, exists, not shipped -> must FAIL.
 make_tree "$TMP/l5" dir no
-out=$(run_tree "$TMP/l5"); rc=$(rc_tree "$TMP/l5")
+out=$(run_tree "$TMP/l5"); rc=$?
 if [ "$rc" -eq 1 ] && printf '%s' "$out" | grep -q 'scripts/helper.sh'; then
   ok "L5 known-positive (referenced ∧ exists ∧ ¬shipped): FAIL, names the path"
 else
-  bad "L5 known-positive: expected exit 1 naming scripts/helper.sh, got rc=$rc"
+  bad "L5 known-positive: expected exit 1 naming scripts/helper.sh, got rc=$rc" "$out"
 fi
 
 # L6 known-NEGATIVE: identical, but the path is in files[] -> must PASS.
 make_tree "$TMP/l6" dir yes
-out=$(run_tree "$TMP/l6"); rc=$(rc_tree "$TMP/l6")
+out=$(run_tree "$TMP/l6"); rc=$?
 if [ "$rc" -eq 0 ] && printf '%s' "$out" | grep -q 'PASS  package-coverage'; then
   ok "L6 known-negative (same tree, path shipped): PASS"
 else
-  bad "L6 known-negative: expected exit 0 PASS, got rc=$rc"
+  bad "L6 known-negative: expected exit 0 PASS, got rc=$rc" "$out"
 fi
 
 # ── L7 · the impossible-zero guard is not reachable by an empty files[] ──────────────
 # A manifest with no shipped docs must report the extractor as broken, not print a pass.
 mkdir -p "$TMP/l7/scripts"; cp "$SUBJECT" "$TMP/l7/scripts/"; mkdir -p "$TMP/l7/.git"
 printf '{"files":[]}\n' > "$TMP/l7/package.json"
-out=$(run_tree "$TMP/l7"); rc=$(rc_tree "$TMP/l7")
+out=$(run_tree "$TMP/l7"); rc=$?
 if [ "$rc" -eq 1 ] && printf '%s' "$out" | grep -q 'the check broke, it did not pass'; then
   ok "L7 zero shipped docs: reported as broken extractor, not as a pass"
 else
-  bad "L7 zero shipped docs: expected exit 1 'check broke', got rc=$rc"
+  bad "L7 zero shipped docs: expected exit 1 'check broke', got rc=$rc" "$out"
 fi
 
 echo
 if [ "$skipped" -gt 0 ]; then
   echo "package-coverage lanes: ${pass} passed, ${fail} failed, ${skipped} UNCALIBRATED (not verified here)"
 else
-  echo "package-coverage lanes: ${pass} passed, ${fail} failed"
+  
+# ── lane 7: tarball oracle JSON without files[] → text-listing fallback (CI 2026-09-04, v3.0.0) ──
+# Known-pair: stub npm returns JSON lacking files[] but delegates the text `pack --dry-run` to the
+# real npm → PASS (7a). Stub returns the same JSON and an EMPTY text listing → ORACLE_UNAVAILABLE rc=2 (7b).
+cd "$REPO_ROOT" || exit 10; _REAL_NPM=$(command -v npm); _ST=$(mktemp -d)   # earlier lanes cd into fixtures — the subject reads .git/package.json from cwd
+printf '#!/bin/bash\nif [ "$*" = "pack --dry-run --json" ]; then echo "[{\\"id\\":\\"x\\"}]"; else exec %s "$@"; fi\n' "$_REAL_NPM" > "$_ST/npm"; chmod +x "$_ST/npm"
+o=$(PATH="$_ST:$PATH" bash "$SUBJECT" --vs-tarball 2>&1); rc=$?
+if [ "$rc" = 0 ] && printf '%s' "$o" | grep -q "^PASS  package-coverage"; then echo "  ✅ lane 7a: JSON without files[] → text listing fallback PASSes"; pass=$((pass+1)); else echo "  ❌ lane 7a: fallback did not PASS (rc=$rc)"; printf "%s\n" "$o" | grep -E "UNAVAILABLE|head:" | cut -c1-220; fail=$((fail+1)); fi
+printf '#!/bin/bash\nif [ "$*" = "pack --dry-run --json" ]; then echo "[{\\"id\\":\\"x\\"}]"; elif [ "$*" = "pack --dry-run" ]; then exit 0; else exec %s "$@"; fi\n' "$_REAL_NPM" > "$_ST/npm"
+o=$(PATH="$_ST:$PATH" bash "$SUBJECT" --vs-tarball 2>&1); rc=$?
+if [ "$rc" = 2 ] && printf '%s' "$o" | grep -q "UNAVAILABLE"; then echo "  ✅ lane 7b: JSON without files[] AND empty text listing → UNAVAILABLE rc=2 (fail-closed)"; pass=$((pass+1)); else echo "  ❌ lane 7b: expected rc=2 UNAVAILABLE, got rc=$rc"; fail=$((fail+1)); fi
+rm -rf "$_ST"
+echo "package-coverage lanes: ${pass} passed, ${fail} failed"
 fi
 [ "$fail" -eq 0 ] || exit 1

package/scripts/test_pipe_verdict_guard_lanes.sh

@@ -45,9 +45,9 @@ expect() {
 echo "[pipe-verdict-guard] known pairs"
 echo "-- R1: PIPESTATUS under zsh (deterministic) --"
 # The exact shape emitted 6× in this project, including twice on 2026-07-31.
-expect "R1 the measured shape"            HIT   'bash x.sh | tail -5; echo "exit=${PIPESTATUS[0]}"'
-expect "R1 any index"                     HIT   'a | b; rc=${PIPESTATUS[1]}'
-expect "R1 inside a larger command"       HIT   'cd /r && npm t | tail; E=${PIPESTATUS[0]}; echo $E'
+expect "R1 the measured shape"            HIT   'bash x.sh | tail -5; echo "exit=${PIPESTATUS[0]}"'  # portability-noqa: fixture string fed to pipe_verdict_guard.sh for static analysis, never executed by this shell
+expect "R1 any index"                     HIT   'a | b; rc=${PIPESTATUS[1]}'  # portability-noqa: same as above
+expect "R1 inside a larger command"       HIT   'cd /r && npm t | tail; E=${PIPESTATUS[0]}; echo $E'  # portability-noqa: same as above
 # zsh's own spelling is correct here and must never be flagged.
 expect "R1 zsh spelling is CLEAN"         CLEAN 'a | b; rc=$pipestatus[1]'
 
@@ -83,7 +83,7 @@ echo x | grep -q y
 rc=$?'
 # B: zsh accepts `$PIPESTATUS[0]` without braces; the brace-anchored regex missed it.
 expect "B PIPESTATUS without braces"      HIT   'a | b; rc=$PIPESTATUS[0]'
-expect "B braced form still caught"       HIT   'a | b; rc=${PIPESTATUS[0]}'
+expect "B braced form still caught"       HIT   'a | b; rc=${PIPESTATUS[0]}'  # portability-noqa: fixture string fed to pipe_verdict_guard.sh for static analysis, never executed by this shell
 
 echo "-- D: statement-continuation flatten + wrapped filter (leg-C MED round, 2026-08-01) --"
 # The blanket newline→`;` rewrite broke the CONTINUATION shapes: a newline after `|`/`&&` or a
@@ -167,7 +167,7 @@ echo "-- C: delivery channel (closes N=8 — detection without delivery is decor
 # NAMED RESIDUAL (cross-family LOW, accepted): $(…) capture strips NUL bytes, so a mutant emitting
 # NUL+JSON would pass C1. The producer's hits text is static ASCII+⚠️ with no NUL source, so the
 # lane does not pay for a byte-exact harness; revisit only if the producer ever emits dynamic bytes.
-HIT_CMD='bash x.sh | tail -5; echo "exit=${PIPESTATUS[0]}"'
+HIT_CMD='bash x.sh | tail -5; echo "exit=${PIPESTATUS[0]}"'  # portability-noqa: fixture string fed to the guard for static analysis, never executed by this shell
 payload() { python3 -c 'import json,sys; print(json.dumps({"tool_name":"Bash","tool_input":{"command":sys.argv[1]}}))' "$1"; }
 
 # All C lanes measure ONE invocation: stdout, stderr, and exit code from the same run (a pair of

package/scripts/test_precommit_pointer_index_lanes.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# test_precommit_pointer_index_lanes.sh — known pair for templates/.git-hooks/pre-commit [Pointers]:
+# the Detail-pointer gate must read the STAGED blob, not the working tree. Found 2026-09-03 (arm C
+# wt2, A3 triage): `[ -f "$REPO_ROOT/$f" ] || continue` let a staged .md with a broken
+# `**Detail**: See §X` pointer land silently when the file was rm'd from disk after staging
+# (git commits the INDEX). Runs in a disposable shallow clone — never touches this checkout.
+#   P1 staged broken pointer, file rm'd from disk       → commit BLOCKED (❌ pointer line printed)
+#   N1 staged VALID pointer, file rm'd from disk        → [Pointers] block runs with no ❌ (control: index read works)
+#   N2 staged broken pointer, file still on disk        → BLOCKED (the pre-fix path also caught this — control)
+# Usage: bash scripts/test_precommit_pointer_index_lanes.sh [--hook <path>]   (default = templates/.git-hooks/pre-commit)
+set -u; ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"; HOOK="$ROOT/templates/.git-hooks/pre-commit"
+[ "${1:-}" = "--hook" ] && HOOK="$2"
+T=$(mktemp -d); trap 'rm -rf "$T"' EXIT; pass=0; fail=0
+git clone -q --depth 1 "file://$ROOT" "$T/r" 2>/dev/null || { echo "❌ clone failed"; exit 10; }
+cd "$T/r" && git config user.email t@t && git config user.name t && mkdir -p .git/hooks && cp "$HOOK" .git/hooks/pre-commit && chmod +x .git/hooks/pre-commit
+mkdir -p docs/lanefix; printf '## §Alive\ntext\n' > docs/lanefix/target.md; git add docs/lanefix/target.md; git -c core.hooksPath=/dev/null commit -qm base 2>/dev/null
+run_case(){ local label="$1" want="$2" ptr="$3" rm_after="$4"
+  printf '# probe\n\n> **Detail**: See `docs/lanefix/target.md §%s`\n' "$ptr" > docs/lanefix/probe.md
+  git add docs/lanefix/probe.md; [ "$rm_after" = 1 ] && rm -f docs/lanefix/probe.md
+  out=$(FH_SKIP_GATE_AXES=1 git commit -qm probe 2>&1); rc=$?
+  # Discriminate on the [Pointers] block itself, not on commit rc: the fixture clone carries no
+  # marker/manifest, so OTHER axes block every commit here — rc is not this lane's signal.
+  if printf '%s' "$out" | grep -q "Detail pointer §"; then got=BLOCK_PTR
+  elif printf '%s' "$out" | grep -q "unreadable from the index"; then got=BLOCK_INDEX
+  elif printf '%s' "$out" | grep -q "\[Pointers\]"; then got=PTR_OK
+  else got=PTR_NOT_RUN; fi
+  git reset -q --hard HEAD 2>/dev/null;  # noqa: destructive-op — disposable clone under mktemp git rm -q --cached docs/lanefix/probe.md 2>/dev/null; rm -f docs/lanefix/probe.md
+  if [ "$got" = "$want" ]; then printf '  ✅ %-48s %s\n' "$label" "$got"; pass=$((pass+1)); else printf '  ❌ %-48s %s (expected %s)\n' "$label" "$got" "$want"; fail=$((fail+1)); printf '%s\n' "$out" | grep -E "Pointers|❌" | head -4 | sed 's/^/       /'; fi; }
+echo "[precommit-pointer-index] hook=$HOOK"
+run_case "P1 broken pointer, staged then rm'd from disk"  BLOCK_PTR Ghost 1
+run_case "N1 valid pointer, staged then rm'd (index read)" PTR_OK    Alive 1
+run_case "N2 broken pointer, still on disk (old path too)" BLOCK_PTR Ghost 0
+echo "[precommit-pointer-index] $pass passed, $fail failed"; [ "$fail" -eq 0 ]

package/scripts/test_preprep_drift_anchor.sh

@@ -16,7 +16,16 @@ set -uo pipefail
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 SRC="$HERE/plugins/fh-commons/skills/preprep"
 # standalone 배포 위치는 환경변수로 받는다. 기본값을 박으면 다른 머신에서 거짓 SKIP 이 된다.
-DIST="${PREPREP_STANDALONE_DIR:-}"
+# 🟥 2026-09-03 — 그런데 «아무도 그 변수를 안 걸어서» D2 가 여태 SKIP 이었고, 그 사이 컴패니언
+#    저장소의 fork(724줄)가 정본(789줄)과 갈라져 L9~L11 을 안 부르고 있었다 — 정본 주석이 이미
+#    한 번 적어 둔 사고의 2회째(fh_signal_2026-09-03_preprep-standalone-anchor-skip.md). 슬롯은
+#    있고 소비처가 0 인 형태. 처방: 명시 변수가 없으면 운영자 로컬 바인딩이 이미 export 하는
+#    FH_COMPANION_STORE 아래 preprep/ 을 «자동 후보»로 쓴다 — 기본값을 박는 게 아니라 이미
+#    선언된 경로를 읽는 것이라 다른 머신에서 거짓 SKIP 을 만들지 않는다(없으면 여전히 SKIP).
+DIST="${PREPREP_STANDALONE_DIR:-}"; DIST_SRC="PREPREP_STANDALONE_DIR"
+if [ -z "$DIST" ] && [ -n "${FH_COMPANION_STORE:-}" ] && [ -d "${FH_COMPANION_STORE}/preprep" ]; then
+  DIST="${FH_COMPANION_STORE}/preprep"; DIST_SRC="FH_COMPANION_STORE/preprep (자동 후보)"
+fi
 PASS=0; FAIL=0; SKIP=0
 ok(){ echo "  ✅ $1"; PASS=$((PASS+1)); }
 ng(){ echo "  ❌ $1"; FAIL=$((FAIL+1)); }
@@ -41,16 +50,16 @@ fi
 
 # D2 — standalone 대조
 if [ -z "$DIST" ]; then
-  sk "D2 standalone 대조 — PREPREP_STANDALONE_DIR 미설정이라 배포본을 못 찾았다"
+  sk "D2 standalone 대조 — PREPREP_STANDALONE_DIR 미설정이고 FH_COMPANION_STORE/preprep 도 없어 배포본을 못 찾았다. UNCHECKED — 배포본이 있는 머신이면 둘 중 하나를 export 해라"
 elif [ ! -d "$DIST" ]; then
-  ng "D2 PREPREP_STANDALONE_DIR 이 가리키는 곳이 없다: $DIST (설정됐는데 부재 = 드리프트 아니라 배선 결함)"
+  ng "D2 $DIST_SRC 이 가리키는 곳이 없다: $DIST (설정됐는데 부재 = 드리프트 아니라 배선 결함)"
 else
   drift=""
   for f in preprep.py interslide_deps.py lane_progression.py lane_adjacent_dup.py; do
     if [ ! -f "$DIST/$f" ]; then drift="$drift $f(부재)"
     elif ! cmp -s "$SRC/$f" "$DIST/$f"; then drift="$drift $f(갈림)"; fi
   done
-  [ -z "$drift" ] && ok "D2 standalone 코드 5파일이 단일 소스와 바이트 동일" \
+  [ -z "$drift" ] && ok "D2 standalone 코드 5파일이 단일 소스와 바이트 동일 ($DIST_SRC)" \
                   || ng "D2 드리프트:$drift ⇒ 사본이 둘이 됐다. 단일 소스에서 다시 뽑아라"
 fi
 

package/scripts/test_preprep_drift_anchor_lanes.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+# test_preprep_drift_anchor_lanes.sh — known pairs for the D2 leg of scripts/test_preprep_drift_anchor.sh
+# WHY (2026-09-03): D2 compared the standalone copy only when PREPREP_STANDALONE_DIR was set. Nobody
+# set it, so the leg SKIPPED for weeks while the companion-store fork drifted (724 vs 789 lines, L9-L11
+# never called) — the second occurrence of the exact accident the canon's own comment records.
+# Fix under test: with the env var unset, the anchor falls back to $FH_COMPANION_STORE/preprep when it
+# exists. These lanes pin: fallback used · fallback discriminates (identical PASS / drifted FAIL) ·
+# explicit var still wins · nothing set → SKIP (never a silent PASS).
+set -u
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"; A="$HERE/scripts/test_preprep_drift_anchor.sh"
+SRC="$HERE/plugins/fh-commons/skills/preprep"; T=$(mktemp -d); pass=0; fail=0
+chk(){ if [ "$1" = 0 ]; then echo "  ✅ $2"; pass=$((pass+1)); else echo "  ❌ $2"; fail=$((fail+1)); fi; }
+mk(){ mkdir -p "$1"; for f in preprep.py interslide_deps.py lane_progression.py lane_adjacent_dup.py lane_promise.py; do cp "$SRC/$f" "$1/$f"; done; }
+echo "[preprep-drift-anchor] D2 known pairs"
+# L1 nothing set → D2 SKIP (skip != pass), rc 0 (D2 is not a FAIL)
+out=$(env -u PREPREP_STANDALONE_DIR FH_COMPANION_STORE="$T/nostore" bash "$A" 2>&1); printf '%s' "$out" | grep -q "D2 .*SKIPPED"; chk $? "L1 var unset + no companion preprep → D2 SKIPPED (not PASS)"
+# L2 companion copy identical → fallback used, D2 PASS
+mk "$T/be/preprep"; out=$(env -u PREPREP_STANDALONE_DIR FH_COMPANION_STORE="$T/be" bash "$A" 2>&1); printf '%s' "$out" | grep -q "✅ D2 .*자동 후보"; chk $? "L2 fallback FH_COMPANION_STORE/preprep identical → D2 PASS via 자동 후보"
+# L3 companion copy drifted → D2 FAIL, rc 1 (the accident class)
+printf '\n# drift\n' >> "$T/be/preprep/preprep.py"; env -u PREPREP_STANDALONE_DIR FH_COMPANION_STORE="$T/be" bash "$A" >"$T/l3.out" 2>&1; rc=$?; [ "$rc" -ne 0 ] && grep -q "D2 드리프트.*preprep.py(갈림)" "$T/l3.out"; chk $? "L3 fallback copy drifted → D2 FAIL rc=$rc (known-positive)"
+# L4 explicit var wins over companion
+mk "$T/explicit"; out=$(PREPREP_STANDALONE_DIR="$T/explicit" FH_COMPANION_STORE="$T/be" bash "$A" 2>&1); printf '%s' "$out" | grep -q "✅ D2 .*(PREPREP_STANDALONE_DIR)"; chk $? "L4 explicit PREPREP_STANDALONE_DIR wins over drifted companion copy"
+rm -rf "$T"; echo "[preprep-drift-anchor] $pass passed, $fail failed"; [ "$fail" -eq 0 ]

package/scripts/test_proposal_hook_lanes.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# test_proposal_hook_lanes.sh — known pairs for scripts/proposal_hook.sh (written before shipping; r4 KP + Bash path)
+set -u; HDIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"; T=$(mktemp -d); pass=0; fail=0
+export CLAUDE_PROJECT_DIR="$T"
+exp(){ local label="$1" want="$2" payload="$3" got; got=$(printf '%s' "$payload" | bash "$HDIR/proposal_hook.sh" 2>/dev/null | wc -c | tr -d ' '); [ "$got" -gt 0 ] && got=HIT || got=CLEAN
+  if [ "$got" = "$want" ]; then printf '  ✅ %-52s %s\n' "$label" "$got"; pass=$((pass+1)); else printf '  ❌ %-52s %s (expected %s)\n' "$label" "$got" "$want"; fail=$((fail+1)); fi; }
+echo "[proposal-hook] known pairs"
+exp "T1 Edit comm+LC_ALL (verdict compare)"   HIT   '{"tool_name":"Edit","tool_input":{"file_path":"/x/scripts/sim_isolated_run.sh","old_string":"  comm -13 <(sort a) <(sort b) \\","new_string":"  comm -13 <(LC_ALL=C sort a) <(LC_ALL=C sort b) \\"}}'
+exp "T2 Edit adds fail-open guard"            HIT   '{"tool_name":"Edit","tool_input":{"file_path":"/x/scripts/capability_effect_probe.sh","old_string":"  h=$(ls -A \"$HOME\" | shasum)","new_string":"  h=$(ls -A \"$HOME\" | shasum) || { echo LS_FAILED; exit 10; }"}}'
+exp "T3 Edit continue guard"                  HIT   '{"tool_name":"Edit","tool_input":{"file_path":"/x/templates/regression_guard.sh","old_string":"      [ -e \"$blk\" ] && [ -s \"$blk\" ] || continue","new_string":"      [ -e \"$blk\" ] || { echo missing >&2; continue; }"}}'
+exp "HARD Edit usage string only (r4 0/5)"    CLEAN '{"tool_name":"Edit","tool_input":{"file_path":"/x/scripts/daily_report.sh","old_string":"  *) echo \"usage: d.sh [run]\" >&2; exit 2 ;;","new_string":"  *) echo \"usage: d.sh [run|--self-test] (DR_DATE)\" >&2; exit 2 ;;"}}'
+exp "docs file with tokens"                   CLEAN '{"tool_name":"Edit","tool_input":{"file_path":"/x/docs/a.md","old_string":"a","new_string":"exit 1 || continue"}}'
+exp "Write new scripts/*.sh with verdict"     HIT   '{"tool_name":"Write","tool_input":{"file_path":"/x/scripts/new_check.sh","content":"#!/bin/bash\n[ -f x ] || exit 1"}}'
+exp "Bash sed -i on scripts/*.sh with token"  HIT   '{"tool_name":"Bash","tool_input":{"command":"sed -i \"\" \"s/comm -13/LC_ALL=C comm -13/\" scripts/sim_isolated_run.sh && [ -s out ] || exit 1"}}'
+exp "Bash sed -i token ONLY inside quotes (a1)"  HIT   '{"tool_name":"Bash","tool_input":{"command":"sed -i \"\" \"s/exit 1/exit 2/\" scripts/target.sh"}}'
+exp "Bash sed -i single-quoted token (a1b)"      HIT   '{"tool_name":"Bash","tool_input":{"command":"sed -i '"'"''"'"' '"'"'s/|| continue/|| { echo x; continue; }/'"'"' scripts/target.sh"}}'
+exp "Bash sed -i no token anywhere (a3)"         CLEAN '{"tool_name":"Bash","tool_input":{"command":"sed -i \"\" s/foo/bar/ scripts/target.sh"}}'
+exp "Bash redirect into scripts/*.sh w/ token" HIT  '{"tool_name":"Bash","tool_input":{"command":"printf \"%s\\n\" x >> scripts/x.sh; grep -q y scripts/x.sh || exit 3"}}'
+exp "Bash redirect into docs (no)"            CLEAN '{"tool_name":"Bash","tool_input":{"command":"echo \"exit 1\" >> docs/a.md || exit 1"}}'
+exp "Bash ls only (no target)"                CLEAN '{"tool_name":"Bash","tool_input":{"command":"ls scripts/ && [ -d scripts ] || exit 1"}}'
+exp "G1 Edit templates/.git-hooks/pre-commit (no .sh)" HIT '{"tool_name":"Edit","tool_input":{"file_path":"/x/templates/.git-hooks/pre-commit","old_string":"  [ -f x ] || continue","new_string":"  [ -f x ] || { echo missing; PTR_FAIL=1; continue; }"}}'
+exp "G1-ctrl Edit .git-hooks docs-ish no token"        CLEAN '{"tool_name":"Edit","tool_input":{"file_path":"/x/templates/.git-hooks/pre-commit","old_string":"# note a","new_string":"# note b"}}'
+exp "noqa exempts"                            CLEAN '{"tool_name":"Edit","tool_input":{"file_path":"/x/scripts/a.sh","old_string":"a","new_string":"exit 1  # noqa: proposal-hook"}}'
+exp "unparseable payload silent"              CLEAN 'not json'
+msg(){ printf '%s' "$2" | bash "$HDIR/proposal_hook.sh" 2>/dev/null; }
+fact(){ local label="$1" want="$2" payload="$3" got; got=$(msg x "$payload"); if printf '%s' "$got" | grep -q -- "$want"; then printf '  ✅ %-52s carries «%s»\n' "$label" "$want"; pass=$((pass+1)); else printf '  ❌ %-52s missing «%s»\n' "$label" "$want"; fail=$((fail+1)); fi; }
+mkdir -p "$T/scripts"; : > "$T/scripts/test_has_lane_lanes.sh"; printf 'scan of scripts/covered.sh\nfindings: 0\n' > "$T/scripts/.degrade_scan_last_2026-09-03.txt"
+E='{"tool_name":"Edit","tool_input":{"file_path":"/x/scripts/%s","old_string":"a","new_string":"[ -f x ] || exit 1"}}'
+fact "F1 lane exists → fact line, no known-pair item" "이미 있다" "$(printf "$E" has_lane.sh)"
+fact "F1b lane exists → scan item still proposed"     "degrade_direction_scan.sh 로" "$(printf "$E" has_lane.sh)"
+fact "F2 self-lane (test_*_lanes.sh) → fact line"     "이 파일 자체가 레인" "$(printf "$E" test_has_lane_lanes.sh)"
+fact "F3 scan covers file → fact line w/ findings"    "findings: 0" "$(printf "$E" covered.sh)"
+fact "F4 neither → both items proposed"               "known-pair(고친 케이스 + 반대 케이스) 컨트롤 degrade_direction_scan.sh" "$(printf "$E" bare.sh)"
+got=$(msg x "$(printf "$E" bare.sh)"); if printf '%s' "$got" | grep -q "사실:"; then echo "  ❌ F4-ctrl bare file must carry NO fact line"; fail=$((fail+1)); else echo "  ✅ F4-ctrl bare file carries no fact line (known-negative)"; pass=$((pass+1)); fi
+[ -f "$T/.claude/.proposal_hook_events.tsv" ] && [ "$(grep -c FIRE "$T/.claude/.proposal_hook_events.tsv")" -ge 5 ]; r=$?; [ $r = 0 ] && { echo "  ✅ evidence file carries a FIRE row per hit"; pass=$((pass+1)); } || { echo "  ❌ evidence file missing/short"; fail=$((fail+1)); }
+rm -rf "$T"; echo "[proposal-hook] $pass passed, $fail failed"; [ "$fail" -eq 0 ]

package/scripts/test_revert_probe_lanes.sh

@@ -0,0 +1,146 @@
+#!/usr/bin/env bash
+# test_revert_probe_lanes.sh — known-pair calibration for scripts/revert_probe.sh
+#
+# WHY THESE LANES. revert_probe.sh exists to replace 15+ hand-written revert-and-observe scripts
+# with one generic tool. The two failure modes that would make it worse than the hand-rolled
+# scripts it replaces are exactly the two known-pair lanes below:
+#   L1  DECORATIVE anchor — a suite whose lanes never actually depend on the target file's content
+#       must be reported as decorative (exit 1), not silently scored as "passed".
+#   L2  REAL anchor        — the mirror-image known-positive: a suite that DOES catch the revert
+#       must report the exact flipped lane and exit 0. Without this half, L1 proves nothing
+#       ([[feedback_control_presence_is_not_discrimination]]).
+#   L3  RESTORE GUARANTEED — the target file must come back byte-identical after the probe, in
+#       BOTH the normal-completion path and the harness-error path (suite crashes / produces no
+#       parseable output). A revert tool that leaves the baseline content sitting in the working
+#       tree on the failure path is strictly worse than not having the tool.
+#   L4+ usage guards, harness-error detection, and the git-show (not git-checkout) restore path.
+#
+# Fixtures are throwaway git repos + throwaway suite scripts, never this repo's own assets — a
+# lane suite that references a repo-specific path fails on a fresh clone (portability_lint P9).
+#
+# Usage: bash scripts/test_revert_probe_lanes.sh
+
+set -uo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+SUT="${FH_REVERT_PROBE_BIN:-$ROOT/scripts/revert_probe.sh}"
+pass=0; fail=0
+ok()  { printf '  ✅ %s\n' "$1"; pass=$((pass+1)); }
+no()  { printf '  ❌ %s\n' "$1"; fail=$((fail+1)); }
+
+if [ ! -f "$SUT" ]; then
+  echo "FAIL  test_revert_probe_lanes.sh: subject absent ($SUT) — skipped is not passed"
+  exit 1
+fi
+
+WORKROOT="$(mktemp -d "${TMPDIR:-/tmp}/revertlane-XXXXXX")"
+trap 'rm -rf "$WORKROOT"' EXIT
+
+# ── throwaway repo: commit 1 = baseline (missing the fix) · commit 2/HEAD = current (has the fix)
+SRC="$WORKROOT/src"; mkdir -p "$SRC"
+(
+  cd "$SRC" && git init -q . && git config user.email l@l && git config user.name l
+  printf 'value = old_and_broken\n' > guard.txt
+  git add guard.txt && git commit -qm "baseline (no fix)"
+  printf 'value = MARKER_OK\n' > guard.txt
+  git add guard.txt && git commit -qm "current (has the fix)"
+) >/dev/null 2>&1
+TARGET="$SRC/guard.txt"
+TARGET_SHA_BEFORE() { shasum -a 256 "$TARGET" 2>/dev/null | awk '{print $1}'; }
+
+# ── fixture suites ──────────────────────────────────────────────────────────────────────────
+# REAL anchor: the lane's pass/fail genuinely depends on the target file's content.
+REAL_SUITE="$WORKROOT/real_suite.sh"
+cat > "$REAL_SUITE" <<'EOF'
+#!/usr/bin/env bash
+if grep -q MARKER_OK "$FIXTURE_TARGET" 2>/dev/null; then
+  printf '  %s %s\n' "✅" "marker present in guard.txt"
+else
+  printf '  %s %s\n' "❌" "marker present in guard.txt"
+fi
+exit 0
+EOF
+chmod +x "$REAL_SUITE"
+
+# DECORATIVE anchor: always ✅, never actually reads the target file.
+DECO_SUITE="$WORKROOT/deco_suite.sh"
+cat > "$DECO_SUITE" <<'EOF'
+#!/usr/bin/env bash
+printf '  %s %s\n' "✅" "unrelated check that never reads guard.txt"
+exit 0
+EOF
+chmod +x "$DECO_SUITE"
+
+# HARNESS-ERROR suite: crashes before printing any ✅/❌ line at all.
+CRASH_SUITE="$WORKROOT/crash_suite.sh"
+cat > "$CRASH_SUITE" <<'EOF'
+#!/usr/bin/env bash
+echo "no verdict lines here, just noise" >&2
+exit 1
+EOF
+chmod +x "$CRASH_SUITE"
+
+echo "── revert_probe known-pair lanes ──────────────────────────────────"
+
+# L1 — DECORATIVE anchor → exit 1, 0 flipped lanes
+BEFORE1="$(TARGET_SHA_BEFORE)"
+OUT1=$(FIXTURE_TARGET="$TARGET" bash "$SUT" "$TARGET" "$DECO_SUITE" --baseline HEAD~1 2>&1); RC1=$?
+[ "$RC1" -eq 1 ] && ok "L1 decorative anchor → exit 1" || no "L1 decorative anchor: rc=$RC1 (want 1)"
+printf '%s' "$OUT1" | grep -q "되돌린 레인 (✅→❌, 앵커가 실제로 잡은 것): 0개" \
+  && ok "L1b report states 0 flipped lanes" || no "L1b report did not state 0 flipped lanes"
+AFTER1="$(TARGET_SHA_BEFORE)"
+[ "$BEFORE1" = "$AFTER1" ] && ok "L1c target file restored after decorative run" \
+  || no "L1c target file NOT restored (before=$BEFORE1 after=$AFTER1)"
+
+# L2 — REAL anchor → exit 0, exactly 1 flipped lane, names it
+BEFORE2="$(TARGET_SHA_BEFORE)"
+OUT2=$(FIXTURE_TARGET="$TARGET" bash "$SUT" "$TARGET" "$REAL_SUITE" --baseline HEAD~1 2>&1); RC2=$?
+[ "$RC2" -eq 0 ] && ok "L2 real anchor → exit 0" || no "L2 real anchor: rc=$RC2 (want 0)"
+printf '%s' "$OUT2" | grep -q "되돌린 레인 (✅→❌, 앵커가 실제로 잡은 것): 1개" \
+  && ok "L2b report states exactly 1 flipped lane" || no "L2b report did not state 1 flipped lane"
+printf '%s' "$OUT2" | grep -q "marker present in guard.txt" \
+  && ok "L2c report names the exact flipped label" || no "L2c flipped label not named in report"
+AFTER2="$(TARGET_SHA_BEFORE)"
+[ "$BEFORE2" = "$AFTER2" ] && ok "L2d target file restored after real-anchor run" \
+  || no "L2d target file NOT restored (before=$BEFORE2 after=$AFTER2)"
+
+# L3 — frontier warning header always present (both suites above already exercised it; assert once)
+printf '%s' "$OUT2" | grep -q "2607.22880" && ok "L3 frontier-warning citation present in output" \
+  || no "L3 frontier-warning citation missing"
+printf '%s' "$OUT2" | grep -q "되돌린 파일(뮤턴트) 수: 1" \
+  && ok "L3b mutant-count line present (n=1 caveat)" || no "L3b mutant-count line missing"
+
+# L4 — HARNESS ERROR: suite produces zero ✅/❌ lines → exit 10, and restore STILL happens.
+# This is the lane that matters most: a crash on the baseline run is exactly the moment a naive
+# implementation would leave the baseline content sitting in the working tree.
+BEFORE4="$(TARGET_SHA_BEFORE)"
+OUT4=$(FIXTURE_TARGET="$TARGET" bash "$SUT" "$TARGET" "$CRASH_SUITE" --baseline HEAD~1 2>&1); RC4=$?
+[ "$RC4" -eq 10 ] && ok "L4 zero-label suite → exit 10 (harness error, not a silent pass)" \
+  || no "L4 zero-label suite: rc=$RC4 (want 10)"
+AFTER4="$(TARGET_SHA_BEFORE)"
+[ "$BEFORE4" = "$AFTER4" ] && ok "L4b target file restored even on the harness-error path" \
+  || no "L4b RESTORE FAILED ON HARNESS-ERROR PATH (before=$BEFORE4 after=$AFTER4) — this is the defect class this suite exists to catch"
+
+# L5 — usage guards
+OUT5=$(bash "$SUT" 2>&1); RC5=$?
+[ "$RC5" -eq 2 ] && ok "L5 no args → exit 2" || no "L5 no args: rc=$RC5"
+OUT5b=$(bash "$SUT" "$TARGET" 2>&1); RC5b=$?
+[ "$RC5b" -eq 2 ] && ok "L5b missing suite arg → exit 2" || no "L5b missing suite arg: rc=$RC5b"
+OUT5c=$(bash "$SUT" "$WORKROOT/does_not_exist.txt" "$REAL_SUITE" 2>&1); RC5c=$?
+[ "$RC5c" -eq 2 ] && ok "L5c missing target file → exit 2" || no "L5c missing target file: rc=$RC5c"
+OUT5d=$(bash "$SUT" "$TARGET" "$WORKROOT/does_not_exist.sh" 2>&1); RC5d=$?
+[ "$RC5d" -eq 2 ] && ok "L5d missing suite file → exit 2" || no "L5d missing suite file: rc=$RC5d"
+OUT5e=$(bash "$SUT" "$TARGET" "$REAL_SUITE" --baseline totally-bogus-ref 2>&1); RC5e=$?
+[ "$RC5e" -eq 2 ] && ok "L5e bad --baseline ref → exit 2" || no "L5e bad baseline ref: rc=$RC5e"
+
+# L6 — the restore path uses `git show`, never `git checkout <ref> -- <path>` (the latter STAGES
+# the revert into the index — [[feedback_git_checkout_path_stages_the_revert]]). Assert the repo's
+# index carries no staged change after a probe run, both directions.
+( cd "$SRC" && git diff --cached --quiet ) \
+  && ok "L6 no staged changes left in the index after any probe run" \
+  || no "L6 the index has staged changes — a checkout-based restore would do this"
+( cd "$SRC" && git status --porcelain ) | grep -q . \
+  && no "L6b working tree not clean after probes (git status is non-empty)" \
+  || ok "L6b working tree clean after all probes (file content == committed HEAD)"
+
+echo "revert_probe lanes: $pass passed, $fail failed"
+[ "$fail" -eq 0 ] || exit 1

package/scripts/test_session_close_lanes.sh

@@ -138,9 +138,7 @@ PREMISE_FAILED=0
 # Human-readable on both platforms: GNU prints a date for %y, BSD's %Fm prints a raw epoch, so the
 # BSD branch asks for a formatted date instead — the whole point of this line is eyeballing.
 _mtime_h() {
-  stat -c %y "$1" 2>/dev/null \
-    || stat -f "%Sm" -t "%Y-%m-%d %H:%M:%S" "$1" 2>/dev/null \
-    || echo "?"
+  stat -c %y "$1" 2>/dev/null || stat -f "%Sm" -t "%Y-%m-%d %H:%M:%S" "$1" 2>/dev/null || echo "?"
 }
 
 _assert_newer() {  # $1=expected-newer  $2=reference  $3=lane label — returns 1 if premise fails
@@ -298,7 +296,7 @@ _carry_fixture() {  # $1=오늘카드 본문  $2=fh_completed 본문(빈 문자
   printf '%s\n' "$card_body" > "$T/tracks/_meta/reference_next_session_starter.md"
   [ -n "$done_body" ] && printf '%s\n' "$done_body" > "$T/tracks/_meta/fh_completed_${TODAY}.md"
   # companion store: 어제 날짜로 커밋된 «이전 카드» 미러 하나
-  FUT=$(date -v+2d '+%m-%d' 2>/dev/null || date -d '+2 days' '+%m-%d')
+  FUT=$(date -d '+2 days' '+%m-%d' 2>/dev/null || date -v+2d '+%m-%d')
   ( cd "$S" && git init -q . && git config user.email a@l && git config user.name a \
     && mkdir -p tracks-meta \
     && printf '기한 %s 미팅 안건 [B]\n' "$FUT" > tracks-meta/reference_next_session_starter.md \
@@ -307,7 +305,7 @@ _carry_fixture() {  # $1=오늘카드 본문  $2=fh_completed 본문(빈 문자
        git commit -qm prior ) >/dev/null 2>&1
   printf '%s|%s' "$T" "$S"
 }
-_carry_future() { date -v+2d '+%m-%d' 2>/dev/null || date -d '+2 days' '+%m-%d'; }
+_carry_future() { date -d '+2 days' '+%m-%d' 2>/dev/null || date -v+2d '+%m-%d'; }
 
 _carry_lane() {  # $1=name $2=pattern $3=expect $4="REPO|STORE" $5=extra-env(옵션)
   local name="$1" pat="$2" expect="$3" pair="$4" env5="${5:-}" T S out hit

package/scripts/test_sim_isolated_run_lanes.sh

@@ -261,5 +261,22 @@ if [ -x "$ROOT/scripts/round/arm_blind_probe.sh" ]; then
     || no "L24 눈가림 실패 — 팔이 정답지를 읽을 수 있다"
 else no "L24 프로브 없음 — 검사 못 함(스킵 아님)"; fi
 
+# ── L25 ⓒ 날짜 오염 통제 필드 (six_axis_review_2026-09-04 강화 #3) — 존재만 본다, 값은 안 본다.
+#    이 러너가 판정을 안 낸다는 것이 헤더의 약속이라, 레인도 «필드가 있나»만 잰다.
+OUTDIR="$WORKROOT/o25"
+( cd "$SRC" && PATH="$STUBBIN:$PATH" HOME="$FAKEHOME" FH_STUB_MODE=say \
+   bash "$SUT" --arm a --reps 1 --prompt p --out "$OUTDIR" ) >/dev/null 2>&1
+META="$OUTDIR/a_r1.meta.tsv"
+if [ -f "$META" ]; then
+  grep -q '^corpus_head_date	' "$META" && ok "L25a corpus_head_date field recorded" \
+    || no "L25a corpus_head_date field missing"
+  grep -q '^sim_model	' "$META" && ok "L25b sim_model field recorded" \
+    || no "L25b sim_model field missing"
+  grep -q '^sim_model_cutoff	' "$META" && ok "L25c sim_model_cutoff field recorded" \
+    || no "L25c sim_model_cutoff field missing"
+else
+  no "L25 meta.tsv not written at all ($META)"
+fi
+
 echo "sim_isolated_run lanes: $pass passed, $fail failed"
 [ "$fail" -eq 0 ] || exit 1

package/scripts/utterance_landing_check.sh

@@ -132,7 +132,7 @@ done
 _probe_hits() {
   local pat="$1"; shift
   grep -lE -- "$pat" "$@" 2>/dev/null
-  return "${PIPESTATUS[0]:-$?}"
+  return "${PIPESTATUS[0]:-$?}"  # portability-noqa: shebang (line 1) pins bash — PIPESTATUS is a real array there, unlike zsh
 }
 
 # ── 1단계: 컨트롤. 살아있음을 증명하기 전에는 타깃을 인쇄하지 않는다 ──
@@ -179,7 +179,7 @@ MISS=0; N=0
 while IFS=$'\t' read -r kind pat label; do
   [ "${kind:-}" = "TARGET" ] || continue
   N=$((N+1))
-  hits=$(_probe_hits "$pat" "${FILES[@]}" | wc -l | tr -d ' '); _rc=${PIPESTATUS[0]}
+  hits=$(_probe_hits "$pat" "${FILES[@]}" | wc -l | tr -d ' '); _rc=${PIPESTATUS[0]}  # portability-noqa: shebang (line 1) pins bash — PIPESTATUS is a real array there, unlike zsh
   if [ "$_rc" -ge 2 ]; then
     printf "  🟥 %-46s 프로브 오류\n" "${label:-$pat}"
     BAD_PAT="${BAD_PAT:+$BAD_PAT, }TARGET/${label:-$pat}"