@chrono-meta/fh-gate 2.15.0 → 3.0.0

package/scripts/package_coverage_check.sh

@@ -63,6 +63,7 @@ ACCEPTED_ABSENT=(
   "scripts/round/target_pin.sh"
   "scripts/round/instrument_manifest.sh"
   "scripts/round/eligcheck_qset.sh"
+  "scripts/round/gatecheck_qset.sh"          # 같은 이유 — 회차 개시 게이트, 소비자 표면 아님 (2026-09-02 짝표 등재로 참조가 생겼다)
   "scripts/test_round_instruments_lanes.sh"
   "scripts/fixtures/isolation_assembly_BROKEN_2026-08-30_ccrun7.json"  # 역사 산출물(등급표가 증거로 인용)
   "scripts/outbound_query_guard.sh"
@@ -359,12 +360,34 @@ if ORACLE == 'tarball':
         if r.returncode != 0:
             print(f"ORACLE_UNAVAILABLE\tnpm pack exited {r.returncode}")
             raise SystemExit(2)
-        packed = {f['path'] for f in json.loads(r.stdout)[0]['files']}
+        # Two shapes have been seen for `npm pack --dry-run --json`: the documented one carries
+        # `[0]['files'][*]['path']`; inside `npm publish`'s prepublishOnly on the CI runner
+        # (Node 22 / npm 10, 2026-09-04, v3.0.0 first OIDC publish) the same call returned JSON
+        # WITHOUT that key and this block died with a bare KeyError — fail-closed (correct) but
+        # blind (no diagnosis). Parse defensively, and when the JSON does not carry a file list
+        # fall back to the text listing (`npm notice <size> <path>` lines), which is what a human
+        # reads. The diagnostic line prints the head of stdout so the NEXT failure names its shape.
+        parsed = json.loads(r.stdout)
+        entry = parsed[0] if isinstance(parsed, list) and parsed else (parsed if isinstance(parsed, dict) else None)
+        flist = (entry or {}).get('files') if isinstance(entry, dict) else None
+        if flist and all(isinstance(f, dict) and 'path' in f for f in flist):
+            packed = {f['path'] for f in flist}
+        else:
+            t = subprocess.run(['npm', 'pack', '--dry-run'], capture_output=True, text=True, timeout=180)
+            lines = (t.stdout + '\n' + t.stderr).splitlines()
+            packed = set()
+            for ln in lines:
+                m = re.match(r'^npm notice\s+[0-9.]+[kMG]?B\s+(\S+)\s*$', ln)
+                if m:
+                    packed.add(m.group(1))
+            if not packed:
+                print(f"ORACLE_UNAVAILABLE\tnpm pack --json had no files[].path and the text listing had no file lines; json head: {r.stdout[:200]!r}")
+                raise SystemExit(2)
     except FileNotFoundError:
         print("ORACLE_UNAVAILABLE\tnpm is not on PATH — the tarball cannot be read")
         raise SystemExit(2)
     except (json.JSONDecodeError, KeyError, IndexError) as e:
-        print(f"ORACLE_UNAVAILABLE\tnpm pack --json did not parse ({type(e).__name__})")
+        print(f"ORACLE_UNAVAILABLE\tnpm pack --json did not parse ({type(e).__name__}); stdout head: {r.stdout[:200]!r}")
         raise SystemExit(2)
     except subprocess.TimeoutExpired:
         print("ORACLE_UNAVAILABLE\tnpm pack timed out")

package/scripts/proposal_hook.sh

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+# proposal_hook.sh — PreToolUse(Edit|Write|Bash) advisory: a verdict/guard line in scripts/**/*.sh or
+# templates/*.sh is about to change → put ONE proposal instruction into the model's context
+# (additionalContext): «offer the user a known-pair control + degrade_direction_scan.sh in one line».
+#
+# WHY A HOOK (identity ⑤, measured 2026-09-03)
+#   r3: a CLAUDE.md table row keyed on this exact file class fired 1/15 at floor tier (that 1 a
+#   recitation). r4: this hook, installed in a disposable clone, fired on 9/10 editing reps and the
+#   floor session relayed the proposal 9/9; the hard negative (a usage-string edit in a .sh) 0/5.
+#   Same tasks, same tier, same prose layer — the row 0, the channel 100%. That is the
+#   «explicit instruction 3/3 · advisory 0/3 · framing 0/3» result of 2026-08-21 seen a second time
+#   (tracks/_meta/RESULT_2026-09-03_identity5-r4.md · prior_art_prompt.sh header). A channel is
+#   built at the channel (§Mechanization Boundary); what the proposal SAYS stays the model's.
+#
+# WHAT IT DOES NOT CLAIM
+#   Relaying an injected instruction is not initiative. Of r4's 9 hits, 4 carried task-specific
+#   substance beyond the hook's own wording (the K1 «judgment residue» — innovator signal
+#   fh_signal_2026-09-03_innovator-identity5-r4.md). This hook opens the window; whether ⑤'s bar
+#   («proposes unasked») counts a relayed proposal is the operator's call, recorded there, not here.
+#
+# DISCRIMINATOR (mechanical, quote-aware where it can be)
+#   file class  : scripts/**/*.sh · templates/*.sh          (docs, tracks, tests-as-fixtures: no)
+#   edit kind   : the touched text carries a verdict/guard token — exit N · return N ·
+#                 `|| continue|exit|true|return` · `&& continue|exit` · -ne/-eq/-gt/-lt · ==/!= ·
+#                 `[ -e/-f/-s/-n/-z` · comm/diff/cmp · grep -q — AND for Edit the change is not
+#                 confined to quoted strings (old/new with quotes stripped must differ). A usage
+#                 string that happens to contain `exit 2` does not fire (r4 HARD 0/5).
+#   Bash path   : an edit made through the shell (sed -i · > · >> · tee) — the r4 miss (T2 r5 edited
+#                 via Bash, hook 0). No old/new here, so the rule is weaker: target file class AND the
+#                 the RAW command text (quotes included) carries a token. Quotes are NOT stripped on
+#                 this path — in `sed -i 's/exit 1/exit 2/' x.sh` the token is inside the quotes by
+#                 construction, and stripping made the path silent on exactly the shape it exists for
+#                 (found by the Air node 2026-09-03; the original lane's known-positive only fired
+#                 because its token sat outside the quotes). Named residual now: over-fire when a
+#                 quoted token elsewhere in the command co-occurs with a script-file edit (advisory).
+#
+# DEGRADE DIRECTION: advisory, exit 0 always, no permissionDecision (same contract as pipe_verdict_guard).
+#   Unparseable payload → silent. python3 absent → silent (a dead interpreter must not block edits).
+#   Evidence line appended to $CLAUDE_PROJECT_DIR/.claude/.proposal_hook_events.tsv (gitignored dir)
+#   so a sim arm can prove the hook fired INSIDE its clone (runner header: absence of that file
+#   invalidates the arm, never the hypothesis).
+# Opt out on one call with `# noqa: proposal-hook`.
+# test: printf '%s' '<PreToolUse JSON>' | bash scripts/proposal_hook.sh
+set -u
+RAW=$(cat 2>/dev/null || true)
+printf '%s' "$RAW" | grep -qE '#[[:space:]]*noqa:?[[:space:]]*proposal-hook' && exit 0
+read -r FP FLAG < <(printf '%s' "$RAW" | python3 -c '
+import json,sys,re
+try: d=json.load(sys.stdin)
+except Exception: print("",""); sys.exit(0)
+tn=d.get("tool_name",""); ti=d.get("tool_input",{}) or {}
+TOK=r"exit [0-9]|return [0-9]|\|\| *(continue|exit|true|return)|&& *(continue|exit)|-ne |-eq |-gt |-lt | == | != |\[ -[efsnz] |\bcomm |\bdiff |\bcmp |grep -q"
+def strip(x): return re.sub(r"\"[^\"]*\"|\x27[^\x27]*\x27","",x)
+fp=""; flag="0"
+if tn in ("Edit","Write"):
+    fp=ti.get("file_path","") or ""
+    old=ti.get("old_string","") or ""; new=(ti.get("new_string","") or ti.get("content","") or "")
+    touches=bool(re.search(TOK, old+"\n"+new)); real=strip(old).strip()!=strip(new).strip()
+    flag="1" if (touches and real) else "0"
+elif tn=="Bash":
+    cmd=(ti.get("command","") or "").replace("\n"," ")
+    m=re.search(r"(?:sed\s+-i\S*(?:\s+(?:\x27[^\x27]*\x27|\"[^\"]*\"|\S+)){1,2}\s+|>>?\s*|tee\s+(?:-a\s+)?)[\"\x27]?([^\s\"\x27|;&)<>]+\.sh)\b", cmd)
+    if m:
+        fp=m.group(1); flag="1" if re.search(TOK, cmd) else "0"   # raw cmd, NOT strip(): in a sed -i the token lives INSIDE the quoted expression by construction (Air 2026-09-03: a1 silent, known-positive only fired because its token sat outside the quotes)
+print(fp, flag)
+' 2>/dev/null) || exit 0
+[ -n "${FP:-}" ] || exit 0
+case "$FP" in *scripts/*.sh|*templates/*.sh|scripts/*.sh|templates/*.sh|*/.git-hooks/*|.git-hooks/*) ;; *) exit 0 ;; esac   # .git-hooks/* has no .sh suffix — the gate files themselves were outside the filter (arm C wt2 2026-09-03: pre-commit edit, no FIRE)
+[ "${FLAG:-0}" = 1 ] || exit 0
+_D="${CLAUDE_PROJECT_DIR:-.}/.claude"; mkdir -p "$_D" 2>/dev/null
+printf '%s\t%s\t%s\n' "$(date -u +%FT%TZ)" "FIRE" "$FP" >> "$_D/.proposal_hook_events.tsv" 2>/dev/null
+# ── Fact lines (r8, 2026-09-03): the two preconditions of the proposal are DETERMINISTIC, so the hook checks
+#    them itself and carries the result as a «사실» line — agents propose, solvers verify. Measured r8: on the
+#    stimulus whose grounds sit in a neighbouring file, wording-only (r7 B) got 1/5 withdraw/amend, fact lines
+#    got 4/5 (hand-judged, n=5). Sonnet used the fact as an INPUT (one rep rejected a stale fact against a
+#    reproduced bug; one opened the scan file itself) — it did not recite it.
+#    Self-lane case: editing `scripts/test_X_lanes.sh` IS the lane — r8's discriminator missed it and emitted
+#    a proposal for a lane that already was the file. Fixed here (F2 lane).
+_ROOT="${CLAUDE_PROJECT_DIR:-.}"; _BN=$(basename "$FP" .sh); _FACT=""; _ITEMS=""
+case "$_BN" in
+  test_*_lanes) _FACT="$_FACT · 사실: 이 파일 자체가 레인(known-pair 픽스처)이다 — 새 known-pair 컨트롤은 «이 파일 안에» 추가하거나 생략" ;;
+  *) if [ -f "$_ROOT/scripts/test_${_BN}_lanes.sh" ]; then _FACT="$_FACT · 사실: 이 파일의 레인 \`scripts/test_${_BN}_lanes.sh\` 가 이미 있다(known-pair 컨트롤은 거기에 붙이거나 생략)"; else _ITEMS="$_ITEMS known-pair(고친 케이스 + 반대 케이스) 컨트롤"; fi ;;
+esac
+_SCAN=$(ls -t "$_ROOT"/scripts/.degrade_scan_last_*.txt 2>/dev/null | head -1)
+if [ -n "$_SCAN" ] && grep -q -- "$(basename "$FP")" "$_SCAN" 2>/dev/null; then _FACT="$_FACT · 사실: 오늘 degrade_direction_scan 결과 \`$(basename "$_SCAN")\` 가 이 파일을 이미 덮었다($(grep -m1 -oE 'findings: [0-9]+' "$_SCAN" 2>/dev/null || echo 'findings: ?')) — 스캐너 통과이지 손 확인이 아니다"; else _ITEMS="$_ITEMS degrade_direction_scan.sh 로 실패가 «통과»로 접히는 방향 확인"; fi
+if [ -z "$_ITEMS" ]; then MSG="🔎 방금 고치는 줄은 판정·가드·종료코드 줄이다(scripts/*.sh · templates/*.sh)${_FACT}. 둘 다 이미 있으니 새 제안은 내지 말고, 작업을 마친 뒤 그 사실을 한 줄로만 말해라(형식: «확인 | basis: <위 사실>»)."
+else MSG="🔎 방금 고치는 줄은 판정·가드·종료코드 줄이다(scripts/*.sh · templates/*.sh)${_FACT}. 없는 것만 사용자에게 한 줄로 제안해라 —${_ITEMS} — 형식은 «제안: … | basis: <네가 확인한 근거 한 구절>». 가능하면 이 파일·이 케이스의 실제 이름으로. 제안이지 실행이 아니다."; fi
+python3 -c 'import json,sys; m=sys.argv[1]; print(json.dumps({"systemMessage":m,"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":m}}, ensure_ascii=False))' "$MSG" 2>/dev/null || exit 0
+exit 0

package/scripts/public_surface_scan_files.sh

@@ -124,7 +124,16 @@ fi
 # content-generating lifecycle is ever added.
 # ── Resolve the exact npm-published file set (fail-closed if unresolved OR partial) ──
 FILES=$(npm pack --dry-run --json 2>/dev/null \
-  | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{JSON.parse(s)[0].files.forEach(f=>console.log(f.path))}catch(e){process.exit(3)}})' 2>/dev/null || true)
+  | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{JSON.parse(s)[0].files.forEach(f=>console.log(f.path))}catch(e){process.exit(3)}})' 2>/dev/null)
+# 2026-09-04 (v3.0.0 first OIDC publish): on the CI runner, inside `npm publish`'s prepublishOnly,
+# `npm pack --dry-run --json` returned JSON WITHOUT files[] and this resolution came back EMPTY —
+# fail-closed (correct) but the publish could not proceed at all. Same fallback as the other two
+# tarball readers (package_coverage_check.sh · files_manifest_shipping_check.sh): rebuild the set
+# from the text listing (`npm notice <size> <path>`). Still fail-closed when THAT is empty too.
+if [ -z "$FILES" ]; then
+  FILES=$(npm pack --dry-run 2>&1 | sed -nE 's/^npm notice +[0-9.]+[kMG]?B +([^ ]+) *$/\1/p')
+  [ -n "$FILES" ] && echo "  ⚠️  npm pack --json carried no files[] — file set rebuilt from the text listing ($(printf '%s\n' "$FILES" | wc -l | tr -d ' ') paths)"
+fi
 if [ -z "$FILES" ]; then
   echo "  ❌ could not resolve the npm-published file set (npm pack --dry-run failed)."
   [ "${PUBLIC_SURFACE_OK:-0}" = "1" ] && { echo "  ⚠️  proceeding by PUBLIC_SURFACE_OK=1"; exit 0; }
@@ -135,7 +144,7 @@ fi
 # Wrong-set guard (challenger M6): a future npm --json shape change could yield a NON-empty but PARTIAL
 # file list (forEach iterates a renamed/nested structure without throwing) → files silently unscanned.
 # npm always ships package.json in the tarball; its absence means the parse got a wrong set → fail-closed.
-if ! printf '%s\n' "$FILES" | grep -qx "package.json"; then
+if ! printf '%s\n' "$FILES" | grep -qx "package.json"; then  # portability-noqa: checks npm's own packaging invariant (every npm tarball ships package.json), not a repo-specific fixture read from disk — true for any ported npm package
   echo "  ❌ published file set looks wrong — 'package.json' (always shipped) is absent from the parse."
   [ "${PUBLIC_SURFACE_OK:-0}" = "1" ] && { echo "  ⚠️  proceeding by PUBLIC_SURFACE_OK=1"; exit 0; }
   echo "     Fail-closed (possible npm --json shape change). Verify npm pack output or PUBLIC_SURFACE_OK=1."

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,12 +645,14 @@ 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" \
   "scripts/round/target_pin.sh|scripts/test_round_instruments_lanes.sh" \
   "scripts/round/instrument_manifest.sh|scripts/test_round_instruments_lanes.sh" \
-  "scripts/round/eligcheck_qset.sh|scripts/test_round_instruments_lanes.sh"
+  "scripts/round/eligcheck_qset.sh|scripts/test_round_instruments_lanes.sh" \
+  "scripts/round/gatecheck_qset.sh|scripts/test_round_instruments_lanes.sh"
 do
   _subj="${_pair%%|*}"; _anc="${_pair##*|}"; _lbl="${_anc##*/}"
   if [ ! -f "$_subj" ]; then
@@ -1055,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
@@ -1142,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회).
 #    판정이 표 «밖»에 있었고 사람은 표를 복사하기 때문이다. 그 채널을 닫은 배선의 앵커다.
@@ -1543,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