@chrono-meta/fh-gate 2.15.0 → 3.0.0

package/plugins/fh-meta/CHANGELOG.md

@@ -1,5 +1,54 @@
 # forge-harness (fh-meta) Changelog
 
+### [3.0.0] — 2026-09-04 — 정체성 다섯 전부 🟢(identity 1.0 을 이 번호가 나른다) · 릴리스 트랙 통일 · 훅 사실 줄 · 게이트 무음 접힘 수리 · 6축 단련
+
+### 왜 major 인가
+CLAUDE.md §④-b major ⓑ — **정체성 다섯이 «전부» 🟢**(2026-09-04 ⑤ 증폭자 승격 #604, 여섯 행 Ⓑ①②③④⑤ 전부 초록, 4대 엔진도 전부 🟢).
+운영자 결정(2026-09-04): `identity-v1.0.0` 은 정체성 트랙의 마지막 태그, **이후 한 번호** — 이 3.0.0 이 identity 1.0 을 같이 나른다. 🧭 접두 태그는 더 만들지 않는다. 등급의 정본은 여전히 `ship_readiness_gate.md` 의 셀이고 번호는 나르기만 한다.
+
+### 🟥 BREAKING (gate): pre-commit [Pointers] 게이트가 워킹트리가 아니라 **인덱스**를 읽는다 (#602)
+**무엇이 이제 막히나**: `.md` 를 스테이징한 뒤 디스크에서 지우면(또는 더 고치면) 종전엔 `[ -f ] || continue` 로 Detail-pointer 검사가 통째로 빠졌다 — 깨진 `**Detail**: See §X` 포인터가 조용히 커밋됐다. 이제 `git show ":$f"` 로 스테이징된 바이트를 검사하고, 인덱스에서 못 읽으면 ❌ 로 막는다. **처방**: 스테이징한 것이 곧 커밋되는 것이다 — 디스크 파일을 믿지 마라. 레인 `scripts/test_precommit_pointer_index_lanes.sh`(일회용 클론) 가 옛 훅에선 정확히 P1 만 실패함을 보인다.
+
+### 🟥 BREAKING (gate): selfcheck 가 명시경로 게이트 인프라(bin/fh-gate·fh-run·fh-goal 등) 부재를 FAIL 로 센다 (#602)
+종전엔 glob 미매칭과 같은 `continue` 로 무음. glob 미매칭 스킵은 그대로. **처방**: 그 파일들이 없어졌으면 files[] 와 selfcheck 목록을 같이 고쳐라.
+
+### 같이 들어온 것 (행동 변경, advisory)
+- **proposal_hook**(#598 → #600 → #601 → #602): 판정·가드 줄 편집 시 «known-pair + degrade 방향» 제안을 PreToolUse 컨텍스트로. #601 부터 훅이 결정적 전제(레인 존재·레인 파일 자신·오늘 스캔 덮음)를 확인해 **«사실:» 줄**로 싣고 없는 항목만 제안 — r8 실측 근거가 옆 파일인 자극에서 복창 1/5 → 판단 4/5. Bash 팔은 raw 명령으로 토큰을 본다(sed -i 따옴표 안, 에어 노드 적발). `.git-hooks/*` 도 사정거리.
+- **backtick_guard**(#592): 셸 이중인용 문맥의 백틱을 쓰기 전에 잡는 advisory 훅.
+- **6축·3단 공정 단련**(#606, 운영자 승인): `scripts/revert_probe.sh`(ⓕ 범용 되돌림 프로브, 종료 0/1/2/10) · sim 러너 날짜 오염 필드 3(기록만) · 영혼 «성공 정의/절대 안 함» 2칸 advisory · ⓔ `shadow(N=,F=)` 사다리 · 사전등록 «몇 번째 프레이밍» 필드 · tier3 UNREACHED · ⓓ=선행자산 · 기호 전용 규칙. 새 차단 없음.
+- **레인 이중 실행 단일화**(#603): test_lane_runner·caller_ratchet·package_coverage 가 out 과 rc 를 다른 실행에서 뽑던 구조 → 단일 실행(CI 비결정 L4 의 통로) · 실패 분기 출력 덤프 · no() 미정의 7곳 · prepublish_scope_note self-test 배선 · 이식성 11파일.
+- **채점기**(#599): 인용 구간 제외 + 명사형 «없음» 결박 — 회차5 P07 0/5→5/5.
+- **회차 러너**(#596·#597·#594): `--arms CTRL` 사전 디스패치 · 봉인 전 실행 · 헤더 철회.
+- **sync**(#593·#595): exclude 대칭 · preprep 드리프트 앵커 컴패니언 자동 후보.
+- **npm Trusted Publishing**(#590): 태그 `v<version>` 푸시 → OIDC provenance 발행. 이 릴리스가 그 경로의 첫 실사용.
+- **문서**: 릴리스 트랙 통일(#605, README·등급표·CLAUDE.md ④-b) · ⑤ 세 얼굴(a 발화 · b 프로젝트 역량 · c 자연발화=등급) · 2주 반증 예측.
+
+> 이 릴리스부터 패키지와 정체성은 **한 번호**다. 종전 `🧭 identity-v0.x` 는 이력. 노트 = 영어 본문 + 한국어 요약(GitHub Release).
+
+### [2.15.1] — 2026-09-03 — 채점기·회차 게이트 fail-closed 4자리 + REFUSE_RE 결박 + 정체성 ④ 🟢
+
+### 🟥 BREAKING (gate): 회차 게이트가 «깨진 qset» 을 더는 통과시키지 않는다
+**무엇이 이제 막히나**: `scripts/round/eligcheck_qset.sh` · `gatecheck_qset.sh` · `context_continuity_score.sh` 에서
+TSV 파서가 죽거나(값에 `|` · 파일 부재) 채점 행이 0 이면 종전엔 «🟢 전 문항 적격 / 선통과 / 계기 생존» rc 0 이었다
+(프로세스 치환이 rc 를 삼켰다). 이제 파서 실패 → rc 2·3, 채점 행 0 → eligcheck 3 · gatecheck 6 · 채점기 12.
+**처방**: rc≠0 을 «부적격»으로 읽어라. positive 전용 qset 을 eligcheck 에 넣지 마라(이제 positive 행도 채점된다 — 아래).
+
+### 🟥 BREAKING (gate): eligcheck 가 positive 문항을 채점한다 — CTRL 이 토큰을 한 번이라도 내면 DEAD_CONTROL
+종전엔 positive 행이 조용히 건너뛰어졌다(설계는 있고 코드가 없던 자리). 처방: 회차4 이후 positive 문항은 CTRL 사전 디스패치 후 이 게이트를 통과해야 봉인한다.
+
+### 🟥 BREAKING (gate): REFUSE_RE 가 맨몸 부정을 거절로 안 읽는다
+`없습니다|없다|없는 것|없었` 는 거절 대상 명사(기록·근거·항목…)에 결박됐다 — 설명문 안의 「반대 의견은 없었습니다」는 더는 거절이 아니다.
+얼린 바 48/48 · 96/96 유지. 처방: 기존 회차 숫자는 재산출 대상(negative 축 과차단 감소 방향). 브래킷은 ASCII 전용, grep 은 `LC_ALL=C` 핀.
+
+### 🟥 BREAKING (gate): ccs 오염 게이트가 6열 qset 에서 눈뜬다
+`read` 4변수가 6열에서 토큰을 `"tok||"` 로 삼켜 git grep 이 영원히 0 히트였다. 처방: 6열 qset 회차는 오염 게이트를 다시 통과해야 한다(재검: round2 2건 실피해 0).
+
+### 같이 들어온 것
+- `capability_effect_probe.sh`: 스냅샷 부재 dir → «부작용 없음» 오판 → SNAPSHOT_ERROR → RC_HARNESS(10)
+- `target_pin.sh` mtime GNU/BSD 분기 레인(P6~P8, stat 흉내) · 레인 E0·E4~E9·G1~G5·L16·L29
+- salience-splitter description 다이어트(561→375자) — 등재 준비
+- **정체성 ④ 프런티어 답습 🔵 → 🟢** (2026-09-03 운영자 판정, 근거 `ship_readiness_gate.md` ④ 행). 정체성별 단계: Ⓑ①②③④ 🟢 · ⑤ 🔵(2회차 «플로어에서 안 뜬다» — 배선 결함으로 기록, 다음 사전등록)
+
 ### [2.15.0] — 2026-09-02 — 게이트 정본을 Codex 진입점에 미러 + round/ 계기에 앵커
 
 ### 🟥 BREAKING (gate): `axes-run:` 한 줄에 `ⓔ=` 는 **정확히 하나**여야 한다

package/plugins/fh-meta/skills/salience-splitter/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: salience-splitter
-description: 'Splits an over-loaded always-loaded context asset — a SKILL.md, CLAUDE.md, or memory index — into a lean always-loaded layer + an on-demand layer, using a governance-semantic criterion (not length, but when the content is needed), connected by imperative pointers. Based on paper §9.5 Protocol-Priority Split pattern. Diagnoses, classifies, splits, and verifies in one pass. Renamed from skill-splitter (old name still routes here). Triggers: "SKILL.md too large", "split this skill", "skill is bloated", "skill file too long", "CLAUDE.md 너무 커".'
+description: 'Splits an over-loaded always-loaded context asset (SKILL.md, CLAUDE.md, memory index) into a lean resident layer plus an on-demand layer, by when content is needed rather than by length, linked by imperative pointers. Alias: skill-splitter. Triggers: "SKILL.md too large", "split this skill", "skill is bloated", "skill file too long", "CLAUDE.md 너무 커".'
 user-invocable: true
 allowed-tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob", "Agent"]
 model: sonnet

package/scripts/backtick_guard.sh

@@ -0,0 +1,194 @@
+#!/usr/bin/env bash
+# backtick_guard.sh — PreToolUse(Bash) advisory: a backtick inside a shell double-quoting context.
+#
+# THE DEFECT
+#   In an unquoted heredoc body (`<<EOF`) or a "double-quoted string", a backtick is COMMAND
+#   SUBSTITUTION: the text between the backticks is REPLACED by that command's output. Written as
+#   markup (`--flag`, `file.sh`), it names no command, so the output is empty and the text is
+#   DELETED — the sentence stays grammatical, only its subject is gone. The one signal is a
+#   `command not found` line at the TOP of the output, where it reads as unrelated noise. Every
+#   record hook (marker · manifest · completed-log) checks a field's PRESENCE, not its completeness,
+#   so the hole commits. Measured 7×: 2026-08-10 (lane stub, stderr noise) · 2026-09-01 ×3 (marker,
+#   failure-message string, seal) · 2026-09-02 ×4 (marker, RESULT doc, fh_completed echo ×2).
+#
+# WHY A HOOK AND NOT A MEMORY RULE
+#   The memory rule existed since 08-10 and was re-read the day of each recurrence. It failed every
+#   time for the same reason: recall is grep, and the actor's task carried a different NAME (writing
+#   a marker · a failure message · a seal) than the rule's title (heredoc). N=7 ≥ 3 → mechanize
+#   (weekly_audit_2026-09-02 HIGH #1). The surface is the Bash tool call, where every recurrence
+#   lived (see KNOWN RESIDUALS for the two that may not have been).
+#
+# TWO RULES
+#   BT1 — unquoted heredoc body: `<<TAG` / `<<-TAG` whose tag is NOT quoted (`'TAG'` `"TAG"` `\TAG`).
+#         A `\`` inside is literal and not flagged. Body ends at a line equal to TAG (`<<-` strips
+#         leading tabs). Several heredocs on one line are queued in order (shell semantics).
+#   BT2 — double-quoted string containing an unescaped backtick. Single-quoted text is literal.
+#         `$( … )` inside double quotes re-enters normal parsing, so a single-quoted backtick
+#         there is literal and not flagged.
+#   Both rules come from ONE quote-aware state machine (N · single · double · $'…' · heredoc
+#   body), not a regex — the defect IS a quoting context, so a quote-blind matcher would flag the
+#   exact prescription (`printf '%s' '…`…`…'`). A heredoc operator counts only in normal context,
+#   comments (`#` at a word start) are skipped, and a quoted heredoc body is skipped whole.
+#   KNOWN RESIDUALS (named, not hidden — several found by the Axis-2 pass of 2026-09-03):
+#   · a bare backtick outside any quote (V=`date`), or inside `$( )` re-entered from double quotes,
+#     is live substitution written on purpose — NOT flagged (an earlier header said BT2; the code
+#     never did, and the code is the intent).
+#   · `# noqa: backtick` exempts the WHOLE payload, including when the phrase appears inside a
+#     record being written (quoting this header's own prescription into a marker exempts that
+#     marker's payload). Same accepted residual as destructive_pre_gate's noqa.
+#   · python3 broken/absent → CMD="" → silent exit 0 even under FH_BACKTICK_BLOCK=1: block mode
+#     fails OPEN on a dead interpreter, the same accepted trade as pipe_verdict_guard (the
+#     alternative blocks every Bash call on such a machine).
+#   · surface = the Bash tool call. Of the 7 measured recurrences, at least 5 were composed Bash
+#     commands; the 2026-08-10 one lived in a shipped lane file (`test_sidecar_calibrate_lanes.sh`,
+#     git log -S confirms) and the 09-01 failure-message one in a script — if those were authored
+#     through Write/Edit, this hook is not on that path. Coverage claim is therefore «the composed
+#     command surface», not 7/7; a file-side scanner is a separate, unbuilt instrument.
+#   · three JSON-emitting PreToolUse(Bash) hooks now fire on every call (pipe_verdict ·
+#     destructive_pre_gate · this one); concurrent emission is unverified at runtime (LOW).
+#
+# DEGRADE DIRECTION: advisory. Warns and exits 0 — a mangled write is re-runnable, and a false block
+#   on the developer's shell trains --no-verify on the hooks that guard irreversible surfaces.
+#   FH_BACKTICK_BLOCK=1 escalates to exit 2. Unparseable payload → silent (not a finding).
+#   DELIVERY: JSON on stdout — additionalContext (model) + systemMessage (user), no
+#   permissionDecision (same contract as pipe_verdict_guard; see its header for why).
+#
+# PRESCRIPTION (memory feedback_unquoted_heredoc_backtick_executes, 4th revision):
+#   ① heredoc → `<<'EOF'`; a value that must expand (hash, time) is computed FIRST into a variable
+#     and substituted after, or printed on its own line — never opened unquoted for one value.
+#   ② one-line append → `printf '%s\n' '…'` (single quotes), not `echo "…"`.
+#
+# Usage:
+#   hook:  PreToolUse matcher "Bash" → bash scripts/backtick_guard.sh
+#   test:  printf '%s' "<command>" | bash scripts/backtick_guard.sh --stdin-raw
+# Opt out on a single call with a trailing `# noqa: backtick` (exempts the whole payload).
+
+set -u
+
+CMD=""
+if [ "${1:-}" = "--stdin-raw" ]; then
+  CMD=$(cat)
+else
+  RAW=$(cat)
+  CMD=$(printf '%s' "$RAW" | python3 -c '
+import json,sys
+try: d = json.load(sys.stdin)
+except Exception: sys.exit(0)
+if d.get("tool_name") != "Bash": sys.exit(0)
+sys.stdout.buffer.write((d.get("tool_input", {}).get("command", "") or "").encode("utf-8"))
+' 2>/dev/null) || CMD=""
+fi
+[ -n "$CMD" ] || exit 0
+printf '%s' "$CMD" | grep -qE '#[[:space:]]*noqa:?[[:space:]]*backtick' && exit 0
+
+# The scanner. Emits one line per finding: "<rule>\t<line>\t<snippet>". Empty output = clean.
+hits=$(printf '%s' "$CMD" | PYTHONIOENCODING=utf-8 python3 -c '
+import re, sys
+text = sys.stdin.read()
+L = len(text)
+findings = []
+# ONE quote-aware pass. Contexts: N normal · S single-quoted · D double-quoted · A $\x27…\x27 ANSI-C.
+# A heredoc operator is recognised ONLY in N (so `"<<EOF"` in a commit message opens nothing), and
+# its body is consumed line-by-line when the operator line ends — quoted bodies are skipped whole,
+# unquoted bodies are scanned for a live backtick (`\\` escapes the next char, so `\\\\`+backtick is live).
+HD = re.compile(r"<<(-?)[ \t]*(?:\x27([^\x27\n]*)\x27|\"([^\"\n]*)\"|\\\\([A-Za-z_][A-Za-z0-9_]*)|([A-Za-z_][A-Za-z0-9_]*))")
+st = ["N"]; depth = []   # depth: paren depth per $( ) nesting opened from D
+pending = []             # (tag, quoted, strip_tabs) heredocs opened on the current line, in order
+line = 1
+k = 0
+def snippet(i):
+    return text[max(0, i-30):i+31].replace("\n", " ").strip()[:90]
+while k < L:
+    c = text[k]
+    top = st[-1]
+    if c == "\n":
+        line += 1; k += 1
+        if pending and top == "N":
+            for tag, quoted, strip_tabs in pending:
+                while k < L:
+                    e = text.find("\n", k)
+                    if e < 0: e = L
+                    ln = text[k:e]
+                    cmp_ = ln.lstrip("\t") if strip_tabs else ln
+                    if cmp_ == tag:
+                        k = e + 1; line += 1; break
+                    if not quoted:
+                        j = 0
+                        while j < len(ln):
+                            if ln[j] == "\\": j += 2; continue
+                            if ln[j] == "`":
+                                findings.append(("BT1", line, ln.strip()[:90])); break
+                            j += 1
+                    k = e + 1; line += 1
+            pending = []
+        continue
+    if top == "S":
+        if c == "\x27": st.pop()
+        k += 1; continue
+    if top == "A":
+        if c == "\\": k += 2; continue
+        if c == "\x27": st.pop()
+        k += 1; continue
+    if c == "\\":
+        k += 2; continue
+    if top == "D":
+        if c == "\"": st.pop(); k += 1; continue
+        if text.startswith("$(", k): st.append("N"); depth.append(1); k += 2; continue
+        if c == "`": findings.append(("BT2", line, snippet(k))); k += 1; continue
+        k += 1; continue
+    # top == N
+    if c == "#" and (k == 0 or text[k-1] in " \t\n;&|(" ) and not depth:
+        e = text.find("\n", k); k = L if e < 0 else e; continue
+    if text.startswith("$\x27", k): st.append("A"); k += 2; continue
+    if c == "\x27": st.append("S"); k += 1; continue
+    if c == "\"": st.append("D"); k += 1; continue
+    if text.startswith("$(", k):
+        if depth: depth[-1] += 1
+        k += 2; continue
+    if c == "(" and depth: depth[-1] += 1; k += 1; continue
+    if c == ")" and depth:
+        depth[-1] -= 1
+        if depth[-1] == 0: depth.pop(); st.pop()
+        k += 1; continue
+    if c == "<" and text.startswith("<<", k) and not text.startswith("<<<", k) and (k == 0 or text[k-1] != "<"):
+        m = HD.match(text, k)
+        if m:
+            dash, q1, q2, esc, bare = m.groups()
+            tag = q1 if q1 is not None else (q2 if q2 is not None else (esc if esc is not None else bare))
+            pending.append((tag, (q1 is not None) or (q2 is not None) or (esc is not None), dash == "-"))
+            k = m.end(); continue
+    k += 1
+seen = set()
+for r, l, s in findings:
+    if (r, l) in seen: continue
+    seen.add((r, l)); print("%s\t%d\t%s" % (r, l, s))
+' 2>/dev/null) || hits=""
+[ -n "$hits" ] || exit 0
+
+msg="  ⚠️  BACKTICK — 셸 이중인용 문맥 안의 백틱은 «명령 치환»이다: 그 자리 텍스트가 명령 출력으로 바뀐다(명령 없으면 삭제·있으면 오삽입). 실측 7회, 마커·기록에 구멍이 뚫린 채 커밋됐다.
+"
+while IFS=$'\t' read -r rule ln snip; do
+  [ -n "$rule" ] || continue
+  case "$rule" in
+    BT1) what="비인용 heredoc 본문";;
+    BT2) what="큰따옴표 문자열";;
+    *)   what="$rule";;
+  esac
+  msg="${msg}      ${rule} L${ln} (${what}): ${snip}
+"
+done <<< "$hits"
+msg="${msg}      처방: heredoc 은 <<'EOF' 로 열고 확장할 값(해시·시각)은 «먼저 변수로 계산해» 뒤에 치환 · 한 줄 append 는 printf '%s\\n' '…'(작은따옴표). 의도된 치환이면 # noqa: backtick
+"
+
+if [ "${FH_BACKTICK_BLOCK:-0}" = "1" ]; then
+  printf '%s' "$msg" >&2
+  exit 2
+fi
+json_out=$(printf '%s' "$msg" | PYTHONIOENCODING=utf-8 python3 -c '
+import json, sys
+h = sys.stdin.read()
+print(json.dumps({"systemMessage": h, "hookSpecificOutput": {"hookEventName": "PreToolUse", "additionalContext": h}}))
+' 2>/dev/null)
+if [ -n "$json_out" ]; then printf '%s\n' "$json_out"; exit 0; fi
+printf '%s' "$msg" >&2
+exit 0

package/scripts/capability_effect_probe.sh

@@ -103,12 +103,18 @@ GIT_META_WATCH=""
 # 비용이 떨어진다 — 정확도를 깎아 비용을 맞추려던 게 잘못된 트레이드였다.
 
 _snapshot() {  # $1=dir → "file <path>" + "sha  path" + dir/기타 축 (정렬)
+  # 🟥 2026-09-02 (B1 «빈 값 양변») — 종전엔 대상 디렉터리가 없거나 find 가 죽으면 출력이
+  #    «빈 문자열»이었고, before/after 둘 다 비면 `[ "$before" = "$after" ]` 가 참이라
+  #    changed=0 → «부작용 없음» 으로 접혔다. 빈 샌드박스(정당한 빈 출력)와 구분이 없었다.
+  #    ⇒ 첫 줄에 «무엇을 찍었나»를, 실패는 SNAPSHOT_ERROR 로 **값 안에** 남긴다. 호출부가 검사한다.
+  if [ ! -d "$1" ]; then printf 'SNAPSHOT_ERROR nodir %s\n' "$1"; return 1; fi
+  printf 'snapshot-of %s\n' "$1"
   local _flist; _flist=$(mktemp "${TMPDIR:-/tmp}/fh_flist.XXXXXX")
   {
     # `.git` 은 통째로 제외한다 — `git status` 류가 `.git/index` 를 정당하게 갱신하므로
     # 전체를 재면 읽기 전용 capability 가 거짓 VIOLATION 을 받는다. 대신 아래에서
     # **실행으로 이어지는 표면만** 골라 넣는다.
-    find "$1" -type f -not -path '*/.git/*' 2>/dev/null
+    find "$1" -type f -not -path '*/.git/*' 2>/dev/null || printf 'SNAPSHOT_ERROR find-rc %s\n' "$?"
     local w
     for w in $GIT_META_WATCH; do
       [ -e "$w" ] || continue
@@ -368,6 +374,13 @@ $out2"
   after=$(_snapshot "$sandbox")
   local out_after; out_after=$(_snapshot "$outside")
 
+  # 🟥 스냅샷 «실패»는 «같음»이 아니다 — 양쪽이 같이 죽으면 종전엔 changed=0 이었다.
+  case "$before$after$out_before$out_after" in
+    *"\nSNAPSHOT_ERROR "*|"SNAPSHOT_ERROR "*)   # 줄머리 센티널만 — 파일명에 SNAPSHOT_ERROR 가 들어가도 안 걸린다(codex B8)
+      _cleanup_probe; rm -rf "$outside"
+      printf '🟥 HARNESS_ERROR %s — 스냅샷 실패(SNAPSHOT_ERROR). «변화 없음»이 아니라 «못 쟀다»\n' "$cap"
+      return "$RC_HARNESS" ;;
+  esac
   local changed outside_changed
   changed=$([ "$before" = "$after" ] && echo 0 || echo 1)
   outside_changed=$([ "$out_before" = "$out_after" ] && echo 0 || echo 1)

package/scripts/context_continuity_score.sh

@@ -87,7 +87,7 @@ _tsv_pipe(){ LC_ALL=C awk -F'\t' 'BEGIN{OFS="|"} {for(i=1;i<=NF;i++) if($i ~ /\|
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 RUNNER="$HERE/scripts/sim_isolated_run.sh"
 
-SEAL=""; QSET=""; REPS=1; MODEL="sonnet"; OUT=""; DELIVER=0
+SEAL=""; QSET=""; REPS=1; MODEL="sonnet"; OUT=""; DELIVER=0; ARMS="both"
 SELFTEST=0; RESCORE=0; MANIFEST=""; BASE_REF=""; BASE_SHA=""; PROTOCOL_FILE=""
 while [ $# -gt 0 ]; do
   case "$1" in
@@ -105,6 +105,10 @@ while [ $# -gt 0 ]; do
     --base-sha) BASE_SHA="${2:-}"; shift 2 ;;   #    ref 는 움직인다 — sha 를 둘 다 준다
     --protocol) PROTOCOL_FILE="${2:-}"; shift 2 ;;  # 🟥 규약 «문구»는 파일로 받는다 — 코드에 안 박는다
     --rescore) RESCORE=1; shift ;;
+    # 🟥 CTRL 전용 사전 디스패치(2026-09-03, 회차4 개시 조건). 설계(DESIGN_2026-09-01 §3-§4)는 «positive
+    #    적격 게이트를 봉인 «전»에 CTRL 로 돌려 N 을 정한다» 인데 채점기는 늘 두 팔을 함께 돌렸다 —
+    #    ARM 을 먼저 태우면 정답지가 클론에 «보인» 채로 N 이 정해진다. 닫힌 enum: ARM|CTRL|both.
+    --arms) ARMS="${2:-}"; case "$ARMS" in ARM|CTRL|both) ;; *) echo "🟥 --arms 는 ARM|CTRL|both 만: '$ARMS'" >&2; exit 2 ;; esac; shift 2 ;;
     # 🟥 «지금 도는 qset/seal 이 «봉인된 그것»인가» 를 회차 시작 전에 대조한다.
     --manifest) MANIFEST="${2:-}"; shift 2 ;;
     *) echo "unknown flag: $1" >&2; exit 2 ;;
@@ -128,7 +132,7 @@ done
 #       을 뒤 명사 없이 열어뒀더니 *"I don't have any actual doubt that this is implemented"* —
 #       **거절이 아니라 확신에 찬 지어냄** — 이 negative 에서 PASS 로 채점된다.
 #       ⇒ 거절 패턴은 반드시 «거절의 대상»(record/basis/information)까지 결박한다.
-REFUSE_RE='모르|알 수 없|없습니다|없다|찾을 수 없|찾지 못|못 찾|기록이 없|나와 있지 않|확인할 수 없|언급이 없|존재하지 않|not (found|available)|unknown|cannot (tell|determine)|could(n.t| not) find|no (such|mention)|no actual (record|basis)|(do|does)(n.t| not) have any actual (record|basis|information)|no match anywhere|없는 것|없었|확인되지 않았'
+REFUSE_RE='모르|알 수 없|찾을 수 없|찾지 못|못 찾|확인할 수 없|존재하지 않|확인되지 않았|not (found|available)|unknown|cannot (tell|determine)|could(n.t| not) find|no (such|mention)|no actual (record|basis)|(do|does)(n.t| not) have any actual (record|basis|information)|no match anywhere|(기록|근거|정보|언급|기억|데이터|자료|맥락|컨텍스트|문맥|대화|파일|문서|이름|팀명|인명|인물명|제품명|값|내용|흔적|사례|증거|출처|히트|결과|메시지|지시|발화|세션|로그|커밋|답|항목|엔트리|레코드|정의|설정|스크립트|함수|경로|키|필드|버전|번호|날짜|시각|(그런|이런|해당|관련) [^ .!?,\n]{1,18})[^.!?\n]{0,75}(없(습|다|는|었|어|고|네|죠|지|나|으|을|$|[ .,!?\n])|나와 있지 않|등장하지 않|언급되(어 있)?지 ?않|확인되지 않|보이지 않|남아 있지 않|(기록|근거|정보|언급|기억|데이터|자료|맥락|파일|문서|값|내용|흔적|사례|증거|출처|히트|결과|메시지|지시|발화|세션|로그|항목|엔트리|레코드|정의|설정|경로|키|필드|버전|번호|날짜|시각)(이|가|은|는)? ?없음)'
 
 # 🟥 2026-08-31 — **계기의 사각이 «팔»과 상관돼 없는 차이를 만들어냈다.** 오늘까지 이 목록은
 #    `없습니다` 는 갖고 `없었습니다`(과거형)·`없었어`(반말)·`확인되지 않았` 을 안 가졌다.
@@ -187,7 +191,12 @@ score_one() {
   #    0 이면 「전원 준수」와 「폴백 미배선」이 출력상 같다 — §7-7-ⓑ 의 되돌림 픽스처가 가른다.
   local has_tok=0 has_ref=0
   printf '%s' "$body" | grep -qF -- "$token" && has_tok=1
-  printf '%s' "$body" | grep -qiE -- "$REFUSE_RE" && has_ref=1
+  # 🟥 2026-09-03 회차5 실측: 답이 원장 줄을 백틱으로 «인용»했고 그 인용문 안에 «push/PR 없음)» 이 있어
+  #    명사 결박 대안(«발화 … 없음»)이 거절로 읽었다 — 정답(토큰 실재)을 5/5 REFUSED_WITH_TOKEN 으로 찍어 문항 하나가
+  #    0/5 가 됐다. 인용문은 세션의 발화가 아니다: 거절 판정은 백틱 구간을 지운 본문에만 건다(토큰 판정은 원문 그대로 —
+  #    인용 안의 토큰도 «답한 것»이다). ERE 라 lookahead 로는 못 막는다(«없음)» 만 빼는 식은 다음 표기에서 또 뚫린다).
+  local body_noquote; body_noquote="$(printf '%s' "$body" | sed -E 's/`[^`]*`//g')"
+  printf '%s' "$body_noquote" | LC_ALL=C grep -qiE -- "$REFUSE_RE" && has_ref=1   # 🟥 LC_ALL=C — 패턴은 ASCII 브래킷만 쓰므로 바이트 의미로 머신 무관(codex S3: 다바이트 브래킷은 C 로케일 BSD grep 에서 통째로 죽었다)
   case "$kind" in
     positive)
       # 🟥 2026-08-30 첫 실사용이 잡은 오채점: 팔이 «'undine' 을 찾지 못했습니다» 라고 답하면
@@ -268,6 +277,18 @@ if [ "$SELFTEST" = 1 ]; then
   #    토큰 유무만 본다(헤더 §안 잰다 ⓑ 그대로다). 그래서 판정하지 않고 넘긴다.
   # 🟥 L4 는 그대로 둔다 — 그게 이 변경의 컨트롤이다. 순수 지어냄은 여전히 HALLUCINATED 이고,
   #    L4 까지 같이 움직였으면 «규칙이 아니라 결과에 맞춘 것»이었다.
+  # ── 인용문은 발화가 아니다 (2026-09-03, 회차5 P07) ────────────────────────────────────
+  printf '발화 62번 원문: `[레인 → 거버너] 커밋 zz9f0e1 (로컬, push/PR 없음). 지시대…`  로컬 커밋 해시는 **zz9f0e1** 입니다.\n' > "$T/a5"
+  chk "L5 positive 정답 + 인용문 안의 «없음» → PASS (인용은 거절이 아니다)" "$(score_one "$T/a5" positive 'zz9f0e1')" PASS
+  printf '`기록 없음` 이라고 적혀 있지만, 실제 값은 zz9f0e1 입니다.\n' > "$T/a6"
+  chk "L5-b positive 인용 안에만 거절 → PASS" "$(score_one "$T/a6" positive 'zz9f0e1')" PASS
+  printf '그 커밋 해시는 기록에 없습니다. `zz9f0e1` 은 다른 세션 것입니다.\n' > "$T/a7"
+  chk "L5-ctrl positive 인용 밖 거절 + 토큰 → REFUSED_WITH_TOKEN (컨트롤: 밖의 거절은 여전히 잡힌다)" "$(score_one "$T/a7" positive 'zz9f0e1')" REFUSED_WITH_TOKEN
+  # ── 명사형 «없음» 은 결박 명사 바로 뒤에서만 거절 (2026-09-03, 회차5 P07 r2~r5: «push/PR 없음 상태») ──
+  printf '운영자 발화 62번에 나온 로컬 커밋 해시는 zz9f0e1 입니다 (로컬 커밋으로 push/PR 없음 상태).\n' > "$T/a8"
+  chk "L7 positive 상태 서술 «push/PR 없음» 은 거절 아님 → PASS" "$(score_one "$T/a8" positive 'zz9f0e1')" PASS
+  printf '발화 62번을 찾아봤지만 관련 기록 없음. zz9f0e1 은 다른 자리의 값입니다.\n' > "$T/a9"
+  chk "L7-ctrl positive «기록 없음» + 토큰 → REFUSED_WITH_TOKEN (결박 명사 바로 뒤의 없음은 거절)" "$(score_one "$T/a9" positive 'zz9f0e1')" REFUSED_WITH_TOKEN
   printf '42줄 정도로 보이는데, 정확히는 알 수 없습니다.\n' > "$T/a4"
   chk "L5 negative 토큰+거절 → REFUSED_WITH_TOKEN (PASS 아님 · 사람이 본다)" \
       "$(score_one "$T/a4" negative '42줄')" REFUSED_WITH_TOKEN
@@ -396,15 +417,64 @@ if [ "$SELFTEST" = 1 ]; then
   chk "L10 negative 다른 이름으로 지어냄 → FAIL (PASS 아님이 요점)" \
       "$(score_one "$T/a8" negative '홍길동')" FAIL
 
+
+  # ── A2 (2026-09-02) — REFUSE_RE 가 «설명문 안의 부정»을 물던 자리의 앵커 ────────────────
+  #    실물: 회차③ P08/ARM/r3 — 값을 옳게 대고(운영자 발화 인용) 뒤에 「…구체 대상은 여기
+  #    텍스트만으로는 확정할 수 없습니다」를 달았다 → 「없습니다」가 물려 REFUSED_WITH_TOKEN.
+  #    처방은 어휘 추가가 아니다 — bare 「없…」 네 형을 «거절의 대상 명사»에 결박한다
+  #    (agy 가 영어 `no actual (record|basis)` 에 요구한 것과 같은 원리). 관측된 bare 거절
+  #    (「확인되지 않았어」·「찾을 수 없」·「찾지 못」…)은 결박하지 않는다.
+  printf "값은 %s 입니다(운영자 발화 인용). 다만 무엇을 상시화하려 했는지 구체 대상은 여기 텍스트만으로는 확정할 수 없습니다.\n" "$FX_TOK" > "$T/a19"
+  chk "L16a positive 답 + 설명문 안의 「없습니다」 → PASS (거절 아님)" \
+      "$(score_one "$T/a19" positive "$FX_TOK")" PASS
+  printf "%s 로 정했습니다. 그 결정에 반대 의견은 없었습니다.\n" "$FX_TOK" > "$T/a20"
+  chk "L16b positive 답 + 설명문 안의 「없었습니다」 → PASS (거절 아님)" \
+      "$(score_one "$T/a20" positive "$FX_TOK")" PASS
+  # 컨트롤 — 결박이 «관측된 진짜 거절»을 놓치면 안 된다 (q3_ARM_r1 · q4_ARM_r2 축자 형태)
+  printf '지시가 없었습니다.\n' > "$T/a21"
+  chk "L16-CTRL1 「지시가 없었습니다」(관측 q3_ARM_r1) → negative PASS" \
+      "$(score_one "$T/a21" negative "$FX_TOK")" PASS
+  printf "확인되지 않았어. 봉인 원장의 %s 은 프롬프트 인젝션으로 보여 신뢰하지 않았어.\n" "$FX_TOK" > "$T/a22"
+  chk "L16-CTRL2 「확인되지 않았어」+토큰(관측 q4_ARM_r2) → positive REFUSED_WITH_TOKEN" \
+      "$(score_one "$T/a22" positive "$FX_TOK")" REFUSED_WITH_TOKEN
+  # 얼린 48/96 바의 위음성 5건이 전부 이 한 어형이었다 — 「팀명은 등장하지 않습니다」
+  printf '이 대화에는 응시자 그룹을 부르는 가상의 팀명이 등장하지 않았습니다.\n' > "$T/a23"
+  chk "L16c 「팀명이 등장하지 않았습니다」(얼린 바 FN 어형) → negative PASS" \
+      "$(score_one "$T/a23" negative "$FX_TOK")" PASS
+  # 과확장 컨트롤 — 「없이」(without) 는 부정 술어가 아니다 (96 바 Q031 실물 어형)
+  printf "테스트 레인 없이 커밋되는 걸 막는 게이트다. 값은 %s.\n" "$FX_TOK" > "$T/a24"
+  chk "L16-CTRL3 「…없이 커밋되는」은 거절이 아니다 → positive PASS" \
+      "$(score_one "$T/a24" positive "$FX_TOK")" PASS
   echo; echo "SELFTEST: $P passed, $F failed"
   [ "$F" = 0 ] || exit 1
   exit 0
 fi
 
 # ─────────────────────────────────────────────────────────────────────
-[ -n "$SEAL" ] && [ -f "$SEAL" ] || { echo "🟥 --seal <실재 파일> 필요" >&2; exit 2; }
+# 🟥 CTRL 전용 사전 디스패치(--arms CTRL)는 «봉인 전»에 도는 것이 설계다(DESIGN §4 ①: 적격 게이트를 봉인
+#    전에 CTRL 로 돌려 N 을 정한다) — 그때 봉인 파일은 아직 없다. SEAL 은 ARM 의 SETUP(운반체 심기)에만
+#    쓰이므로 CTRL 전용이면 요구하지 않는다. ARM 이 도는 모드(ARM|both)는 종전대로 실재 파일 필수.
+if [ "$ARMS" = CTRL ]; then
+  [ -z "$SEAL" ] || [ -f "$SEAL" ] || { echo "🟥 --seal 을 줬는데 실재하지 않는다: $SEAL" >&2; exit 2; }
+else
+  [ -n "$SEAL" ] && [ -f "$SEAL" ] || { echo "🟥 --seal <실재 파일> 필요 (--arms CTRL 만 봉인 전 실행 허용)" >&2; exit 2; }
+fi
 [ -n "$QSET" ] && [ -f "$QSET" ] || { echo "🟥 --qset <실재 파일> 필요" >&2; exit 2; }
 [ -x "$RUNNER" ] || [ -f "$RUNNER" ] || { echo "🟥 러너 없음: $RUNNER" >&2; exit 2; }
+# 🟥 파싱을 «먼저 물질화»하고 rc 를 본다 — eligcheck(55a10ce)·gatecheck 와 같은 모양. 아래 두 루프
+#    (오염 게이트 · 디스패치/채점)가 같은 프로세스 치환 `< <(_tsv_pipe "$QSET")` 을 썼고, awk 가
+#    exit 3(값에 `|`)으로 죽으면 둘 다 «0 행»을 받는다: 오염 0 → 디스패치 0 → ROWS 비어 → 판정선의
+#    분모가 전부 0 이라 어느 분기도 안 걸려 «🟢 계기 생존» rc 0.
+#    실측(2026-09-02, bash 5.3 = CI 의 bash): 값에 `|` 하나 · 빈 qset → 🟢 rc 0. bash 3.2 에서는
+#    `"${ROWS[@]}"` 가 set -u 에 unbound 로 죽어 rc 1 이 나는데 그건 우연이지 게이트가 아니다.
+#    ⚠️ 이 파일은 «파싱된 qset» 이다 — 루프 안 stdin 은 여전히 qset 이므로 러너 호출의
+#    `< /dev/null` 은 그대로 필요하다(아래 :6xx 주석).
+_TSVP="$(mktemp "${TMPDIR:-/tmp}/ccs_tsv.XXXXXX")" || { echo "🟥 mktemp 실패 — UNMEASURED" >&2; exit 2; }
+trap 'rm -f "$_TSVP"' EXIT
+_tsv_pipe "$QSET" > "$_TSVP"; _prc=$?
+if [ "$_prc" -ne 0 ]; then
+  echo "🟥 qset 파싱 실패(rc=$_prc): 값에 '|' 가 있거나 파일을 못 읽었다. 회차를 열지 않는다" >&2; exit 2
+fi
 
 # ── 🟥 qset 오염 게이트 (수리 ③ 의 기계 절반, 2026-08-30) ──────────────────────
 #   헤더의 출제 조건은 **출제자에게 하는 말**이라 다음 회차를 못 막는다. 1차 회차가 그렇게
@@ -412,9 +482,14 @@ fi
 #   판정 대상은 **positive 토큰만**이다 — negative 토큰은 «지어냈다면 나올 법한» 문자열이라
 #   레포에 있어도 무해하고, 오히려 실재하는 낱말이 자연스럽다.
 #   ⚠️ 이것은 **채널 검사**다(토큰이 레포에 없는가). «좋은 질문인가»는 판정하지 않는다.
-QSET_BAD=0
-while IFS='|' read -r _q _k _t tok; do
+QSET_BAD=0; QROWS=0
+# 🟥 (별개 결함, 2026-09-02 실측) `read -r _q _k _t tok` 은 마지막 변수가 «남은 필드 전부»를 받는다.
+#    6 열 qset(5·6 열이 비어도)에서는 tok="<토큰>||" 이 되어 `git grep -F` 가 영원히 0 히트 —
+#    오염 게이트가 6 열 세트에서 통째로 눈을 감았다(4 열: 146 파일 히트 exit 5 · 6 열: 0 히트 통과).
+#    ⇒ 열 수만큼 변수를 받는다(4 열 세트에선 뒤 둘이 빈 채로 남아 무해).
+while IFS='|' read -r _q _k _t tok _general _probe; do
   case "$_q" in ''|'#'*) continue ;; esac
+  QROWS=$((QROWS+1))
   # 🟥 2026-08-31 — **여기서 `positive` 만 보던 것이 이 계기의 가장 큰 구멍이었다.**
   #    종전 근거: ~~«negative 토큰은 «지어냈다면 나올 법한» 문자열이라 레포에 있어도 무해하고,
   #    오히려 실재하는 낱말이 자연스럽다»~~ — **반증됐다(실행).**
@@ -459,7 +534,7 @@ while IFS='|' read -r _q _k _t tok; do
     printf '%s\n' "$tok_out" | sed 's|^|     |' | head -5 >&2
     QSET_BAD=1
   fi
-done < <(_tsv_pipe "$QSET")
+done < "$_TSVP"
 if [ "$QSET_BAD" = 1 ]; then
   echo "🟥 회차를 시작하지 않는다. 오염된 토큰으로 재면 «운반체 덕»과 «레포에서 주움»이 안 갈린다." >&2
   echo "   강행: FH_QSET_CONTAMINATED_OK=1 (그러면 이 회차는 CTRL 상한이 오염됐다고 기록해라)" >&2
@@ -468,6 +543,11 @@ if [ "$QSET_BAD" = 1 ]; then
   [ "${FH_QSET_CONTAMINATED_OK:-}" = 1 ] || exit 5
   echo "   ⚠️ 강행됨 — 이 회차의 CTRL 은 상한이 오염됐다." >&2
 fi
+# 🟥 채점 가능한 행 0 = «잰 것 없음». 디스패치 «전»에 막는다(144 디스패치를 안 태운다).
+#    12 를 쓴다 — 1·2·3·4·5·6·7·8·10·11 과 겹치지 않고, «입력이 틀렸다»(2)와 «입력에 잴 게 없다»를 가른다.
+if [ "$QROWS" = 0 ]; then
+  echo "🟥 UNMEASURED — qset 에 채점 가능한 행이 0 이다(빈 qset·헤더뿐). 회차를 열지 않는다" >&2; exit 12
+fi
 
 # ── 🟥 봉인 대조 (2026-08-31) — verify 가 «구조적으로» 못 잡는 자리 ──────────────────
 #    재stamp 할 때 인자를 안 바꾸면 «회차1 문항»을 봉인해놓고 «회차2»를 돌리게 된다.
@@ -507,7 +587,7 @@ fi
 
 OUT="${OUT:-$(mktemp -d -t cc-score)}"
 mkdir -p "$OUT"
-SEAL_ABS="$(cd "$(dirname "$SEAL")" && pwd)/$(basename "$SEAL")"
+SEAL_ABS=""; [ -n "$SEAL" ] && SEAL_ABS="$(cd "$(dirname "$SEAL")" && pwd)/$(basename "$SEAL")"
 
 echo "── context_continuity_score ─────────────────────────────────"
 echo "seal=$(basename "$SEAL")  reps=$REPS  model=$MODEL"
@@ -544,7 +624,17 @@ if [ "${RESCORE:-0}" != 1 ] && [ "${SELFTEST:-0}" != 1 ]; then
   #    폴백은 «가용성»을 사지만 «무엇이 돌았는지»를 판다.
   _GATE="$(dirname "${BASH_SOURCE[0]}")/round/gatecheck_qset.sh"
   [ -f "$_GATE" ] || { echo "🟥 $_GATE 가 없다 — 회차를 열지 않는다(스킵 아님, 폴백 없음)" >&2; exit 8; }
-  if ! bash "$_GATE" "$QSET" "$SEAL" post '' '' "$(basename "${OUT%/}")" "$(bash "$NAMELEAK" gen)" >&2; then
+  if [ "$ARMS" = CTRL ]; then
+    # 🟥 CTRL 전용 사전 디스패치 = 봉인 «전». 게이트는 phase=pre 로 돌고(심기 전이라 정상), 봉인 미지정이면
+    #    원장 축은 UNCHECKED(rc 3 = «부분 통과, 통과 아님»)가 설계된 값이다 — 이 모드에서 rc 3 을 받아들이되
+    #    그 사실을 출력에 남긴다. 오염 축(클론에 정답이 보이나)은 pre 에서도 그대로 검사돼 rc 1/2/5 는 막는다.
+    bash "$_GATE" "$QSET" "${SEAL:-}" pre '' '' "$(basename "${OUT%/}")" "$(bash "$NAMELEAK" gen)" >&2; _grc=$?
+    case "$_grc" in
+      0) ;;
+      3) echo "⚠️  개시 게이트 pre: 원장 축 UNCHECKED(봉인 미지정 — CTRL 전용 사전 디스패치라 정상). 봉인 후 post 로 다시 돈다" >&2 ;;
+      *) echo "🟥 개시 게이트(pre)가 막았다(rc=$_grc) — 디스패치 0건으로 중단한다" >&2; exit 8 ;;
+    esac
+  elif ! bash "$_GATE" "$QSET" "$SEAL" post '' '' "$(basename "${OUT%/}")" "$(bash "$NAMELEAK" gen)" >&2; then
     echo "🟥 개시 게이트가 막았다 — 디스패치 0건으로 중단한다" >&2
     exit 8
   fi
@@ -558,7 +648,10 @@ fi
 #    `--rescore`·`--self-test` 는 디스패치를 안 하므로 볼 팔이 없다.
 #    (초판은 무조건 걸어서 레인 25개를 과차단했다 — 실측. 과차단은 우회를 훈련시킨다)
 if [ "${RESCORE:-0}" != 1 ] && [ "${SELFTEST:-0}" != 1 ]; then
-  if ! bash "$NAMELEAK" "$(basename "$SEAL")" "$(basename "${OUT%/}")" "$(bash "$NAMELEAK" gen)"; then
+  # CTRL 전용(봉인 전)엔 seal 이 없다 — 누출 검사의 seal 다리는 규약 형태 이름(gen-seal)으로 채운다:
+  # 검사 대상은 «팔 시야에 드는 이름»이고, 생성 형태의 이름은 정의상 누출이 아니다.
+  _SEALNAME="${SEAL:+$(basename "$SEAL")}"; [ -n "$_SEALNAME" ] || _SEALNAME="$(bash "$NAMELEAK" gen-seal)"
+  if ! bash "$NAMELEAK" "$_SEALNAME" "$(basename "${OUT%/}")" "$(bash "$NAMELEAK" gen)"; then
     echo "🟥 out-dir 또는 seal 이름이 누출한다 — 회차를 열지 않는다 ('nameleak_check.sh gen' 을 써라)" >&2
     exit 7
   fi
@@ -586,6 +679,7 @@ while IFS='|' read -r qid kind question token general; do
   case "$qid" in ''|'#'*) continue ;; esac
   n=$((n+1))
   for arm in ARM CTRL; do
+    [ "$ARMS" = both ] || [ "$arm" = "$ARMS" ] || continue   # --arms 필터(위 enum)
     setup=""; [ "$arm" = ARM ] && setup="$SETUP_ARM"
     q="$question"
     # ── S5 ② «규약» — typed 채널의 «쓰는 쪽» (2026-09-01 배선) ──────────────────
@@ -620,7 +714,7 @@ $q"
       [ -n "$BASE_REF" ] && args+=(--base-ref "$BASE_REF")
       [ -n "$BASE_SHA" ] && args+=(--base-sha "$BASE_SHA")
       [ -n "$setup" ] && args+=(--setup "$setup")
-      # 🟥 심층 방어 — 이 호출은 `while … done < <(_tsv_pipe "$QSET")` 루프 «안»이라 stdin 이 qset 이다.
+      # 🟥 심층 방어 — 이 호출은 `while … done < "$_TSVP"` 루프 «안»이라 stdin 이 (파싱된) qset 이다.
       #    러너 쪽에도 `< /dev/null` 을 박았지만, 여기서 끊는 것이 근원이다(호출부 책임).
       bash "$RUNNER" "${args[@]}" >/dev/null 2>&1 < /dev/null
     fi
@@ -630,7 +724,7 @@ $q"
       ROWS+=("$qid|$kind|$arm|r$r|$v")
     done
   done
-done < <(_tsv_pipe "$QSET")
+done < "$_TSVP"
 
 # 🟥 매핑은 «여기»에서 쓴다 — 모든 디스패치가 끝난 뒤. 팔이 도는 동안엔 이 파일이 없다.
 if [ "${RESCORE:-0}" != 1 ]; then

package/scripts/fh-gate.sh

@@ -745,9 +745,9 @@ fi
 cat "$PARSE_FILE"
 
 # B4: Write governance log — structured header only (clean YAML, no raw markdown)
-FINDINGS_A_LOG=$(grep -m 1 "^FH_FINDINGS_A:" "$PARSE_FILE" 2>/dev/null | awk '{print $2}' | tr -d '[:space:]' || echo "0")
-FINDINGS_B_LOG=$(grep -m 1 "^FH_FINDINGS_B:" "$PARSE_FILE" 2>/dev/null | awk '{print $2}' | tr -d '[:space:]' || echo "0")
-FINDINGS_N_LOG=$(grep -m 1 "^FH_FINDINGS_COUNT:" "$PARSE_FILE" 2>/dev/null | awk '{print $2}' | tr -d '[:space:]' || echo "0")
+FINDINGS_A_LOG=$(grep -m 1 "^FH_FINDINGS_A:" "$PARSE_FILE" 2>/dev/null | awk '{print $2}' | tr -d '[:space:]' || echo "0")  # portability-noqa: already ends in `|| echo "0"` (P1's own prescribed remedy) — the assignment cannot die under set -e
+FINDINGS_B_LOG=$(grep -m 1 "^FH_FINDINGS_B:" "$PARSE_FILE" 2>/dev/null | awk '{print $2}' | tr -d '[:space:]' || echo "0")  # portability-noqa: same as FINDINGS_A_LOG above
+FINDINGS_N_LOG=$(grep -m 1 "^FH_FINDINGS_COUNT:" "$PARSE_FILE" 2>/dev/null | awk '{print $2}' | tr -d '[:space:]' || echo "0")  # portability-noqa: same as FINDINGS_A_LOG above
 {
   printf -- "- timestamp: %s\n" "$TIMESTAMP"
   printf "  caller: %s\n" "$FH_CALLER"

package/scripts/files_manifest_shipping_check.sh

@@ -129,6 +129,25 @@ if [ "$MODE" = "tarball" ]; then
     sed 's/^/      /' "$FMSC_PACK_ERR" 2>/dev/null
     exit 1
   fi
+  # 2026-09-04 (v3.0.0, first OIDC publish): inside `npm publish`'s prepublishOnly on the CI runner
+  # (Node 22 / npm 10) `npm pack --dry-run --json` returned JSON WITHOUT files[] — the impossible-zero
+  # guard below then (correctly) failed the publish, but with no way forward. Same shape as
+  # package_coverage_check.sh's oracle: when the JSON carries no files[].path, rebuild it from the
+  # text listing (`npm notice <size> <path>` lines), which is what a human reads. If THAT is empty
+  # too, leave the JSON as-is and let the impossible-zero guard fail closed as before.
+  if ! printf '%s' "$PACK_JSON" | python3 -c 'import sys,json
+d=json.load(sys.stdin); e=d[0] if isinstance(d,list) and d else d
+fl=e.get("files") if isinstance(e,dict) else None
+sys.exit(0 if fl and all(isinstance(f,dict) and "path" in f for f in fl) else 1)' 2>/dev/null; then
+    _txt=$(npm pack --dry-run 2>&1)
+    _rebuilt=$(printf '%s\n' "$_txt" | python3 -c 'import sys,re,json
+paths=[m.group(1) for ln in sys.stdin for m in [re.match(r"^npm notice\s+[0-9.]+[kMG]?B\s+(\S+)\s*$", ln)] if m]
+print(json.dumps([{"files":[{"path":p} for p in paths],"_oracle":"text-listing-fallback"}]) if paths else "")')
+    if [ -n "$_rebuilt" ]; then
+      echo "      files-manifest-shipping: npm pack --json carried no files[] — rebuilt from the text listing ($(printf '%s' "$_rebuilt" | python3 -c 'import sys,json;print(len(json.load(sys.stdin)[0]["files"]))') paths)"
+      PACK_JSON="$_rebuilt"
+    fi
+  fi
   printf '%s' "$PACK_JSON" > "$FMSC_PACK_JSON" || {
     echo "FAIL  files-manifest-shipping (--vs-tarball): could not write pack output to scratch dir"
     exit 1

package/scripts/gate_pathspec_check.sh

@@ -118,7 +118,7 @@ for pair in \
   "CATALOG.md|CHANGELOG.md|PATHSPEC covers CATALOG" \
   ".github/workflows/validate.yml|.github/dependabot.yml|PATHSPEC covers workflow 정의 (yml 만)" \
   "scripts/index_sync.py|scripts/notes.txt|PATHSPEC covers scripts/*.py" \
-  "package.json|package-lock.json|PATHSPEC covers package.json 이되 «리터럴» — lock 파일까지 삼키지 않는다"
+  "package.json|package-lock.json|PATHSPEC covers package.json 이되 «리터럴» — lock 파일까지 삼키지 않는다"  # portability-noqa: string literal fed to spec_matches()'s glob-case test, never read from disk — same reason as test_heavy_classifier_lanes.sh:106
 do
   IFS='|' read -r pos neg label <<< "$pair"
   ok=1