@chrono-meta/fh-gate 2.15.1 → 3.0.0

package/scripts/revert_probe.sh

@@ -0,0 +1,250 @@
+#!/usr/bin/env bash
+# revert_probe.sh — general-purpose ⓕ revert-and-observe probe (rung 강화 #2, six_axis_review_2026-09-04).
+#
+# WHY THIS EXISTS. `되돌림`(revert-and-observe) has been done by hand 15+ times in this repo's own
+# history (see 6축 실측: ⓕ none 비율 57.4%, «정확히 4레인 적색» 급 실물은 매번 손으로 짠 1회성
+# 스크립트였다). Hand-rolled revert probes are the exact shape §Mechanize-at-repetition names —
+# N≥3 recurrence on the SAME operation (swap a file to an older version, rerun a suite, read which
+# lines changed color) is a mechanization trigger, not a one-off. This is that mechanization.
+#
+# 🟥 FRONTIER WARNING — read before citing this tool's PASS as "the suite has detection power".
+#   A single revert of a single file is ONE mutant. Mutation-testing research (arXiv 2607.22880,
+#   and the companion Meta engineering write-up cited alongside it in
+#   frontier_verification_map_2026-09-04.md §ⓕ) found that coverage/mutation SCORE loses its
+#   correlation with real fault-detection effectiveness once suite size is controlled for — a
+#   single kill is evidence the ANCHOR under test is load-bearing for THIS ONE reverted file,
+#   never a general claim that the suite "has good mutation coverage" or "catches regressions".
+#   Run this against every file you actually care about; do not average or extrapolate from one.
+#
+# WHAT IT DOES
+#   1. Runs the lane suite AS-IS against the file's CURRENT (working-tree) content — the "수리 후"
+#      run.
+#   2. Swaps ONLY the target file to its content at --baseline (default HEAD), backing up the
+#      current content first.
+#   3. Reruns the same lane suite against that swapped-in baseline content — the "되돌린" run.
+#   4. Restores the target file to its exact pre-probe content — ALWAYS, even if either suite run
+#      crashes, hangs past its timeout, or this script itself errors. Restore is attempted from an
+#      EXIT trap (safety net) in addition to the normal-path restore, so a `kill`-free abnormal
+#      exit still restores. Physical restore, never `git checkout <ref> -- <path>` — that stages
+#      the revert into the index ([[feedback_git_checkout_path_stages_the_revert]]); this tool
+#      writes bytes to the file only, with `git show <ref>:<path>` (never `git checkout`), and
+#      never touches the index.
+#   5. Diffs the two runs' ✅/❌ label lines (this repo's universal `ok()`/`no()` convention —
+#      every test_*.sh / *_lanes.sh in scripts/ prints `  ✅ <label>` / `  ❌ <label>`) and reports
+#      EXACTLY which labels flipped from ✅ (current) to ❌ (baseline) — i.e. which lane actually
+#      went red when the fix was undone.
+#
+# WHAT IT ASSUMES (named, not hidden): the lane suite's ✅/❌ label text is STABLE across the two
+#   runs for a given lane (the suite script itself does not change between the two invocations —
+#   only the target file's content does). A suite whose pass/fail label text is dynamically built
+#   from data that changes with the target file (e.g. embeds a byte count in the label) will show
+#   as "label only in one run" rather than a flip — reported honestly as UNMATCHED, not silently
+#   dropped, and not counted toward the flip total.
+#
+# USAGE
+#   bash scripts/revert_probe.sh <target-file> <lane-suite-script> [--baseline <ref>] [--timeout <sec>]
+#   bash scripts/revert_probe.sh scripts/foo.sh scripts/test_foo_lanes.sh
+#   bash scripts/revert_probe.sh scripts/foo.sh scripts/test_foo_lanes.sh --baseline HEAD~1
+#
+# EXIT CODES (fail-closed, per CLAUDE.md §Irreversibility Surface-Class Degrade Invariant — this
+#   is a REVERSIBLE, read-then-restore surface, so the floor here is "never mis-score", not
+#   "never run"):
+#   0  = exactly ≥1 lane flipped ✅→❌ when reverted (anchor is alive — it caught the mutant)
+#   1  = 0 lanes flipped (anchor is DECORATIVE for this file — nothing depended on the fix)
+#   2  = usage error (bad args, target/suite/ref not found)
+#   10 = the probe itself is unreliable for this run — either suite run produced ZERO parseable
+#        ✅/❌ lines (harness error, not "0 lanes exist"), OR the restore step failed (the target
+#        file may still hold BASELINE content — treated as the more severe failure and reported
+#        loudly, never silently folded into a verdict)
+#
+# Usage in a lane test: see scripts/test_revert_probe_lanes.sh for the known-pair calibration
+# (decorative anchor → 1, real anchor → 0, restore-guaranteed-on-suite-crash).
+
+set -uo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+TARGET=""; SUITE=""; BASELINE="HEAD"; TIMEOUT="120"
+_POS=()
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --baseline) BASELINE="${2:-HEAD}"; shift 2 ;;
+    --timeout)  TIMEOUT="${2:-120}"; shift 2 ;;
+    -*)         echo "FAIL: unknown flag: $1" >&2; exit 2 ;;
+    *)          _POS+=("$1"); shift ;;
+  esac
+done
+TARGET="${_POS[0]:-}"; SUITE="${_POS[1]:-}"
+
+[ -n "$TARGET" ] || { echo "FAIL: usage: revert_probe.sh <target-file> <lane-suite-script> [--baseline <ref>]" >&2; exit 2; }
+[ -n "$SUITE" ]  || { echo "FAIL: usage: revert_probe.sh <target-file> <lane-suite-script> [--baseline <ref>]" >&2; exit 2; }
+[ -f "$TARGET" ] || { echo "FAIL: target file not found: $TARGET" >&2; exit 2; }
+[ -f "$SUITE" ]  || { echo "FAIL: lane suite script not found: $SUITE" >&2; exit 2; }
+
+# 🟥 physical path (`pwd -P`), not logical — macOS `/tmp` and `$TMPDIR` are symlinks into
+# `/private/...`, and `git rev-parse --show-toplevel` always answers with the PHYSICAL path.
+# A logical `pwd` here would make every fixture under a temp dir fail the prefix-strip below
+# (same class of defect `sim_isolated_run.sh` already names for its own path isolation).
+TARGET_DIR="$(cd "$(dirname "$TARGET")" && pwd -P)"
+TARGET_ABS="$TARGET_DIR/$(basename "$TARGET")"
+GIT_ROOT="$(cd "$TARGET_DIR" && git rev-parse --show-toplevel 2>/dev/null)"
+[ -n "$GIT_ROOT" ] || { echo "FAIL: target file is not inside a git repository: $TARGET" >&2; exit 2; }
+case "$TARGET_ABS" in
+  "$GIT_ROOT"/*) REL_PATH="${TARGET_ABS#"$GIT_ROOT"/}" ;;
+  *) echo "FAIL: could not compute a repo-relative path for $TARGET" >&2; exit 2 ;;
+esac
+
+if ! git -C "$GIT_ROOT" cat-file -e "${BASELINE}:${REL_PATH}" 2>/dev/null; then
+  echo "FAIL: $REL_PATH not found at baseline '$BASELINE' (bad ref, or the file did not exist there)" >&2
+  exit 2
+fi
+
+echo "── revert_probe ────────────────────────────────────────────────────"
+echo "target:   $REL_PATH"
+echo "suite:    $SUITE"
+echo "baseline: $BASELINE"
+echo ""
+echo "🟥 FRONTIER WARNING (arXiv 2607.22880): this run reverts EXACTLY ONE file — ONE mutant."
+echo "   A ✅ verdict here means the anchor caught THIS mutant, not that the suite has general"
+echo "   mutation-detection power. Coverage/mutation score decorrelates from real effectiveness"
+echo "   once suite size is controlled for — do not average or extrapolate from a single run."
+echo "되돌린 파일(뮤턴트) 수: 1 — $REL_PATH"
+echo ""
+
+WORKDIR="$(mktemp -d "${TMPDIR:-/tmp}/revert_probe.XXXXXX")" || { echo "FAIL: mktemp -d failed" >&2; exit 10; }
+BACKUP="$WORKDIR/backup"
+RUN_A="$WORKDIR/run_current.txt"
+RUN_B="$WORKDIR/run_baseline.txt"
+
+cp -p "$TARGET_ABS" "$BACKUP" || { echo "FAIL: could not back up $TARGET_ABS — refusing to touch it" >&2; rm -rf "$WORKDIR"; exit 10; }
+
+RESTORED=0
+_restore() {
+  [ "$RESTORED" = 1 ] && return 0
+  if cp -p "$BACKUP" "$TARGET_ABS" 2>/dev/null; then
+    RESTORED=1
+  else
+    echo "🟥🟥🟥 RESTORE FAILED — $TARGET_ABS may still hold BASELINE ($BASELINE) content." >&2
+    echo "    Backup of the pre-probe content is kept at: $BACKUP" >&2
+    echo "    Restore it by hand: cp \"$BACKUP\" \"$TARGET_ABS\"" >&2
+  fi
+}
+# Safety net — fires on ANY exit path (normal, error, unbound-var under set -u), so a crash
+# mid-probe still restores. The normal path below also calls _restore explicitly and checks its
+# result directly, because a trap cannot hand its own success/failure back to the exit-code logic.
+trap '_restore' EXIT
+
+_run_suite() { # $1=output-file
+  if command -v timeout >/dev/null 2>&1; then
+    timeout "$TIMEOUT" bash "$SUITE" > "$1" 2>&1
+  else
+    bash "$SUITE" > "$1" 2>&1
+  fi
+  return 0   # the suite's own exit code (pass/fail count) is not this function's concern
+}
+
+echo "── run 1/2: 현재(수리 후) 판 ──"
+_run_suite "$RUN_A"
+echo "  captured $(wc -l < "$RUN_A" | tr -d ' ') lines"
+
+if ! git -C "$GIT_ROOT" show "${BASELINE}:${REL_PATH}" > "$TARGET_ABS.new" 2>"$WORKDIR/show.err"; then
+  echo "FAIL: git show ${BASELINE}:${REL_PATH} failed:" >&2
+  cat "$WORKDIR/show.err" >&2
+  rm -f "$TARGET_ABS.new"
+  # trap restores (no-op here, file was never swapped) and exits
+  exit 10
+fi
+mv "$TARGET_ABS.new" "$TARGET_ABS"
+
+echo "── run 2/2: 기준($BASELINE) 판 (파일만 되돌림, 인덱스는 안 건드림) ──"
+_run_suite "$RUN_B"
+echo "  captured $(wc -l < "$RUN_B" | tr -d ' ') lines"
+
+_restore
+trap - EXIT   # explicit restore already ran; the safety net has nothing left to do
+if [ "$RESTORED" != 1 ]; then
+  echo "" >&2
+  echo "RESULT: RESTORE-FAILED — do not trust the file on disk, see backup path above" >&2
+  rm -rf "$WORKDIR"
+  exit 10
+fi
+
+# ── ✅/❌ 라벨 추출 — 심볼\tSPACE-트림한 설명 ────────────────────────────────────────────
+_extract_labels() { # $1=source-file → writes "P|F<TAB>desc"
+  grep -E '(✅|❌)' "$1" 2>/dev/null | while IFS= read -r line; do
+    case "$line" in
+      *✅*) sym=P; rest="${line#*✅}" ;;
+      *)   sym=F; rest="${line#*❌}" ;;
+    esac
+    rest="$(printf '%s' "$rest" | sed 's/^[[:space:]]*//; s/[[:space:]]*$//')"
+    [ -n "$rest" ] && printf '%s\t%s\n' "$sym" "$rest"
+  done
+}
+
+LABELS_A="$WORKDIR/labels_a.tsv"; LABELS_B="$WORKDIR/labels_b.tsv"
+_extract_labels "$RUN_A" > "$LABELS_A"
+_extract_labels "$RUN_B" > "$LABELS_B"
+NA=$(wc -l < "$LABELS_A" | tr -d ' ')
+NB=$(wc -l < "$LABELS_B" | tr -d ' ')
+
+if [ "$NA" -eq 0 ] || [ "$NB" -eq 0 ]; then
+  echo ""
+  echo "🟥 HARNESS ERROR — one of the two runs produced ZERO ✅/❌ lines (current=$NA, baseline=$NB)."
+  echo "   That is not \"0 lanes exist\" — it means this probe cannot see the suite's verdicts at"
+  echo "   all for that run (crash, missing labels, wrong suite path). Read the raw output:"
+  echo "     current:  $RUN_A"
+  echo "     baseline: $RUN_B"
+  rm -rf "$WORKDIR"
+  exit 10
+fi
+
+# DESC\tSYM, sorted by DESC — LC_ALL=C throughout so non-ASCII label text (this repo's labels are
+# routinely Korean) never collapses under a locale-dependent string-equality/sort
+# ([[feedback_locale_string_equality_breaks_nonascii]]).
+DESC_A="$WORKDIR/desc_a.tsv"; DESC_B="$WORKDIR/desc_b.tsv"
+awk -F'\t' '{print $2"\t"$1}' "$LABELS_A" | LC_ALL=C sort -t"$(printf '\t')" -k1,1 -k2,2 > "$DESC_A"
+awk -F'\t' '{print $2"\t"$1}' "$LABELS_B" | LC_ALL=C sort -t"$(printf '\t')" -k1,1 -k2,2 > "$DESC_B"
+
+JOINED="$WORKDIR/joined.tsv"
+LC_ALL=C join -t "$(printf '\t')" -j 1 -o 1.1,1.2,2.2 "$DESC_A" "$DESC_B" > "$JOINED" 2>/dev/null || : > "$JOINED"
+
+FLIPPED_RED="$WORKDIR/flipped_red.txt"     # ✅(현재) → ❌(기준) — 앵커가 실제로 잡은 것
+FLIPPED_GREEN="$WORKDIR/flipped_green.txt" # ❌(현재) → ✅(기준) — 이상 신호, 참고용
+awk -F'\t' '$2=="P" && $3=="F" {print $1}' "$JOINED" > "$FLIPPED_RED"
+awk -F'\t' '$2=="F" && $3=="P" {print $1}' "$JOINED" > "$FLIPPED_GREEN"
+K=$(wc -l < "$FLIPPED_RED" | tr -d ' ')
+J=$(wc -l < "$FLIPPED_GREEN" | tr -d ' ')
+
+# 라벨 텍스트가 두 실행에서 안 겹치는 경우 — 조용히 버리지 않고 이름으로 남긴다(가정 위반 알림).
+ONLY_A="$WORKDIR/only_a.txt"; ONLY_B="$WORKDIR/only_b.txt"
+LC_ALL=C comm -23 <(cut -f1 "$DESC_A" | LC_ALL=C sort -u) <(cut -f1 "$DESC_B" | LC_ALL=C sort -u) > "$ONLY_A"
+LC_ALL=C comm -13 <(cut -f1 "$DESC_A" | LC_ALL=C sort -u) <(cut -f1 "$DESC_B" | LC_ALL=C sort -u) > "$ONLY_B"
+NUM_ONLY_A=$(wc -l < "$ONLY_A" | tr -d ' '); NUM_ONLY_B=$(wc -l < "$ONLY_B" | tr -d ' ')
+
+echo ""
+echo "── 결과 ──────────────────────────────────────────────────────────"
+echo "현재(수리 후) 라벨: ${NA}줄  ·  기준($BASELINE) 라벨: ${NB}줄"
+echo ""
+echo "되돌린 레인 (✅→❌, 앵커가 실제로 잡은 것): ${K}개"
+if [ "$K" -gt 0 ]; then sed 's/^/    ❌ /' "$FLIPPED_RED"; fi
+echo ""
+echo "(참고) 반대방향 (❌→✅, 이상 신호): ${J}개"
+if [ "$J" -gt 0 ]; then sed 's/^/    ⚠️  /' "$FLIPPED_GREEN"; fi
+if [ "$NUM_ONLY_A" -gt 0 ] || [ "$NUM_ONLY_B" -gt 0 ]; then
+  echo ""
+  echo "🟥 라벨 텍스트가 두 실행에서 완전히 겹치지 않는다 — 이 도구의 가정(라벨 텍스트가 안정적)"
+  echo "   이 이 스위트에서는 안 맞을 수 있다. 아래는 매칭 대상에서 빠진 라벨(플립 집계에 미포함):"
+  [ "$NUM_ONLY_A" -gt 0 ] && sed 's/^/    현재에만: /' "$ONLY_A"
+  [ "$NUM_ONLY_B" -gt 0 ] && sed 's/^/    기준에만: /' "$ONLY_B"
+fi
+
+echo ""
+if [ "$K" -ge 1 ]; then
+  echo "판정: 앵커 살아있음 — 되돌리면 정확히 ${K}개 레인이 빨개진다"
+  rm -rf "$WORKDIR"
+  exit 0
+else
+  echo "판정: 앵커 장식 — 되돌려도 빨개지는 레인이 0개다"
+  rm -rf "$WORKDIR"
+  exit 1
+fi

package/scripts/selfcheck.sh

@@ -187,10 +187,22 @@ else
   fail=1
 fi
 
-# Bash surface: npm-shipped scripts + local bin wrappers + gate-chain infra
+# Bash surface: npm-shipped scripts + local bin wrappers + gate-chain infra.
+# `bin/fh-gate` · `bin/fh-run` · `bin/fh-goal` are named EXPLICITLY here (not a glob) and, unlike
+# most of this list, are not covered by files_manifest_shipping_check.sh either (only their
+# `.js` counterparts are declared in package.json files[]) — so a plain `[ -f "$f" ] || continue`
+# made their disappearance invisible to BOTH checks at once. Reproduced 2026-09-03: deleting
+# bin/fh-gate from a fixture tree left fail=0, no FAIL line, nothing. `scripts/*.sh` staying a
+# silent skip on a genuinely-empty glob is correct (that arm still has no non-glob name); the
+# named gate-chain-infra paths must not degrade the same way.
 for f in scripts/*.sh bin/fh-gate bin/fh-run bin/fh-goal \
          templates/regression_guard.sh templates/temper_check.sh templates/predelete_check.sh templates/.git-hooks/pre-commit; do
-  [ -f "$f" ] || continue
+  if [ ! -f "$f" ]; then
+    case "$f" in
+      *'*'*) continue ;;   # unmatched glob (nullglob off) — not a real path, legitimate skip
+      *) echo "FAIL  bash -n coverage: gate-chain infra file missing: $f"; fail=1; continue ;;
+    esac
+  fi
   check "bash -n $f" bash -n "$f"
 done
 
@@ -615,10 +627,12 @@ for _pair in \
   ".claude/soul_tenets.txt|scripts/test_marker_soul_tenet_lanes.sh" \
   "templates/.git-hooks/pre-commit|scripts/test_precommit_staged_drift_lanes.sh" \
   "templates/.git-hooks/pre-commit|scripts/test_marker_address_lanes.sh" \
+  "templates/.git-hooks/pre-commit|scripts/test_precommit_pointer_index_lanes.sh" \
   "scripts/residency_closure_scan.py|scripts/test_residency_closure_lanes.sh" \
   "scripts/reviewer_capability_corpus.tsv|scripts/test_reviewer_capability_conformance.sh" \
   "scripts/field_canon_preload.sh|scripts/test_field_canon_lanes.sh" \
   "scripts/stale_clone_guard.sh|scripts/test_stale_clone_guard_lanes.sh" \
+  "scripts/proposal_hook.sh|scripts/test_proposal_hook_lanes.sh" \
   "plugins/fh-commons/skills/ko-tech-writer/SKILL.md|scripts/test_ko_tech_writer_lanes.sh" \
   "scripts/script_caller_ratchet.sh|scripts/test_script_caller_ratchet_lanes.sh" \
   "scripts/script_caller_ratchet.sh|scripts/test_runner_surface_index_lanes.sh" \
@@ -631,6 +645,7 @@ for _pair in \
   "plugins/fh-commons/skills/preprep/lane_adjacent_dup.py|scripts/test_preprep_adjacent_dup_lanes.sh" \
   "plugins/fh-commons/skills/preprep/lane_promise.py|scripts/test_preprep_promise_lanes.sh" \
   "plugins/fh-commons/skills/preprep/SKILL.md|scripts/test_preprep_drift_anchor.sh" \
+  "scripts/test_preprep_drift_anchor.sh|scripts/test_preprep_drift_anchor_lanes.sh" \
   "scripts/field_canon_preload.sh|scripts/test_skill_canon_preload_lanes.sh" \
   `# ── round/ 회차 계기 4종(2026-09-01). 넷 다 한 스위트가 잡는다 — 주체별로 행을 둔다 ──` \
   "scripts/round/delta_guard.sh|scripts/test_round_instruments_lanes.sh" \
@@ -1056,6 +1071,29 @@ else
   esac
 fi
 
+# prepublish_scope_note — an embedded --self-test subject lane_runner_check.sh flagged as having
+# no dispatcher anywhere (2026-09-03): its own 7-lane known-pair (does validate.yml still call
+# selfcheck.sh — known-positive/negative, missing-workflow, commented-out call, real call beside a
+# stale commented one, the real `run: |` block-scalar shape, and echo-mention-is-not-a-call) lives
+# behind `--self-test`, and nothing runs it. It IS invoked at publish time (package.json
+# `prepublishOnly`) — but that is `check()`, the gate's default argument-less mode, running for
+# real; it never exercises the gate's OWN calibration. Not in the `for _subj in ...` loop above:
+# its terminal line is `── N pass / M fail`, never 캘리브레이션, same reason capability_registry_check
+# and capability_effect_probe were pulled out of that loop. Direct dispatch instead, same shape as
+# capability_effect_probe.sh above — whole-line terminal verdict with a non-zero PASS count, so an
+# emptied suite cannot certify itself. Ships via package.json files[], so absence is FAIL, not SKIP.
+if [ ! -f scripts/prepublish_scope_note.sh ]; then
+  echo "FAIL  prepublish_scope_note.sh: missing — it ships via package.json files[], so absence is deletion, not package mode"
+  fail=1
+elif _out=$(bash scripts/prepublish_scope_note.sh --self-test < /dev/null 2>&1) \
+     && printf '%s\n' "$_out" | grep -qE '^  ── [1-9][0-9]* pass / 0 fail$'; then
+  echo "PASS  prepublish_scope_note.sh --self-test ($(printf '%s\n' "$_out" | grep -oE '[0-9]+ pass / [0-9]+ fail' | tail -1))"
+else
+  echo "FAIL  prepublish_scope_note.sh: --self-test failed or produced no terminal verdict line"
+  _show_failure "$_out"
+  fail=1
+fi
+
 # 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
@@ -1143,6 +1181,20 @@ else
   fail=1
 fi
 
+# ⓕ 되돌림 범용 프로브 (six_axis_review_2026-09-04 강화 #2) — 15+ 손짜기 되돌림 스크립트를
+# 대체하는 계기다. 자기 자신을 known-pair 로 검증한다(장식 앵커→1, 실물 앵커→0, 복원 보장) —
+# 앵커가 아니라 그 앵커를 검증하는 계기이므로 반드시 실행돼야 한다.
+if [ ! -f scripts/revert_probe.sh ]; then
+  _absent_subject_verdict "test_revert_probe_lanes.sh" "scripts/revert_probe.sh" || fail=1
+elif [ -f scripts/test_revert_probe_lanes.sh ]; then
+  if ! bash scripts/test_revert_probe_lanes.sh; then
+    fail=1
+  fi
+else
+  echo "FAIL  test_revert_probe_lanes.sh: revert_probe.sh present but its anchor is missing"
+  fail=1
+fi
+
 # 무효 워터마크 — 무효 회차의 «숫자 줄»이 자기 무효를 나르는가.
 # 🟥 회차 3 은 자기 게이트가 VOID 를 찍고도 그 숫자만 기록으로 넘어갔다(VOID 낱말은 0회).
 #    판정이 표 «밖»에 있었고 사람은 표를 복사하기 때문이다. 그 채널을 닫은 배선의 앵커다.
@@ -1544,6 +1596,17 @@ else
   fail=1
 fi
 
+if [ ! -f scripts/backtick_guard.sh ]; then
+  _absent_subject_verdict "test_backtick_guard_lanes.sh" "scripts/backtick_guard.sh" || fail=1
+elif [ -f scripts/test_backtick_guard_lanes.sh ]; then
+  if ! bash scripts/test_backtick_guard_lanes.sh; then
+    fail=1
+  fi
+else
+  echo "FAIL  test_backtick_guard_lanes.sh: backtick_guard.sh present but its anchor is missing"
+  fail=1
+fi
+
 if [ ! -f scripts/halffix_propagation_scan.sh ]; then
   _absent_subject_verdict "test_halffix_lanes.sh" "scripts/halffix_propagation_scan.sh" || fail=1
 elif [ -f scripts/test_halffix_lanes.sh ]; then

package/scripts/sim_isolated_run.sh

@@ -46,6 +46,18 @@
 #       same clone, --tools "", no --restricted   → "🐿️"                  (memory PRESENT)
 #   One variable, opposite answers. ([[feedback_instrument_cannot_discriminate_hypotheses]])
 #
+# 🟥 THE SAME FLAG ALSO KILLS `act` MODE'S WRITE PATH — measured 2026-09-03, known-pair.
+#   `--restricted` ignores settings for PERMISSIONS too, not just memory, and `-p` has no TTY to
+#   ask a human — so `act`+`--no-harness` cannot Write/Edit AT ALL, regardless of what the model
+#   decides. Confirmed with one variable (`--restricted` on/off, same prompt, same --tools): Edit
+#   succeeds without it; with it every rep says "The edit was blocked — permission to write to
+#   file.txt wasn't granted." Deterministic, not a race — this is why a real run reads 5/5.
+#   ⇒ A "did not edit" result from `act --no-harness` is NOT evidence the base model chose not to
+#   write. Use `--no-harness` as an observe-mode control (memory presence, per the pair above)
+#   only — never to ask whether a write would have happened. Workaround not built: `--restricted`
+#   still honors an explicit `--settings <file>` (per `claude --help`), so a minimal file carrying
+#   only Write/Edit approval could restore act-mode fidelity here — filed, not implemented.
+#
 # 🟢 AND THE DEFECT IS REUSABLE AS AN INSTRUMENT. `--no-harness` answers a question this repo
 #   asks constantly and usually by eye: **does this behaviour come from FH, or would the base
 #   model have done it anyway?** Run the same prompt with and without the flag; a behaviour that
@@ -69,17 +81,74 @@
 #   FH defect (a normal session has Bash and can `ls`) — but scoring an arm without knowing it
 #   produces a confident zero from a fixture that was never observable.
 #
-# 🟥 PROJECT HOOKS DO NOT RUN IN A DISPOSABLE CLONE — so this runner cannot measure anything
-#   that depends on one. Measured 2026-08-30: an arm copied `.claude/settings.json` into its clone
-#   to make the PreToolUse PriorArt hook live; not one of the three clones grew
-#   `.claude/.prior_art_events.tsv`, while the live repo's copy carries entries from the same hour.
-#   The hook never fired, so the "hook vs no-hook" contrast was HOOK ≡ NOHOOK and either verdict
-#   would have been false. ⇒ Before claiming a hook-dependent result, check the hook's own
-#   evidence file INSIDE the clone; absence of that file invalidates the arm, not the hypothesis.
+# 🟥 PROJECT HOOKS DO RUN IN A DISPOSABLE CLONE — an earlier version of this paragraph said the
+#   opposite, and it was wrong (RETRACTED 2026-09-03). It read: "PROJECT HOOKS DO NOT RUN IN A
+#   DISPOSABLE CLONE … measured 2026-08-30: an arm copied `.claude/settings.json` into its clone to
+#   make the PreToolUse PriorArt hook live; not one of the three clones grew
+#   `.claude/.prior_art_events.tsv`". That absence was read as "hooks never fire here" with NO
+#   control arm whose hook was known to fire — and it narrowed two rounds of the identity-⑤
+#   design (the hook-layer arm was declared unmeasurable). Known pair, 2026-09-03: a PreToolUse
+#   Bash hook that appends to `$CLAUDE_PROJECT_DIR/_hook_evidence.txt`, installed via
+#   `--setup 'cp <settings.json> .claude/settings.json'`, FIRED inside this runner's own clone
+#   (act mode, deny settings.local.json present) and in a bare `claude -p` clone, trusted or not.
+#   Why the 2026-08-30 arm saw nothing — CONFIRMED the same day, one more known pair: with the
+#   real project hook set copied into a clone, an arm asked to build a new mechanism script FOUND
+#   PRIOR ART and never called Write (identity-④ behaviour), so the Write-matched PriorArt hook had
+#   nothing to fire on; an arm forced to Write a new scripts/*.sh produced `.prior_art_events.tsv`
+#   with a FIRE row inside the clone. The stimulus never reached the hook — a hook that is never
+#   triggered looks identical to a hook that cannot run, which is why a control arm whose hook is
+#   KNOWN to fire is mandatory. Signal: tracks/_meta/fh_signal_2026-09-03_runner-hooks-do-fire.md
+#   What SURVIVES from the old paragraph: before claiming a hook-dependent result, check the
+#   hook's own evidence file INSIDE the clone; absence of that file invalidates the ARM, never the
+#   hypothesis. And `--setup` writing an UNTRACKED file (.claude/settings.json is gitignored) is
+#   not contamination — the tree baseline is taken after setup, and git status never sees it.
 #
 # 🟥 CONTROL IS NOT OPTIONAL. Always run at least one arm whose correct answer is "the thing
 #   being measured should NOT fire". An instrument that fires on everything measures nothing
 #   ([[feedback_control_presence_is_not_discrimination]]).
+#
+# ── ⓒ 격리 그라운딩 — 날짜 오염 통제 (six_axis_review_2026-09-04 강화 #3, RECORD ONLY) ──────────
+#   WHY: LiveCodeBench (arXiv 2403.07974) and the contamination-taxonomy literature
+#   (frontier_verification_map_2026-09-04.md §ⓒ) filter benchmark items by RELEASE DATE precisely
+#   because a model can have memorized — not reasoned about — anything published before its
+#   training cutoff. This runner has the same exposure: a sim arm's "correct" answer about a
+#   doc/rule/gate can be recall of that doc's OWN CONTENT (if the doc predates the model's cutoff
+#   and the model happened to see this repo, or a near-identical one, during training) rather than
+#   evidence the harness under test actually delivers the behaviour to a cold session.
+#   THIS IS A RECORDING, NOT A GATE — per CLAUDE.md §Mechanization Boundary, "what the right value
+#   IS" stays judgment; only "was it recorded" is a channel. Below writes two fields per rep to
+#   `<out>/<arm>_r<rep>.meta.tsv` and does NOT compare them or fail a run on their basis:
+#     corpus_head_date   — the clone's HEAD commit date (ISO 8601). PROXY, named honestly: this
+#                          runner cannot resolve which files a given PROMPT actually cites, so it
+#                          records the whole corpus's most recent commit as an upper bound on
+#                          "how fresh could the cited material be", not a per-file citation date.
+#     sim_model / sim_model_cutoff — the `--model` value and a best-effort known cutoff via
+#                          `_model_known_cutoff()` below, `UNKNOWN` when not recorded there. This
+#                          table WILL go stale as new models ship — it is deliberately not treated
+#                          as authoritative; a scoring session should verify the cutoff it cites
+#                          rather than trust this file's guess (§Instrument-Calibration).
+#
+# ── ⓒ 격리 그라운딩 — 일회용 샌드박스 표준 (six_axis_review_2026-09-04 강화 #3) ─────────────────
+#   프런티어 대조표가 "ephemeral wipe-and-reseed 샌드박스(E2B/Modal/Runloop)"를 도입 후보로 든다.
+#   조직 제약상 외부 도구는 보류하고(§도입 후보 3), 이 러너가 "이미 그렇게 동작하는 부분"과
+#   "아닌 부분"을 정직하게 갈라 적는다 — 매번 재발견하지 않도록.
+#
+#   WIPE (매 rep 마다 새로 만든다 — 재사용 없음):
+#     ✅ 이미 참 — 매 rep 이 독립된 `git clone` (§위 "A disposable clone per REP") + 독립된 부모
+#        디렉터리(§L10). 오늘 실행한 실측 (`test_sim_isolated_run_lanes.sh`):
+#          ✅ L10 no clone shares a parent with another (2 clones, 0 co-parented)
+#          ✅ L10b control — 2 clones found (L10 did not pass on an empty set)
+#        (재현: `bash scripts/test_sim_isolated_run_lanes.sh` — 위 두 줄이 그대로 나온다.)
+#   RESEED (팔이 못 보면 안 되는 자산을 클론에서 지운다):
+#     ✅ 이미 참 — ARM_BLIND_PATHS 제거(§아래) + 그 자체가 known-pair 로 검정됨:
+#          ✅ L24 팔 눈가림 자산이 클론에서 제거된다 (히트 >0 → 0)
+#   기계-표면 리셋 (LaunchAgents/crontab/settings — VM 리셋과 달리 "지우고 다시 만들지" 않는다):
+#     🟥 아직 부분 — observe 모드는 도구 자체가 없어 못 건드리고(구조적 예방), act 모드는 실제
+#        변경을 만들고 나서 **탐지**만 한다(§L7). "매 rep 전 기계 상태를 초기화"는 하지 않는다 —
+#        E2B/Modal 급 VM wipe-and-reseed와의 실제 델타는 이 한 줄이다. 진짜 OS 샌드박스가 필요한
+#        이유는 헤더 상단 "WHAT THIS GIVES YOU" 절이 이미 말한다 — 여기서 되풀이하지 않는다.
+#   요약: 파일시스템 코퍼스 축(WIPE+RESEED)은 클론 단위로 이미 wipe-and-reseed다. 기계 표면 축은
+#   아니다 — 탐지기이지 리셋기가 아니다. 이 두 문장이 "샌드박스 표준"의 정직한 전부다.
 
 set -uo pipefail
 
@@ -274,6 +343,16 @@ snapshot() {
   } > "$f"
 }
 
+# ⓒ 날짜 오염 통제 — 기록 전용 헬퍼(§헤더 참조). 판정 아님, 있으면 값·없으면 UNKNOWN.
+# 🟥 이 표는 부패한다(stale) — 새 모델이 나올 때마다 손으로 갱신해야 한다. 여기 적힌 값을
+# «검증됨»으로 인용하지 마라: 이 스크립트 자신이 그렇게 적어두라고 요구한다(§Instrument-Calibration).
+_model_known_cutoff() { # $1=--model 값 → ISO 월 또는 UNKNOWN
+  case "$1" in
+    *sonnet-5*|sonnet) printf '2026-01' ;;   # 이 세션의 시스템 프롬프트가 스스로 적은 값
+    *) printf 'UNKNOWN' ;;
+  esac
+}
+
 echo "── sim_isolated_run ──────────────────────────────────────────────"
 echo "arm=$ARM mode=$MODE model=$MODEL reps=$REPS timeout=${TIMEOUT}s"
 echo "out=$OUTDIR"
@@ -318,6 +397,17 @@ for r in $(seq 1 "$REPS"); do
     continue
   fi
 
+  # ⓒ 날짜 오염 통제 — 기록만, 판정 아님(§헤더). corpus_head_date 는 "프롬프트가 인용하는
+  # 파일들"의 날짜가 아니라 그 상한(코퍼스 전체 HEAD)이다 — 러너는 프롬프트가 무엇을 인용하는지
+  # 모르므로 더 좁게 잴 수 없다. 그렇게 좁혀 적는다.
+  _corpus_date=$(git -C "$WORK" log -1 --format=%cI 2>/dev/null); [ -n "$_corpus_date" ] || _corpus_date="UNKNOWN"
+  _cutoff=$(_model_known_cutoff "$MODEL")
+  {
+    printf 'corpus_head_date\t%s\n' "$_corpus_date"
+    printf 'sim_model\t%s\n' "$MODEL"
+    printf 'sim_model_cutoff\t%s\n' "$_cutoff"
+  } > "$OUTDIR/${ARM}_r${r}.meta.tsv"
+
   # ── 🟥 팔이 읽으면 안 되는 tracked 자산을 «클론 안에서» 제거한다 (2026-09-01) ──────
   # 왜: 얼린 정답지(`scripts/fixtures/knownpair_refusal_48_*`)가 tracked 가 되면서
   #     **모든 팔의 클론에 들어갔다.** 실측 — negative 문항의 핵심 명사구가 그 안에 있다

package/scripts/test_backtick_guard_lanes.sh

@@ -0,0 +1,115 @@
+#!/usr/bin/env bash
+# test_backtick_guard_lanes.sh — known pairs for scripts/backtick_guard.sh. Written BEFORE the detector.
+#
+# WHAT IS BEING GUARDED
+#   A backtick inside a shell DOUBLE-QUOTING CONTEXT — an unquoted heredoc body (`<<EOF`) or a
+#   "double-quoted string" — is command substitution: the text between the backticks is REPLACED by
+#   the command's output. With no such command the output is empty, so the text is DELETED; with one,
+#   foreign content is INSERTED. The sentence stays grammatical (only its subject is gone), the only
+#   signal is one `command not found` line at the top of the output, and every marker/record hook
+#   checks a field's presence, not its completeness.
+#   Measured 7× (2026-08-10 · 2026-09-01 ×3 · 2026-09-02 ×4 — marker, RESULT doc, fh_completed echo ×2)
+#   with a resident memory rule that failed each time because the actor's task had a different NAME
+#   (writing a marker · a failure message · a seal). N≥3 → mechanize (weekly_audit_2026-09-02 HIGH #1).
+#
+#   BT1 — unquoted heredoc body (`<<TAG`, `<<-TAG`; NOT `<<'TAG'` / `<<"TAG"` / `<<\TAG`) containing `
+#   BT2 — double-quoted string containing ` (single-quoted text and `\`` are literal → CLEAN)
+#
+# Surface = the Bash tool call itself (interactively-composed commands), same reasoning as
+# pipe_verdict_guard: every recurrence was in a composed command, none in a shipped file.
+
+set -u
+G="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/backtick_guard.sh"
+pass=0; fail=0
+
+# expect <label> <HIT|CLEAN> <command-string>   (the command text is passed raw via --stdin-raw)
+expect() {
+  local label="$1" want="$2" cmd="$3" out got
+  out=$(printf '%s' "$cmd" | bash "$G" --stdin-raw 2>&1)
+  # want may be HIT · CLEAN · HIT:BT1@2 (rule and line asserted — a hit on the WRONG line is a miss)
+  if printf '%s' "$out" | grep -q 'BACKTICK'; then got=HIT; else got=CLEAN; fi
+  case "$want" in HIT:*) printf '%s' "$out" | grep -q "${want#HIT:BT}" 2>/dev/null; :; esac
+  if [ "$got" = HIT ] && [ "${want%%:*}" = HIT ] && [ "$want" != HIT ]; then
+    local r="${want#HIT:}"; r="${r%@*}"; local l="${want##*@}"
+    printf '%s' "$out" | grep -q "$r L$l " || got="HIT-WRONG($(printf '%s' "$out" | grep -oE 'BT[12] L[0-9]+' | head -1))"
+    [ "$got" = HIT ] && got="$want"
+  fi
+  if [ "$got" = "$want" ]; then
+    printf '  ✅ %-56s %s (expected %s)\n' "$label" "$got" "$want"; pass=$((pass+1))
+  else
+    printf '  ❌ %-56s %s (expected %s)\n' "$label" "$got" "$want"; fail=$((fail+1))
+    printf '     cmd: %s\n     out: %s\n' "$cmd" "$out"
+  fi
+}
+BT='`'   # one backtick, spelled once so the lanes below never carry a live one in double quotes
+NL=$'\n'
+
+echo "[backtick-guard] known pairs"
+echo "-- BT1: unquoted heredoc body --"
+# 2026-09-02 ⓐ — the measured shape: a marker written through an unquoted heredoc so a $VAR expands.
+expect "BT1 measured: marker heredoc"        HIT:BT1@3   "cat > m.marker <<EOF${NL}date: \$TODAY${NL}axis2-evidence: 러너가 ${BT}--keep-blind-paths${BT} 를 삼켰다${NL}EOF"
+expect "BT1 <<-TAG (tab-stripped) form"      HIT   "cat <<-EOF${NL}	note ${BT}x${BT}${NL}	EOF"
+expect "BT1 markdown fence in heredoc"       HIT   "cat > r.md <<EOF${NL}\`\`\`${NL}out${NL}\`\`\`${NL}EOF"
+expect "BT1 second of two heredocs on a line" HIT:BT1@4  "diff <(cat <<'A') <(cat <<B)${NL}${BT}a${BT}${NL}A${NL}${BT}b${BT}${NL}B"
+expect "BT1 quoted <<'EOF' is CLEAN"          CLEAN "cat > m.marker <<'EOF'${NL}evidence: ${BT}--keep-blind-paths${BT} 삼킴${NL}EOF"
+expect "BT1 quoted <<\"EOF\" is CLEAN"        CLEAN "cat <<\"EOF\"${NL}${BT}x${BT}${NL}EOF"
+expect "BT1 escaped <<\\EOF is CLEAN"         CLEAN "cat <<\\EOF${NL}${BT}x${BT}${NL}EOF"
+expect "BT1 backslash-escaped backtick CLEAN" CLEAN "cat <<EOF${NL}see \\${BT}x\\${BT}${NL}EOF"
+expect "BT1 backtick AFTER the body ends"     CLEAN "cat <<EOF${NL}plain${NL}EOF${NL}echo '${BT}later${BT}'"
+expect "BT1 <<< herestring is not a heredoc"  CLEAN "grep -c x <<< 'a ${BT}b${BT}'"
+
+echo "-- BT2: double-quoted string --"
+# 2026-09-02 ⓑ — the measured shape: a completion-log append through echo "…".
+expect "BT2 measured: echo append"            HIT:BT2@1   "echo \"- ✅ 러너 ${BT}sim_isolated_run.sh${BT} 헤더 경고\" >> tracks/_meta/fh_completed.md"
+expect "BT2 failure-message string (09-01)"   HIT   "printf '%s\\n' \"(${BT}nameleak_check.sh gen${BT} 을 써라)\""
+expect "BT2 single quote inside dq is inert"  HIT   "echo \"don't ${BT}x${BT}\""
+expect "BT2 single-quoted is CLEAN"           CLEAN "printf '%s\\n' '- ✅ 러너 ${BT}sim_isolated_run.sh${BT} 헤더' >> log.md"
+expect "BT2 escaped \\\` is CLEAN"             CLEAN "echo \"see \\${BT}x\\${BT}\""
+expect "BT2 dq inside single quotes is CLEAN" CLEAN "echo '\"${BT}x${BT}\"'"
+expect "BT2 sq inside \$( ) inside dq CLEAN"  CLEAN "echo \"\$(printf '%s' '${BT}x${BT}')\""
+expect "BT2 no backtick at all"               CLEAN "echo \"\$(git log -1) done\" && cat <<EOF${NL}plain \$X${NL}EOF"
+expect "BT2 bare backtick outside quotes"     CLEAN "V=${BT}date${BT}; echo ok"   # live command substitution on purpose, not a text context
+
+echo "-- Axis-2 pass 2026-09-03 (challenger, repros executed by the governor) --"
+# A1: the first build stripped single-quoted spans BEFORE matching heredoc operators, so <<'EOF' was
+# never a heredoc — three symptoms from one cause. Each pinned in its real shape.
+expect "A1a quoted body with dq+backtick CLEAN" CLEAN "cat <<'EOF'${NL}axis2-evidence: 메시지 \"use ${BT}x${BT}\" 가 떴다${NL}EOF"
+expect "A1b quoted A then unquoted B: only B" CLEAN "diff <(cat <<'A') <(cat <<B)${NL}${BT}a${BT}${NL}A${NL}plain${NL}B"
+expect "A1c apostrophe in quoted body, then echo" HIT:BT2@4 "cat <<'EOF'${NL}don't${NL}EOF${NL}echo \"${BT}x${BT}\" >> log"
+# A2: a comment's apostrophe must not open a single-quote context that swallows the next line.
+expect "A2 comment apostrophe then echo"      HIT:BT2@2 "# don't re-run this${NL}echo \"${BT}x${BT}\" >> f.md"
+expect "A2 url fragment is not a comment"     HIT:BT2@1 "curl \"https://x/a#frag ${BT}x${BT}\""
+# B3: <<TAG inside a double-quoted string (commit message) opens no heredoc.
+expect "B3 <<EOF in commit message is CLEAN" CLEAN "git commit -m \"docs: prefer <<EOF for markers\"${NL}V=${BT}date${BT}; echo ok"
+# B5: escaped backslash + LIVE backtick.
+expect "B5 \\\\ then live backtick HITs"      HIT:BT1@2 "cat <<EOF${NL}path\\\\${BT}x${BT}${NL}EOF"
+# B2: ANSI-C $'…' with an escaped apostrophe does not end early.
+expect "B2 \$'don\\'t' then dq backtick"      HIT:BT2@1 "echo \$'don\\'t' \"${BT}x${BT}\""
+# B1: backtick inside \$( ) re-entered from dq is live substitution — deliberately NOT flagged.
+expect "B1 backtick inside \$( ) in dq CLEAN"  CLEAN "echo \"\$(echo ${BT}x${BT})\""
+
+echo "-- hook mode: JSON payload in → JSON out (A4: detection is worthless if delivery is 0) --"
+jexp() {  # <label> <expect-substring-in-additionalContext|SILENT> <env> <payload>
+  local label="$1" want="$2" env_="$3" payload="$4" out ctx
+  out=$(printf '%s' "$payload" | env $env_ bash "$G" 2>/dev/null)
+  if [ "$want" = SILENT ]; then
+    if [ -z "$out" ]; then printf '  ✅ %-56s SILENT\n' "$label"; pass=$((pass+1)); else printf '  ❌ %-56s expected SILENT, got: %s\n' "$label" "${out:0:80}"; fail=$((fail+1)); fi
+    return
+  fi
+  ctx=$(printf '%s' "$out" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(d["hookSpecificOutput"]["additionalContext"])' 2>/dev/null)
+  if printf '%s' "$ctx" | grep -q "$want"; then printf '  ✅ %-56s JSON additionalContext carries %s\n' "$label" "$want"; pass=$((pass+1))
+  else printf '  ❌ %-56s no JSON/context (%s)\n' "$label" "${out:0:80}"; fail=$((fail+1)); fi
+}
+P='{"tool_name":"Bash","tool_input":{"command":"echo \"- done `x.sh` ok\""}}'
+jexp "JSON payload → additionalContext"       "BT2 L1" "X=1" "$P"
+jexp "ascii PYTHONIOENCODING still emits"     "BT2 L1" "PYTHONIOENCODING=ascii" "$P"
+jexp "non-Bash tool is SILENT"                SILENT   "X=1" '{"tool_name":"Write","tool_input":{"content":"`x`"}}'
+jexp "unparseable payload is SILENT"          SILENT   "X=1" 'not json'
+
+echo "-- opt-out / payload --"
+expect "noqa exempts"                         CLEAN "echo \"${BT}x${BT}\"  # noqa: backtick"
+expect "empty payload"                        CLEAN ""
+
+echo
+echo "[backtick-guard] $pass passed, $fail failed"
+[ "$fail" -eq 0 ]