axmap-cli 1.1.1 → 1.2.1

package/governance/GOVERNANCE.md

@@ -212,7 +212,7 @@ node axmap/governance/gate.mjs --source <소스브랜치> --target <타깃브랜
 
 | | | 안 지키면 |
 |---|---|---|
-| **G1** | **자기 표는 세지 않는다** — MR 소스 브랜치 커밋의 author 인 사람의 표는 무효 | 혼자 쓰고 혼자 승인한다 |
+| **G1** | **자기 표는 세지 않는다** — MR 소스 브랜치 커밋의 author 인 사람의 표는 무효 (예외 하나 — 바로 아래) | 혼자 쓰고 혼자 승인한다 |
 | **G2** | **정책은 언제나 타깃 브랜치**(**합쳐 받는 쪽 브랜치**)**에서 읽는다** | 정족수를 1 로 낮추는 MR 이 **자기 자신의 낮춘 규칙으로** 통과한다 |
 | **G3** | **표는 커밋(sha)에 묶인다** — 헤드가 바뀌면 효력을 잃는다 | 승인받은 뒤 내용을 갈아끼운다 |
 | **G4** | **한 사람은 한 표** — id 유일, email 유일 | 명단에 자기를 두 줄 적으면 두 표다 |
@@ -225,6 +225,76 @@ node axmap/governance/gate.mjs --source <소스브랜치> --target <타깃브랜
 **G2 만 순수 판정 밖에 있다.** 어느 브랜치에서 정책을 읽어오는가는 git 을 만지는
 일이라 게이트의 책임이다. `src/governance.mjs` 는 **읽어온 정책이 성립하는지**만 본다.
 
+### 🔴 G1 의 예외 하나 — 던질 수 있는 사람이 정족수보다 적을 때
+
+오래 쌓는 `<파트>/dev` 브랜치에서는 시간이 갈수록 커밋한 사람이 늘어
+**던질 수 있는 사람이 0 으로 수렴한다.** 실측 (팀 저장소 S15P21E201, 2026-09-07):
+
+| 브랜치 | 투표권자 | 그중 소스 브랜치의 author | 던질 수 있는 사람 | 정족수 |
+|---|---|---|---|---|
+| `front/main` ← `front/dev` | 4명 | **4명 전원** | **0명** | 2 |
+| `back/main` ← `back/dev` | 6명 | **6명 전원** | **0명** | 2 |
+
+이건 **"아직 표가 모자라다"(미달)가 아니다.** 표를 더 모아도 안 풀린다 — 던질 수
+있는 사람 자체가 없기 때문이다. 그 상태에 미달(종료 코드 2)을 내면 부르는 쪽에게
+*"사람에게 부탁하면 된다"* 고 거짓말을 하는 것이고, 사람은 시스템 밖에서
+탈출한다 (`hotfix/` 를 코드 안에 둔 것과 같은 이유다).
+
+그래서 **그 판정 하나에 한해** G1 을 푼다. 조건 셋을 **모두** 만족할 때만이다.
+
+| | |
+|---|---|
+| 1 | 이번 판정의 **정족수를 숫자로 알고 있다** (`judge` 가 `countVotes` 에 넘긴다) |
+| 2 | **G1 이 실제로 명단에서 누군가를 뺐다** — 안 뺐으면 G1 이 만든 교착이 아니다 |
+| 3 | 그러고 **남은 사람이 정족수보다 적다** |
+
+2번이 없으면 *"명단 자체가 정족수보다 작다"*(승계로도 못 채운 **막힌 저장소**)까지
+이 문으로 샌다. 그건 G1 을 풀어도 아무도 못 던지므로, 판정문에 거짓 사유만
+한 줄 남는다.
+
+**바뀌지 않는 것 — 이게 절반이다.**
+
+- **정족수 숫자.** `majorityThreshold` 는 그대로다. 문턱을 낮추면 *"최소 두 사람이
+  본다"* 는 팀의 뜻이 조용히 사라진다. 여기서 푸는 것은 **누가 던질 수 있는가** 하나다
+- **G3 · G4 · G5**, 브랜치 대조, committer(**표를 기록한 git 신원**) 대조,
+  `vote_note`, 미래 시각 — 전부 그대로 돈다
+- **fail-closed.** 소스 브랜치의 author 목록을 못 받으면 여전히 판정 불가다
+  (`authors-missing`). **"저자를 모를 때" 는 해제 조건이 아니다** — 거기로 새면
+  G1 은 켜고 끄는 스위치가 되고, 그건 성질이 아니라 설정이다
+
+🔴 **해제는 조용히 발동하지 않는다.** 승계와 같은 규칙이다 — 판정문이 찍는다.
+
+```
+🔴 G1(자기 표 배제)이 해제된 판정입니다 — 유효 투표권자 0명 < 정족수 2.
+   저자 본인의 표를 셌습니다.
+```
+
+해제 덕분에 세어진 사람의 이름까지 남는다. 기계가 읽을 표식은 `tally` 에 있다 —
+`g1Waived` · `eligibleCount` · `threshold` · `selfVoted`. `gate --json` 이 그대로 낸다.
+
+🔴 **표를 쓰는 쪽도 같은 판단을 한다.** `governance/vote.mjs` 는 자기 표를 만나면
+게이트를 `--json` 으로 한 번 돌려 그 판정의 `tally.g1Waived` 를 읽는다. 해제가
+걸리면 **`--force` 없이 그냥 써 주고** 왜 걸렸는지(유효 투표권자 N명 < 정족수 M)를
+같이 찍는다. 안 걸리면 지금까지대로 경고하고 `--force` 를 요구한다.
+
+> **왜 이 줄이 여기 있나** — 1.2.0 에서 이 예외를 세는 쪽에만 넣었더니, 쓰는 쪽이
+> 그것을 모른 채 *"이 표는 자기 표라 세지지 않습니다"* 라며 막았다. **세어질 표를
+> 막은 것이다.** 사람은 던져 보지도 않고 교착이라고 믿었다 (실측: 팀 저장소
+> S15P21E201 의 `front/dev → front/main`, 2026-09-07 — `--force` 로 밀어 넣은
+> 자기 표 둘이 판정문에서 "해제 덕분에 센 표" 로 세어져 종료 코드 0 이 났다).
+>
+> 그래서 쓰는 쪽은 조건을 **다시 세지 않는다.** 판정이 내놓은 표식을 읽을 뿐이다.
+> 같은 규칙을 두 곳에 적으면 한쪽만 고치는 날 같은 어긋남이 또 난다 —
+> `vote_note` 를 두 곳에서 같은 함수 하나로 보는 것과 같은 이유다.
+>
+> **fail-closed 는 쓰는 쪽에도 그대로다.** 게이트를 못 돌렸거나 판정이 `count`
+> 단계까지 못 갔으면 해제하지 않는다. 즉 **모르면 여전히 `--force` 가 필요하다.**
+
+**`self_vote` 정책(아래)과는 다른 층이다.** `self_vote` 는 *"누구까지를 자기로
+보는가"* 를 **사람이 미리 정하는 것**이고, 이 예외는 *"그렇게 정했더니 아무도 못
+던지게 됐을 때"* **코드가 그 판정에서만 푸는 것**이다. `self_vote: "off"` 면
+배제할 사람이 없으므로 이 예외는 아예 안 걸린다.
+
 ---
 
 ## 종료 코드
@@ -496,7 +566,9 @@ git log --format=%B -1 <커밋> | git interpret-trailers --parse
 살아 있는 투표권자가 필요 표보다 적으면, 최근 90일 안에 커밋한 author 상위 3명이
 **임시 투표권**을 갖는다.
 
-- 승계로 들어온 사람도 **자기 표는 못 센다** (G1 은 예외가 없다)
+- 승계로 들어온 사람도 **자기 표는 못 센다** (G1). 예외는 하나 — 던질 수 있는
+  사람이 정족수보다 적어 G1 이 해제된 판정에서는 승계로 들어온 사람의 자기 표도
+  센다 (위 "G1 의 예외 하나")
 - 정책에 적힌 사람은 **살아 있지 않아도 투표권을 잃지 않는다.** 생사는 *승계를 켤지*만
   정한다. 두 달 자리를 비운 사람이 돌아와 던진 표가 안 세지면 그건 fail-closed 가
   아니라 그냥 틀린 판정이다

package/governance/vote.mjs

@@ -50,6 +50,11 @@
  *    언제나 게이트다. 여기서 미리 거르면 규칙이 두 군데로 갈라지고, 그때부터
  *    한 쪽만 고쳐지는 날이 온다.
  *
+ *    🔴 그래서 **자기 표를 막을지 말지도 여기서 판단하지 않는다.** 게이트를
+ *    `--json` 으로 한 번 돌려 그 판정의 `tally.g1Waived` 를 그대로 읽는다
+ *    (`g1WaiverFor`). 1.2.0 에서 세는 쪽이 얻은 G1 해제를 이 파일이 몰라
+ *    **세어질 표를 "안 세어집니다" 라며 막던** 버그가 바로 그 갈라짐이었다.
+ *
  * ── 장부와 같은 방식 ─────────────────────────────────────────────────────
  *
  * 표 브랜치를 다루는 방법은 `bin/axmap.mjs` 의 장부(`axmap/claims`)와 같다:
@@ -222,6 +227,8 @@ const HELP = `표를 던진다 — 저장소 안의 파일 하나로
   --target    자기 표(G1) 경고를 위해 비교할 브랜치. 생략하면 main.
               변경량(agent.shown)을 재는 기준이기도 하다
   --force     자기 표라는 경고를 무릅쓰고 그래도 쓴다.
+              🔴 던질 수 있는 사람이 정족수보다 적어 G1 이 해제되는 판정에서는
+              필요 없다 — 그때는 자기 표도 세어지므로 그냥 써 준다
               🔴 이유(--note) 요구는 --force 로 못 넘긴다
   --remote    원격 이름. 없으면 git config axmap.remote → 유일한 원격 → origin
   --policy    정책 파일의 자리 (저장소 루트 기준). 없으면 AXMAP_POLICY_PATH
@@ -352,7 +359,38 @@ function selfVoteRange(branch, targetName) {
   return { args: ['-n', '200', branch], label: `${branch} 의 최근 200 커밋` }
 }
 
-function warnIfSelfVote(branch, targetName, email, force) {
+/**
+ * **이 판정에서 G1 이 해제되는가 — 세는 쪽에 물어본다.**
+ *
+ * 🔴 왜 여기서 계산하지 않는가 — **이 함수가 없어서 버그가 났다.** 1.2.0 에서
+ *    세는 쪽(`src/governance.mjs` 의 `countVotes`)은 *"자기 표를 빼고 나면 던질
+ *    수 있는 사람이 정족수보다 적을 때"* 그 판정 하나에 한해 G1 을 푸는 예외를
+ *    얻었는데, **쓰는 쪽인 이 파일은 그 사실을 몰랐다.** 그래서 세어질 표를
+ *    "안 세어집니다" 라며 막았고, 팀은 반나절을 교착이라고 믿었다
+ *    (실측: 팀 저장소 S15P21E201 의 `front/dev → front/main`, 2026-09-07).
+ *
+ *    같은 규칙을 두 곳에 적으면 그 어긋남이 그대로 다시 난다. 그래서 여기서는
+ *    조건을 세지 않고 **판정이 내놓은 표식**(`tally.g1Waived` · `eligibleCount`
+ *    · `threshold`)을 그대로 읽는다. `vote_note` 를 두 곳에서 같은 함수 하나로
+ *    보는 것과 같은 태도다.
+ *
+ * 🔴 **fail-closed.** 게이트를 못 돌렸거나 판정이 `count` 단계까지 못 갔으면
+ *    `null` 을 돌려 **해제하지 않는다.** 모를 때 풀어 주면 G1 은 성질이 아니라
+ *    켜고 끄는 스위치가 된다 (GOVERNANCE.md 의 "G1 의 예외 하나").
+ *
+ * @returns {{eligibleCount:number, threshold:number}|null} 해제될 때만 숫자들
+ */
+function g1WaiverFor(branch, targetName, policyFlag) {
+  const v = runGate(branch, targetName, policyFlag)
+  if (!v || v.stage !== 'count' || !v.tally) return null
+  const { g1Waived, eligibleCount, threshold } = v.tally
+  if (g1Waived !== true) return null
+  // 표식이 반쪽만 온 판정은 못 읽은 것으로 친다 — 숫자를 지어내서 안내하지 않는다.
+  if (!Number.isInteger(eligibleCount) || !Number.isInteger(threshold)) return null
+  return { eligibleCount, threshold }
+}
+
+function warnIfSelfVote(branch, targetName, email, force, policyFlag) {
   const range = selfVoteRange(branch, targetName)
   const r = git(['log', '--format=%aE', ...range.args])
   if (r.code !== 0) {
@@ -362,6 +400,18 @@ function warnIfSelfVote(branch, targetName, email, force) {
   const authors = new Set(r.out.split('\n').map((s) => s.trim().toLowerCase()).filter(Boolean))
   if (!authors.has(email.toLowerCase())) return
 
+  // 자기 표는 맞다. 그런데 **이 판정에서는 세어지는가?** 세는 쪽에 물어본다.
+  const waiver = g1WaiverFor(branch, targetName, policyFlag)
+  if (waiver) {
+    console.error(
+      '이 표는 자기 표지만 **이 판정에서는 세어집니다** (G1 의 예외 — 해제).\n'
+      + `  ${targetName} 기준 유효 투표권자 ${waiver.eligibleCount}명 < 정족수 ${waiver.threshold} —\n`
+      + '  자기 표를 빼고 나면 던질 수 있는 사람이 정족수보다 적어, 이 판정 하나에 한해 G1 이 풀립니다.\n'
+      + '  --force 없이 그대로 씁니다. 판정문에는 "해제 덕분에 센 표" 로 이름까지 남습니다.\n',
+    )
+    return
+  }
+
   console.error(
     `이 표는 자기 표라 세지지 않습니다 (G1 — 자기가 쓴 코드에 자기가 찬성할 수 없습니다).\n`
     + `  ${email} 이(가) ${range.label} 의 author 목록에 있습니다.\n\n`
@@ -478,16 +528,21 @@ function measureDiff(targetName, branch) {
 }
 
 /**
- * **던지기 직전의 판정.** 게이트를 그대로 한 번 돌려 요약 한 줄로 줄인다.
+ * **세는 쪽에게 직접 물어본다.** 게이트를 `--json` 으로 한 번 돌리고 그 판정을
+ * 그대로 기억한다. 못 돌렸으면 `null`.
  *
- * 🔴 이 표 자신은 아직 없다. 즉 `"미달 1/2"` 는 *"내가 던지기 전에 1표였다"* 는
- *    뜻이다. 나중에 이 표가 몇 번째였는지를 이력만으로 알 수 있게 하는 값이다.
+ * 🔴 **이 프로그램은 판정을 흉내내지 않는다.** "자기 표가 세어지는가" 를 여기서
+ *    다시 계산하면 규칙이 두 벌이 되고, 한쪽만 고치는 날 **세는 쪽은 세는데
+ *    쓰는 쪽은 막는** 어긋남이 난다. 그게 실제로 났다 (`g1WaiverFor` 주석).
  *
- * 판정문을 다시 해석하지 않고 `--json` 의 `exit`·숫자만 쓴다. 문구를 다듬는
- * 커밋이 이 칸의 뜻을 바꾸면 안 되기 때문이다 (gate.mjs 의 관례 그대로).
- * 못 돌리면 `"잴 수 없음"` — 표는 그래도 던져진다.
+ * 🔴 한 번만 돌린다. 이 결과를 쓰는 자리가 둘이기 때문이다 — 자기 표를 막을지
+ *    말지(`g1WaiverFor`)와 표에 적히는 `agent.shown.gate`. 두 번 돌리면 게이트가
+ *    두 번 fetch 하고, 그 사이에 남이 표를 던지면 **같은 실행 안에서 두 판정이
+ *    갈린다.**
  */
-function measureGate(branch, targetName, policyFlag) {
+let gateOnce // undefined = 아직 안 돌림 · null = 못 돌림
+function runGate(branch, targetName, policyFlag) {
+  if (gateOnce !== undefined) return gateOnce
   const r = spawnSync(process.execPath, [
     path.join(HERE, 'gate.mjs'),
     '--source', branch,
@@ -502,10 +557,28 @@ function measureGate(branch, targetName, policyFlag) {
     maxBuffer: 64 * 1024 * 1024,
     timeout: GATE_TIMEOUT_MS,
   })
-  if (r.error || r.status === null) return '잴 수 없음'
+  gateOnce = null
+  if (r.error || r.status === null) return gateOnce
   let verdict = null
-  try { verdict = JSON.parse(r.stdout ?? '') } catch { return '잴 수 없음' }
-  if (!verdict || typeof verdict !== 'object') return '잴 수 없음'
+  try { verdict = JSON.parse(r.stdout ?? '') } catch { return gateOnce }
+  if (!verdict || typeof verdict !== 'object') return gateOnce
+  gateOnce = verdict
+  return gateOnce
+}
+
+/**
+ * **던지기 직전의 판정** 한 줄. 위에서 받아 둔 판정을 요약할 뿐이다.
+ *
+ * 🔴 이 표 자신은 아직 없다. 즉 `"미달 1/2"` 는 *"내가 던지기 전에 1표였다"* 는
+ *    뜻이다. 나중에 이 표가 몇 번째였는지를 이력만으로 알 수 있게 하는 값이다.
+ *
+ * 판정문을 다시 해석하지 않고 `--json` 의 `exit`·숫자만 쓴다. 문구를 다듬는
+ * 커밋이 이 칸의 뜻을 바꾸면 안 되기 때문이다 (gate.mjs 의 관례 그대로).
+ * 못 돌리면 `"잴 수 없음"` — 표는 그래도 던져진다.
+ */
+function measureGate(branch, targetName, policyFlag) {
+  const verdict = runGate(branch, targetName, policyFlag)
+  if (!verdict) return '잴 수 없음'
   if (verdict.stage === 'policy') return '정책 깨짐'
   if (verdict.stage === 'undecidable') return '판정 불가'
   if (!Number.isInteger(verdict.approvals) || !Number.isInteger(verdict.threshold)) return '잴 수 없음'
@@ -645,7 +718,7 @@ const nameErr = agentNameError(voter)
 if (nameErr) die(`${nameErr}\n  git config user.name 을 고치세요.`)
 
 warnIfNotAVoter(roster, targetName, email)
-warnIfSelfVote(branch, targetName, email, flags.force === true)
+warnIfSelfVote(branch, targetName, email, flags.force === true, str(flags.policy))
 
 // ── 이유 없는 표는 여기서 거부한다 ─────────────────────────────────────────
 //

package/package.json

@@ -1,7 +1,7 @@
 {
   "//name": "🔴 npm 의 'axmap' 은 2022년부터 남이 쓰고 있는 다른 꾸러미다(leozin_ 의 Map 라이브러리, 1.1.2). 그래서 `npx axmap` 은 우리 것이 아니고, 누구에게도 그렇게 안내하면 안 된다. 2026-08-28 에 axmap-cli 로 정했다 — 스코프(@사용자/이름)를 쓰지 않는 이유는 스코프가 npm 계정 이름에 묶여서 나중에 팀이나 조직으로 옮길 때 이름이 통째로 바뀌기 때문이다. 사람이 치는 **명령** 이름은 그대로 axmap 이다 (아래 bin) — 꾸러미 이름과 명령 이름은 달라도 된다.",
   "name": "axmap-cli",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "//private": "🔴 여기 있던 \"private\": true 를 2026-08-28 에 지웠다. 그 줄이 있는 동안 npm publish 는 거부됐다. 되돌리려면 다시 넣으면 되지만, 이미 올라간 버전은 그래도 안 사라진다 — npm 은 같은 번호를 덮어쓰지 못하고 삭제도 72시간 안에만 된다. 즉 이 줄을 되살리는 것은 '앞으로 안 올린다' 는 뜻이지 '올린 것을 없앤다' 는 뜻이 아니다.",
   "//publishConfig": "axmap-cli 는 스코프가 없어서 기본이 이미 공개다. 즉 지금은 없어도 된다. 그래도 남겨 두는 이유: 나중에 @조직/axmap 처럼 스코프를 붙이는 날 이 줄이 없으면 publish 가 '유료 플랜이 필요하다'는 엉뚱한 말로 실패한다.",
   "publishConfig": {

package/src/governance.mjs

@@ -929,9 +929,15 @@ const FUTURE_TOLERANCE_MS = 24 * 60 * 60 * 1000
  * @param {string|null} [args.branch] 소스 브랜치 이름. 주면 표의 branch 와 대조한다
  * @param {string|null} [args.tipAuthorEmail] 맨 위 커밋의 author email.
  *        `self_vote: "tip"` 일 때만 쓰이고, 그때는 **없으면 판정 불가**다
- * @returns {{approvals:number, counted:Array, rejections:Array, invalid:Array}}
+ * @param {number|null} [args.threshold] 이번 판정의 정족수. **주면** 자기 표 배제가
+ *        판정을 불가능하게 만드는지 볼 수 있다 (아래 waiver). 안 주면 해제는
+ *        영영 안 걸린다 — 모르면 안 푸는 쪽이 fail-closed 다. `judge` 가 넣어 준다
+ * @returns {{approvals:number, counted:Array, rejections:Array, invalid:Array,
+ *            g1Waived:boolean, eligibleCount:number, threshold:number|null, selfVoted:Array}}
  */
-export function countVotes({ policy, votes, authorEmails, sha, now, voters = null, branch = null, tipAuthorEmail = null }) {
+export function countVotes({
+  policy, votes, authorEmails, sha, now, voters = null, branch = null, tipAuthorEmail = null, threshold = null,
+}) {
   const roster = voters ?? policy?.voters ?? null
   if (!Array.isArray(roster) || roster.length === 0) {
     throw new GovernanceError('투표권자 명단이 없습니다.', { exit: EXIT.POLICY_BROKEN, code: 'voters-missing' })
@@ -966,9 +972,41 @@ export function countVotes({ policy, votes, authorEmails, sha, now, voters = nul
   const authors = excludedAuthors(selfVote, authorEmails, tipAuthorEmail)
   const byEmail = new Map(roster.map((v) => [fold(v.email), v]))
 
+  // ── G1 해제(waiver) — 자기 표 배제가 **판정 자체를 불가능하게 만들 때만** ────
+  //
+  // 🔴 왜 필요한가 — 실측. 오래 쌓는 `<파트>/dev` 브랜치에서는 시간이 갈수록
+  //    커밋한 사람이 늘어 "던질 수 있는 사람" 이 0 으로 수렴한다. 팀 저장소의
+  //    `front/main` 은 투표권자 4명이 **전원 저자**였고(정족수 2), `back/dev` 는
+  //    명단 6명 전원이 저자였다. 이건 "아직 표가 모자라다"(미달, exit 2)가 아니라
+  //    **표를 더 모아도 영원히 안 풀리는 교착**이다. 재시도가 답이 아닌 상태에
+  //    미달 코드를 내는 것은 부르는 쪽에게 거짓말을 하는 것이다.
+  //
+  // 🔴 해제 조건을 좁게 잡는다. 셋을 **모두** 만족해야 한다.
+  //      1. 이번 판정의 정족수를 숫자로 알고 있다 (`threshold` 를 받았다)
+  //      2. G1 이 실제로 명단에서 누군가를 뺐다 (`excludedFromRoster > 0`)
+  //      3. 그러고 남은 사람이 정족수보다 적다 (`eligibleCount < threshold`)
+  //    2번이 없으면 "명단 자체가 정족수보다 작다"(승계로도 못 채운 막힌 저장소)
+  //    까지 이 문으로 새어 나온다. 그건 G1 이 만든 교착이 아니므로 G1 을 풀어도
+  //    아무도 못 던진다 — 판정문에 거짓 사유만 한 줄 남는다.
+  //
+  // 🔴 **정족수 숫자는 건드리지 않는다.** 문턱을 낮추면 "두 사람이 본다" 는 팀의
+  //    뜻이 조용히 사라진다. 여기서 바꾸는 것은 **누가 던질 수 있는가** 하나다.
+  //
+  // 🔴 fail-closed 는 그대로다. 저자 목록을 못 받으면 위에서 이미 던졌다
+  //    (`authors-missing`). "저자를 모를 때" 는 해제 조건이 **아니다** —
+  //    모르는 것과 셀 수 없는 것을 통과로 바꾸면 이 층이 없는 것과 같다.
+  const eligible = roster.filter((v) => !authors.has(fold(v?.email)))
+  const eligibleCount = eligible.length
+  const excludedFromRoster = roster.length - eligibleCount
+  const need = isInt(threshold) && threshold >= 1 ? threshold : null
+  const g1Waived = need !== null && excludedFromRoster > 0 && eligibleCount < need
+
   const counted = []
   const rejections = []
   const invalid = []
+  // 해제 덕분에 세어진 표. **판정문에 이름까지 남긴다** — 해제가 조용히 발동하면
+  // 그건 예외가 아니라 우회로다 (승계를 출력에 찍는 것과 같은 이유).
+  const selfVoted = []
   const seen = new Map() // fold(email) -> 이미 센 표
 
   for (const raw of votes) {
@@ -993,7 +1031,8 @@ export function countVotes({ policy, votes, authorEmails, sha, now, voters = nul
     if (!isStr(v.committerEmail)) { bad('committer-unknown'); continue }
     if (fold(v.committerEmail) !== email) { bad('committer-mismatch', v.committerEmail); continue }
 
-    if (authors.has(email)) { bad('self-vote'); continue } // G1
+    // G1 · 자기 표는 안 센다. 단 해제된 판정에서는 센다 (위 waiver 주석).
+    if (authors.has(email) && !g1Waived) { bad('self-vote'); continue }
     if (toMs(v.at, 'votes[].at') > nowMs + FUTURE_TOLERANCE_MS) { bad('future-dated', v.at); continue }
     // 🔴 이유 없는 표는 **찬성이든 반대든** 안 센다. 반대야말로 이유가 필요하다 —
     //    이유 없는 반대는 판정문에 "누군가 막고 있다" 만 남기고 무엇을 고쳐야
@@ -1004,13 +1043,28 @@ export function countVotes({ policy, votes, authorEmails, sha, now, voters = nul
     if (seen.has(email)) { bad('duplicate', `이미 센 표: ${seen.get(email).voter}`); continue } // G4
 
     seen.set(email, v)
+    // 해제가 없었으면 여기 못 왔을 표. 판정문이 이름을 찍는다.
+    if (g1Waived && authors.has(email)) selfVoted.push({ voter: v.voter, email: v.email, vote: v.vote })
     if (v.vote === 'approve') counted.push(v)
     // 반대는 정족수 계산에 들어가지 않는다. 이 층이 답하는 질문은 "찬성이 몇인가"
     // 하나뿐이고, 거부권은 다른 제도다 — 만들려면 SPEC 부터 고쳐야 한다.
     else rejections.push(v)
   }
 
-  return { approvals: counted.length, counted, rejections, invalid }
+  return {
+    approvals: counted.length,
+    counted,
+    rejections,
+    invalid,
+    // ── 기계가 읽는 해제 표식 ────────────────────────────────────────────
+    // `gate.mjs --json` 이 이 셋을 그대로 내보낸다. 판정문의 한 줄이 지워져도
+    // 이 표식은 남는다 — 나중에 "이 판정이 예외였나" 를 사람이 아니라 코드가
+    // 물어볼 수 있어야 한다.
+    g1Waived,
+    eligibleCount,
+    threshold: need,
+    selfVoted,
+  }
 }
 
 /**
@@ -1084,7 +1138,14 @@ export function judge({
       : null
     const need = rulesFor(changed, policy, { majority })
     const roster = deriveVoters({ policy, contributors, now, threshold: need.threshold })
-    const tally = countVotes({ policy, votes, authorEmails, sha, now, voters: roster.voters, branch, tipAuthorEmail })
+    // 🔴 정족수를 **분자 쪽에도** 넘긴다. `countVotes` 는 이 숫자가 있어야
+    //    "자기 표를 빼고 나면 던질 수 있는 사람이 정족수보다 적은가" 를 볼 수
+    //    있다. 문턱은 여기서 정해지므로(`rulesFor`) 그 값을 그대로 준다 —
+    //    분자가 다른 문턱을 보고 해제를 판단하면 판정만 조용히 틀린다.
+    const tally = countVotes({
+      policy, votes, authorEmails, sha, now, voters: roster.voters, branch, tipAuthorEmail,
+      threshold: need.threshold,
+    })
     const ok = tally.approvals >= need.threshold
     return {
       exit: ok ? EXIT.OK : EXIT.SHORT,
@@ -1141,6 +1202,22 @@ export function formatVerdict(verdict) {
   }
   L.push('')
 
+  // 🔴 자기 표 배제 해제는 **조용히 발동하지 않는다.** 이 줄을 지우면 해제가
+  //    예외가 아니라 우회로가 된다 — 승계 줄을 지울 수 없는 것과 같은 이유다.
+  //    나중에 이력을 보는 사람이 "이 판정은 예외였다" 를 여기서 알아야 한다.
+  if (tally?.g1Waived) {
+    L.push(`  🔴 G1(자기 표 배제)이 해제된 판정입니다 — 유효 투표권자 ${tally.eligibleCount}명 < 정족수 ${threshold}. 저자 본인의 표를 셌습니다.`)
+    L.push('     오래 쌓인 브랜치는 투표권자가 전부 저자가 되어 던질 수 있는 사람이 0 이 됩니다.')
+    L.push('     그건 표가 모자란 것이 아니라 표를 더 모아도 안 풀리는 교착이라, 이 판정에 한해서만 풉니다.')
+    L.push('     🔴 정족수 숫자는 그대로입니다. G3(표는 커밋에 묶인다)·G4(같은 사람의 두 번째 표)·')
+    L.push('        브랜치 대조·committer(표를 기록한 git 신원) 대조도 전부 그대로 돕니다.')
+    if (tally.selfVoted?.length) {
+      L.push('     해제 덕분에 센 표')
+      for (const s of tally.selfVoted) L.push(`       ! ${s.voter} <${s.email}>  ${s.vote}`)
+    }
+    L.push('')
+  }
+
   if (tally.counted.length) {
     L.push('  센 표')
     for (const c of tally.counted) L.push(`    o ${c.voter} <${c.email}>  ${c.at}`)
@@ -1173,7 +1250,10 @@ export function formatVerdict(verdict) {
     } else {
       L.push('     그런데 창 안에 기여자가 없습니다.')
     }
-    L.push('     승계로 들어온 사람도 자기 표는 세지 않습니다 (G1).')
+    // 해제된 판정에서는 이 줄이 거짓이 된다. 틀린 안내는 안 하는 것만 못하다.
+    L.push(tally?.g1Waived
+      ? '     이 판정은 자기 표 배제가 해제되어 있어 승계로 들어온 사람의 자기 표도 셉니다 (위 🔴).'
+      : '     승계로 들어온 사람도 자기 표는 세지 않습니다 (G1).')
     L.push('')
   }
   if (roster.short > 0) {