geobuke-code 0.2.9 → 0.4.0

package/README.md

@@ -19,6 +19,13 @@
 
 게이트는 *완전 구현*을 요구하지 않는다. 케이스가 다뤄지기 시작했거나 명시 defer되면 통과한다.
 
+그 게이트 위에 운영을 돕는 얇은 층이 붙는다:
+
+- **누락 케이스 일괄 분류** — 차단이 도출한 형제 케이스를 번호 체크리스트로 받아 한 번에 승인(spec)/미룸(defer) ([`gbc gate review`](#누락-케이스-일괄-분류-gbc-gate-review))
+- **크로스-repo 가시성** — 등록한 다른 repo의 미해결 defer 요약 + 게이트 hook 건강성 롤업("회사 repo에서 게이트가 조용히 안 먹는다"를 한 명령으로 진단) ([크로스-repo](#크로스-repo-가시성))
+- **판정 드리프트 회귀락** — 실제 판정을 캡처해두고 모델/프롬프트/SDK 변화 후 재판정해 pass↔block 뒤집힘을 잡는 로컬 pre-flight ([`gbc gate snapshot`](#판정-드리프트-회귀락-gbc-gate-snapshot))
+- **관측 계측(M1~M3)** — 게이트 적중·재호출·통과 후 churn. 여러 repo는 `gbc metrics --all`로 병합 ([계측](#계측-m1m3))
+
 ## 설치
 
 ```bash
@@ -100,11 +107,11 @@ phase-protocol/계획 → /plan(SubTask) → 【게이트: 구현 직전 케이
 | **코드 변경 직전** | PreToolUse (`Edit\|Write\|MultiEdit`) | 명세 ↔ 변경 ↔ defer 대조 → 통과(침묵)/차단(시나리오 도출 지시)/fail-open |
 | **작업단위당 1회** | (PreToolUse 캐시) | 같은 명세 해시 내에선 첫 편집만 판정, 이후 통과 → 매 편집 지연 회피 |
 | **응답 종료** | Stop | 계측 flush(`events.jsonl`) + 미해결 defer가 있으면 리마인드(매 대화 종료마다). 거슬리면 `gbc defer mute`(또는 `/gbc-mute` 스킬)로 끈다 — SessionStart 진입 알림은 유지 |
-| **업데이트 필요 시** | (PreToolUse·SessionStart) | hook 구버전(②) 또는 신버전 출시(①)면 갱신 안내. PreToolUse는 세션당 1회(`systemMessage` 비차단), SessionStart는 진입 시 표시. `gbc status`는 캐시만 갱신하고 안내는 **표시하지 않는다**(명시 진단 명령). 게이트 통과/차단 동작은 불변 |
+| **업데이트 필요 시** | (PreToolUse·SessionStart) | hook 구버전(②) 또는 신버전 출시(①)면 갱신 안내. PreToolUse는 세션당 1회(`systemMessage` 비차단) — **통과된 작업단위(cached-skip) 편집에도 표시**(0.3.0: 평상 작업 대부분이 cached-skip이라, 여기서 빠지면 배너가 거의 안 떴음). SessionStart는 진입 시 표시(모델 컨텍스트). `gbc status`는 캐시만 갱신하고 안내는 **표시하지 않는다**(명시 진단 명령). 게이트 통과/차단 동작은 불변 |
 
 > 세션 진입 알림만 끄려면 `GBC_NO_SESSION_HINT=1`. 매 대화 종료(Stop) defer 리마인드만 끄려면 `gbc defer mute`(영속, 해제 `unmute` · 스킬 `/gbc-mute`) — 진입 알림은 남는다. 업데이트 안내만 끄려면 `GBC_NO_UPDATE_NOTICE=1`.
 > 프로젝트 hook이 구식이거나(SessionStart 누락·옛 명령) 새 버전이 나오면 gbc가 감지해 **`gbc update`**(전역 최신 + 현재 프로젝트 재init 한방) 또는 수동 `npm i -g geobuke-code@latest → gbc init --yes`를 안내한다. 단 안내는 **이미 hook이 등록된 프로젝트**(=한 번이라도 `gbc init`을 한 코호트)에만 도달한다 — 전혀 init하지 않은 프로젝트엔 실행할 hook이 없어 구조적으로 알릴 수 없다(gbc는 전역 hook을 깔지 않는다).
-> **업데이트 안내(①)는 네트워크를 게이트 핫패스에 들이지 않는다**: `~/.gbc/version-check.json` 캐시만 비교하고, 갱신 fetch는 SessionStart·`gbc status`에서만 짧은 타임아웃(1.5s)으로. SessionStart는 캐시가 stale이면 **표시 전에 갱신**해 신버전이 그 세션에 바로 뜬다(1세션 지연 없음). 조회 실패는 조용히 무시(fail-silent)되어 게이트 결정에 영향이 없다. 캐시 TTL 24h.
+> **업데이트 안내(①)는 네트워크를 게이트 핫패스에 들이지 않는다**: `~/.gbc/version-check.json` 캐시만 비교하고, 갱신 fetch는 안전한 비-핫패스에서만 짧은 타임아웃(1.5s)으로. ⓐSessionStart는 캐시가 stale이면 **표시 전에 갱신**해 신버전이 그 세션에 바로 뜬다(1세션 지연 없음). ⓑ**PreToolUse는 judge를 도는 편집(cache-miss)에서 캐시가 stale이면 refresh를 judge와 *병렬*로 건다**(0.3.0) — judge가 ≥1.5s라 지연 0이고, 사용자가 `gbc status`를 직접 치지 않아도 캐시가 최신이 된다. **cached-skip 핫패스에는 네트워크를 절대 넣지 않는다.** 조회 실패는 조용히 무시(fail-silent)되어 게이트 결정에 영향이 없다. 캐시 TTL 24h.
 
 ### 시나리오 도출 루프 (수기 입력 불필요)
 
@@ -117,6 +124,19 @@ phase-protocol/계획 → /plan(SubTask) → 【게이트: 구현 직전 케이
 - **도출**은 코딩 에이전트 본체(Opus, 대화 맥락 보유)가, **게이트 판정**은 haiku가 한다 — 두 작업/두 모델 분리. gbc는 모델 계층을 소유하지 않는다(판단용 작은 호출만).
 - **사용자 검증은 양보 불가**다 — 같은 에이전트가 도출+구현까지 자동으로 하면 자기 시나리오만 통과시키는 고무도장이 된다. 승인 없는 자동 등록을 금지한다.
 
+### 누락 케이스 일괄 분류 (`gbc gate review`)
+
+명세가 있는데 **형제 케이스를 침묵 누락**해 차단되면, 판정이 도출한 누락 케이스들이 `.gbc/pending-review.json`에 기록된다. 케이스가 여러 개일 때 하나씩 `gbc spec add`/`gbc defer add`를 반복하지 않고 **체크리스트로 한 번에 분류**한다:
+
+```
+gbc gate review                              # 누락 케이스를 번호 목록으로 (사용자에게 제시·검증)
+gbc gate review --spec 1 3 --defer 2         # 1,3은 승인→spec / 2는 미룸→defer (한 번에)
+```
+
+- 승인(`--spec`)은 `.gbc/spec.md`에, 미룸(`--defer`)은 defer 레지스트리에 등록하고 펜딩을 비운다. 한 케이스가 양쪽에 걸리면 **spec 우선**(이중 등록 방지). ref는 `번호|텍스트|all`(defer 명령과 동일).
+- 분류 후 같은 편집을 재시도하면 등록된 케이스 기준으로 재판정된다. 여기서도 **사용자 검증이 분류 전제** — 도출된 케이스를 사용자에게 보여주고 승인받은 뒤 등록한다.
+- 펜딩은 "가장 최근 차단의 도출"이라 다음 차단이 덮어쓴다. 단건이면 종전대로 지금 변경에서 직접 다루거나 `gbc defer add`로 미뤄도 된다.
+
 ## 지연(latency)과 트랜스포트
 
 판정은 작은 LLM 호출이다. 두 트랜스포트:
@@ -134,7 +154,7 @@ phase-protocol/계획 → /plan(SubTask) → 【게이트: 구현 직전 케이
 
 | 명령 | 설명 |
 |---|---|
-| `gbc init` | hook + `/gate` · `/gbc-mute` 스킬 설치 |
+| `gbc init` | hook + `/gate` · `/gbc-mute` 스킬 설치 + 크로스-repo 레지스트리 자동등록(opt-out: `--no-register`) |
 | `gbc update` | 전역 최신 설치(`npm i -g …@latest`) + 현재 프로젝트 재init 한방. `--dry-run`으로 실행 명령만 미리보기 |
 | `gbc status` | 게이트 상태 + 로드된 명세 + Stop 리마인드 음소거 여부 |
 | `gbc defer add "<케이스>"` | 케이스를 명시적으로 미루기 (→ open) |
@@ -147,9 +167,13 @@ phase-protocol/계획 → /plan(SubTask) → 【게이트: 구현 직전 케이
 | `gbc spec show` | 등록된 케이스 목록 |
 | `gbc spec clear` | 명세 비우기(작업단위 종료) |
 | `gbc gate reset` | 작업단위 게이트 리셋 |
-| `gbc metrics [--json]` | 계측 리포트(M1~M3) |
+| `gbc gate review` | 차단이 도출한 누락 케이스 체크리스트 보기 |
+| `gbc gate review --spec <ref> --defer <ref>` | 누락 케이스 일괄 분류(승인→spec / 미룸→defer) |
+| `gbc gate snapshot <on\|off\|status\|list\|clear>` | 골든셋 캡처 토글·조회(판정 드리프트 회귀락) |
+| `gbc gate snapshot replay [--samples N]` | 골든 케이스 재판정(temp 0)·드리프트 시 exit 1 |
+| `gbc metrics [--all] [--json]` | 계측 리포트(M1~M3). `--all`=등록 repo들의 events.jsonl 병합 집계 |
 | `gbc repos add [경로]` | 크로스-repo 레지스트리에 추가(생략 시 현재 폴더) |
-| `gbc repos list` | 등록된 repo + 각 repo의 미해결 defer 수 |
+| `gbc repos list` | 등록된 repo + 각 repo의 미해결 defer 수 + **게이트 건강성**(hook 부재/구식 코호트) |
 | `gbc repos remove [경로]` | 레지스트리에서 제거 |
 
 우회: `GBC_NO_GATE=1` (계측됨 — 우회 자체가 게이트 가치 측정 데이터).
@@ -158,6 +182,8 @@ phase-protocol/계획 → /plan(SubTask) → 【게이트: 구현 직전 케이
 
 여러 repo를 오가며 작업할 때, **다른 repo에 걸린 미완 작업**을 그 repo를 열지 않고도 인지하기 위한 기능이다. 세션 진입(SessionStart) 시 현재 repo의 미해결 defer 상세에 더해, **등록된 다른 repo들의 미해결 defer 요약**을 한 줄로 환기한다.
 
+`gbc init`을 하면 그 repo는 **레지스트리에 자동 등록**된다(opt-out: `gbc init --no-register`). 따라서 보통은 아래를 따로 칠 필요 없이, init한 repo들이 서로의 미완 작업을 자동으로 환기한다. 수동 관리가 필요할 때만:
+
 ```bash
 # 감시할 repo를 글로벌 레지스트리(~/.gbc/repos.json)에 등록 (각 repo에서 1회, 또는 경로 지정)
 gbc repos add                 # 현재 폴더
@@ -182,10 +208,29 @@ gbc repos list                # 등록 현황 + 각 repo 미해결 defer 수
 
 > CLI에서 repo별 alias(`alias cc-x='cd <dir> && claude'`)를 쓴다면, alias에 `gbc repos add . 2>/dev/null;`를 끼워 **여는 repo를 자동 등록**할 수 있다(등록은 멱등).
 
+### 게이트 건강성 롤업 (`gbc repos list`)
+
+"회사 repo에서 게이트가 조용히 안 먹는다"를 한 명령으로 진단한다. `gbc repos list`는 각 등록 repo의 `.claude/settings.json`을 읽어 hook 등록 상태를 표시한다:
+
+```
+📁 등록된 repo 3개:
+  [○깨끗] /path/to/healthy
+  [○깨끗] /path/to/old        ⚠️SessionStart누락        ← 0.2.1 이하 init 코호트
+  [●미해결2] /path/to/broken  ⚠️게이트hook부재          ← PreToolUse 게이트가 아예 없음(조용히 죽음)
+
+⚠️ 게이트 hook 부재/SessionStart 누락 repo는 해당 repo에서 'gbc init --yes' 재실행으로 복구하세요.
+   (크로스-repo는 hook *등록 여부*만 검사 — 명령 freshness[설치경로 의존]는 각 repo에서 'gbc status'로 확인)
+```
+
+- **검사 대상**: 게이트 hook(`PreToolUse`)·SessionStart hook의 **등록 여부**. 둘 다 cliPath 없이 결정론적으로 판정된다.
+- **검사 안 하는 것**: hook 명령의 *freshness*(구버전 prefix 등). gbc는 단일 전역 설치지만 각 repo의 hook 명령엔 설치 시점의 절대경로가 구워져 있어, 현재 런타임 경로로 타 repo를 stale 판정하면 false-positive가 난다. 명령이 구식인지는 그 repo에서 `gbc status`로 확인한다(진짜 사후대조 freshness는 A-mode 과제).
+
 ## 계측 (M1~M3)
 
 게이트는 모든 결정을 `.gbc/events.jsonl`(append-only, 메타데이터만 — 코드 본문 미기록)에 기록한다. `gbc metrics`로 집계를 본다. 끄려면 `GBC_NO_METRICS=1`.
 
+여러 repo의 게이트 ROI를 한 번에 보려면 `gbc metrics --all` — 등록된 repo들의 `events.jsonl`을 병합 집계한다. 병합 시 각 이벤트의 `specHash`를 repo 경로로 태깅해 **repo간 boilerplate 명세 해시 충돌**을 막는다(태깅 없이 합치면 한 repo의 통과 뒤 다른 repo의 변이가 M1 churn으로 오집계된다; M2/M3는 세션 UUID 키라 원래 안전). symlink로 등록된 경로는 거부한다(등록 경로 밖 임의 디렉터리 읽기 차단).
+
 | 지표 | 관측 | B-모드 신뢰도 |
 |---|---|---|
 | **M2** 게이트 적중 vs 도중발견 | 차단이 잡은 누락 케이스 수 vs `defer add`로 도중 등록된 수 | **강** (defer-registry와 1:1) |
@@ -194,11 +239,31 @@ gbc repos list                # 등록 현황 + 각 repo 미해결 defer 수
 
 > ⚠️ **진짜 M1**(통과 후 시나리오 위반율)은 게이트가 엔진 출력을 채점하는 **사후 대조**가 필요하다 — 이는 후속 A(standalone) 모드 영역이다. B-커널(hook)은 churn 약신호만 관측한다. `events.jsonl` 원시 로그는 그때 그대로 재사용된다.
 
+## 판정 드리프트 회귀락 (`gbc gate snapshot`)
+
+게이트 판정은 LLM(haiku)이라 **모델 업그레이드·프롬프트 수정·SDK 변경**이 같은 편집에 대한 통과/차단을 조용히 바꿀 수 있다. 골든셋은 실제 판정을 캡처해두고 나중에 재판정해 그 드리프트를 잡는다.
+
+```bash
+gbc gate snapshot on          # 캡처 모드 ON (opt-in)
+# … 평소처럼 작업 — judge가 평가하는 편집이 .gbc/golden.json에 기록된다 …
+gbc gate snapshot list        # 캡처된 케이스 확인 (판정·도구·편집 머리말)
+gbc gate snapshot off         # 캡처 종료
+
+# 나중에(모델/gbc 업그레이드 후 등) 드리프트 점검:
+gbc gate snapshot replay              # 각 케이스를 temp 0으로 재판정, 캡처 시점과 비교
+gbc gate snapshot replay --samples 5  # 케이스당 5회 모달 판정(잔여 비결정 흡수)
+```
+
+- **하드 신호 = 판정 뒤집힘(pass↔block)만.** 하나라도 뒤집히면 `replay`는 **exit 1**(로컬 pre-flight 게이트로 사용 가능). `missing[]` 변화는 LLM 자유서술이라 정보용으로만 표시하고 절대 실패시키지 않는다.
+- **결정성**: replay는 judge를 `temperature 0`으로 재실행한다(핫패스 게이트는 불변). `claude -p` 폴백 트랜스포트는 temperature 핀을 지원하지 않아 best-effort다 — 직접 API 키가 있을 때 가장 안정적. temp 0도 bit-stable은 아니므로 `--samples N`으로 다수결 모달을 쓸 수 있다.
+- **캡처 시점**: judge가 *실제로 평가한* cache-miss 편집만 기록된다(cached-skip·fail-open 제외). 특정 편집을 캡처하려면 `gbc gate reset` 후 그 편집을 수행한다.
+- **⚠️ 로컬 전용(privacy)**: `golden.json`은 정규화된 **편집 본문**을 담는다 — `events.jsonl`이 불변식으로 절대 저장하지 않는 내용이다. `.gbc/`는 gitignore이므로 이 골든셋은 **로컬 드리프트 점검**이지 커밋되는 CI 스위트가 아니다. 공유 CI로 쓰려면 편집 본문을 커밋하는 privacy 트레이드오프를 명시적으로 감수해야 한다.
+
 ## 정직한 한계
 
 - 사후 대조가 아닌 **구현 전 게이트**다 — "도중 탈선"은 못 잡는다(설계상 후속 C 영역).
 - 판정은 LLM이라 100% 아니다. **사람이 변이 전 케이스를 리뷰/편집하는 pause**가 진짜 가치다.
-- MVP scope = **B-커널**(CC-native hook + defer-registry + /gate). standalone TUI·추출 모드는 후속 A(public). 계측은 B-모드 관측 프록시(M1~M3)까지 구현됨(위 [계측](#계측-m1m3)).
+- scope = **B-커널**(CC-native hook + defer-registry + /gate) + 그 위 운영층: 누락 케이스 일괄 분류·크로스-repo 가시성/건강성·판정 드리프트 회귀락·관측 계측(M1~M3). **standalone TUI·엔진 래핑 추출 모드·진짜 사후대조 M1**은 후속 A(public) 영역이다 — B-커널은 hook-게스트라 "구현 전" 게이트일 뿐, 통과 후 실제 산출물을 채점하지 않는다.
 - **검증 상태**: 게이트 판정 품질은 **양 트랜스포트 모두 회귀 8/8(FP0 FN0)**. 직접 API(haiku) 경로 실측 **평균 1.7s**(1.1–2.5s), claude -p 폴백 ~18s. 직접 API용 게이트 프롬프트는 최소화하면서 정확도를 유지하도록 "동작 편집 vs 비-동작 편집" 2단계 분류로 튜닝했다(`ANTHROPIC_API_KEY=… node dist/eval/regression.js`로 재현).
 - **fail-open**: 판정 호출이 실패하면(키 오류·네트워크 등) 게이트는 안전하게 통과시킨다(개발 차단 방지). 단 fail-open 통과는 작업단위 캐시에서 제외되고(다음 편집 재판정), `systemMessage` 경고 + `.gbc/failopen.log` 계측으로 드러난다(조용한 무력화 방지).
 

package/dist/cli.js

@@ -4,17 +4,20 @@ import { fileURLToPath } from "node:url";
 import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { spawnSync } from "node:child_process";
-import { mkdirSync, existsSync, readFileSync, writeFileSync, copyFileSync, } from "node:fs";
+import { mkdirSync, existsSync, readFileSync, writeFileSync, copyFileSync, lstatSync, } from "node:fs";
 import { runPreToolUse, runStop, runSessionStart } from "./hook.js";
 import { loadPlanSpec, computeSpecHash, addSpecCase, readSpecCases, clearSpec } from "./spec.js";
 import { loadState, resetGate } from "./state.js";
 import { addDefer, loadDefers, resolveDefer, startDefer, reopenDefer } from "./defer.js";
 import { loadRepos, addRepo, removeRepo } from "./repos.js";
-import { isStopHintMuted, setStopHintMuted } from "./config.js";
+import { readPendingReview, clearPendingReview, resolveRefs } from "./review.js";
+import { isStopHintMuted, setStopHintMuted, isGoldenCapture, setGoldenCapture } from "./config.js";
+import { loadGolden, clearGolden, diffVerdict, summarizeReplay } from "./golden.js";
 import { selectedTransport } from "./judge.js";
-import { buildPreCommand, normalizeHooks, ensureSessionStartHook, DEV_PLACEHOLDER } from "./install.js";
+import { buildPreCommand, normalizeHooks, ensureSessionStartHook, DEV_PLACEHOLDER, assessRepoHealth } from "./install.js";
+import { readProjectSettings } from "./notice.js";
 import { isCacheStale, readVersionCache, refreshVersionCache, } from "./version.js";
-import { logEvent, parseEvents, computeMetrics } from "./metrics.js";
+import { logEvent, parseEvents, computeMetrics, tagEventsWithRepo } from "./metrics.js";
 const CLI_PATH = fileURLToPath(import.meta.url);
 const PKG_ROOT = join(dirname(CLI_PATH), ".."); // dist/cli.js → 패키지 루트
 /** 설치된 패키지 버전(업데이트 안내 비교 기준). 읽기 실패 시 "". */
@@ -69,6 +72,8 @@ async function cmdInit(args) {
     // --dev: hook 명령에 절대경로(CLI_PATH) 대신 ${CLAUDE_PROJECT_DIR} placeholder를 굽는다.
     // geobuke-code 자기 repo 도그푸딩 전용(dist 위치가 옮겨다녀도 안 깨짐). 기본(false)은 절대경로.
     const dev = args.includes("--dev");
+    // --no-register: 크로스-repo 레지스트리(~/.gbc/repos.json) 자동등록 opt-out(기본=등록).
+    const noRegister = args.includes("--no-register");
     const hookPath = dev ? DEV_PLACEHOLDER : CLI_PATH;
     const claudeDir = join(cwd, ".claude");
     const settingsPath = join(claudeDir, "settings.json");
@@ -82,6 +87,7 @@ async function cmdInit(args) {
      - 기존 settings.json 있으면 백업: settings.json.bak-<시각>
   2) ${join(claudeDir, "skills")} 에 ${skillNames.map((n) => `/${n}`).join(", ")} 스킬 설치
   3) hook 명령: ${buildPreCommand(hookPath)}${dev ? "  (--dev: ${CLAUDE_PROJECT_DIR} placeholder)" : ""}
+  4) ${noRegister ? "크로스-repo 레지스트리 등록 생략 (--no-register)" : "이 repo를 크로스-repo 레지스트리(~/.gbc/repos.json)에 등록 (opt-out: --no-register)"}
 ${hasApiKey()
             ? "     (~/.gbc/api-key 감지됨 → 빠른 haiku API 경로로 동작)"
             : "     (~/.gbc/api-key 없음 → claude -p 폴백. 빠른 경로 원하면 키 파일 생성)"}
@@ -155,6 +161,20 @@ ${hasApiKey()
         ? "  (ANTHROPIC_API_KEY 설정 시 직접 API로 ~1–3s, 미설정 시 claude -p 폴백 ~13–20s)"
         : ""}
    계획 명세는 .gbc/spec.md 에 작성하세요(없으면 시나리오 미지정으로 차단 → 도출·검증 루프 발동: 에이전트가 요청에서 시나리오를 도출해 사용자 검증 후 'gbc spec add'로 등록).`);
+    // 크로스-repo 레지스트리 자동등록(~/.gbc/repos.json, 멱등 dedup) — 등록된 타 repo의 미해결
+    // defer를 SessionStart에 환기(0.2.9 buildCrossRepoHint)하려면 레지스트리가 차 있어야 한다.
+    // 이 repo 자신은 cwd 제외라 즉시 가시성 0이지만, N개 누적되면 서로의 잔여를 환기(passive fill).
+    // ~/.gbc append만(별 네임스페이스) → 프로젝트 .claude/settings.json 미접촉(install-safe 보존).
+    // --no-register로 opt-out. 등록 실패는 init 본체를 깨지 않는다(best-effort).
+    if (!noRegister) {
+        try {
+            addRepo(cwd);
+            console.log(`  + 크로스-repo 레지스트리 등록 (~/.gbc/repos.json, opt-out: --no-register)`);
+        }
+        catch {
+            /* 레지스트리 쓰기 실패는 무시(fail-silent) */
+        }
+    }
     // 설치 직후 버전 캐시 seed — 신버전 안내(①)가 "설치만 하고 init 안 한" 코호트에도
     // 신뢰성 있게 동작하도록(SessionStart 없는 환경의 유일한 seed 지점일 수 있음). best-effort.
     try {
@@ -299,30 +319,227 @@ function cmdSpec(args) {
     }
 }
 // ---------- gbc gate ----------
-function cmdGate(args) {
+async function cmdGate(args) {
+    const cwd = process.cwd();
     if (args[0] === "reset") {
-        const cwd = process.cwd();
         logCli(cwd, "gate-reset", curHash(cwd));
         resetGate(cwd);
         console.log("🐢 작업단위 게이트 리셋 — 다음 편집에서 다시 발동합니다.");
     }
+    else if (args[0] === "review") {
+        cmdGateReview(cwd, args.slice(1));
+    }
+    else if (args[0] === "snapshot") {
+        await cmdGateSnapshot(cwd, args.slice(1));
+    }
     else {
-        console.error("사용: gbc gate reset");
+        console.error("사용: gbc gate <reset|review|snapshot>");
         process.exit(1);
     }
 }
+/**
+ * 골든셋 캡처 + 판정 드리프트 회귀락(A2). 캡처는 opt-in(hook이 judge 출력을 .gbc/golden.json에 로컬
+ * 저장 — edit 본문 포함이라 gitignore·로컬 pre-flight 전용). replay는 각 케이스를 judge temp 0으로
+ * 재판정해 캡처 시점과 비교, 판정 뒤집힘(decisionFlip)이 있으면 exit 1(로컬 회귀 게이트).
+ */
+async function cmdGateSnapshot(cwd, args) {
+    const sub = args[0];
+    if (sub === "on") {
+        setGoldenCapture(cwd, true);
+        console.log("🐢 골든셋 캡처 ON — 이제 judge가 평가하는 cache-miss 편집이 .gbc/golden.json에 기록됩니다.\n" +
+            "   ⚠️ 캡처되는 편집 본문은 'gbc gate snapshot replay' 시 Anthropic API(haiku)로 전송됩니다.\n" +
+            "   (특정 편집을 캡처하려면 'gbc gate reset' 후 그 편집 수행. 끄기: gbc gate snapshot off)");
+    }
+    else if (sub === "off") {
+        setGoldenCapture(cwd, false);
+        console.log("🐢 골든셋 캡처 OFF.");
+    }
+    else if (sub === "status" || sub === undefined) {
+        const cases = loadGolden(cwd);
+        console.log(`🐢 골든셋 — 캡처 ${isGoldenCapture(cwd) ? "ON" : "OFF"} · 케이스 ${cases.length}건 (.gbc/golden.json, 로컬 전용)`);
+    }
+    else if (sub === "list") {
+        const cases = loadGolden(cwd);
+        if (cases.length === 0) {
+            console.log("골든셋 비어 있음. 'gbc gate snapshot on'으로 캡처를 시작하세요.");
+            return;
+        }
+        console.log(`🐢 골든셋 ${cases.length}건:`);
+        for (const c of cases) {
+            const head = c.edit.replace(/\s+/g, " ").trim().slice(0, 60);
+            console.log(`  [${c.expected.verdict}] ${c.tool} ${c.id}  "${head}…"`);
+        }
+    }
+    else if (sub === "clear") {
+        clearGolden(cwd);
+        console.log("🐢 골든셋 비움.");
+    }
+    else if (sub === "replay") {
+        await cmdGateSnapshotReplay(cwd, args.slice(1));
+    }
+    else {
+        console.error("사용: gbc gate snapshot <on|off|status|list|clear|replay>");
+        process.exit(1);
+    }
+}
+/** golden 케이스를 judge temp 0으로 재판정해 드리프트를 본다. --samples N=모달 판정(잔여 노이즈 흡수). */
+async function cmdGateSnapshotReplay(cwd, args) {
+    const cases = loadGolden(cwd);
+    if (cases.length === 0) {
+        console.log("골든셋 비어 있음 — replay할 케이스 없음. 'gbc gate snapshot on' 후 편집을 캡처하세요.");
+        return;
+    }
+    const si = args.indexOf("--samples");
+    let samples = si >= 0 ? Math.max(1, Number.parseInt(args[si + 1] ?? "1", 10) || 1) : 1;
+    // 모달 판정은 동수(tie)면 pass로 떨어져 block-기대 케이스의 드리프트를 *놓친다* → 짝수면 홀수로
+    // 올려 tie를 원천 제거(다수결은 본래 홀수 표본을 요구). 기본 1은 홀수라 무영향.
+    if (samples % 2 === 0) {
+        console.log(`  (--samples ${samples}=짝수 → 동수 방지 위해 ${samples + 1}로 조정)`);
+        samples += 1;
+    }
+    const { judge } = await import("./judge.js");
+    console.log(`🐢 골든셋 replay — ${cases.length}건${samples > 1 ? ` · ${samples}-sample 모달` : ""} (judge temp 0; CLI 폴백은 best-effort)`);
+    const outcomes = [];
+    for (const c of cases) {
+        // N-sample 모달 판정 — temp 0도 bit-stable 아니라, 다수결로 잔여 비결정을 흡수한다.
+        const votes = { pass: 0, block: 0 };
+        let lastMissing = [];
+        for (let i = 0; i < samples; i++) {
+            const v = await judge(c.spec, c.edit, c.defers, { temperature: 0 });
+            votes[v.verdict]++;
+            lastMissing = v.missing;
+        }
+        const actual = votes.block > votes.pass ? "block" : "pass";
+        const diff = diffVerdict(c.expected, { verdict: actual, missing: lastMissing });
+        outcomes.push({ id: c.id, tool: c.tool, expected: c.expected.verdict, actual, diff });
+        const mark = diff.decisionFlip ? "❌FLIP" : diff.missingChanged ? "·missing변화" : "✓";
+        console.log(`  ${mark} ${c.tool} ${c.id}: ${c.expected.verdict}→${actual}`);
+    }
+    const s = summarizeReplay(outcomes);
+    console.log(`\n결과: 일치 ${s.matched}/${s.total} · 판정뒤집힘 ${s.flips} · (정보용 missing변화 ${s.missingOnly})`);
+    if (s.flips > 0) {
+        console.log(`❌ 드리프트 감지 — ${s.flips}건 판정 뒤집힘. 모델/프롬프트/SDK 변화로 게이트 판정이 바뀌었습니다.`);
+        process.exit(1);
+    }
+    console.log("✅ 드리프트 없음 — 캡처 시점과 동일 판정.");
+}
+/** `gbc gate review` 인자에서 --spec/--defer 뒤의 비-플래그 토큰을 각각 모아 ref 문자열로. */
+function parseReviewArgs(args) {
+    let cur = null;
+    const spec = [];
+    const defer = [];
+    for (const a of args) {
+        if (a === "--spec") {
+            cur = "spec";
+        }
+        else if (a === "--defer") {
+            cur = "defer";
+        }
+        else if (a.startsWith("--")) {
+            cur = null; // 알 수 없는 플래그 — 수집 중단
+        }
+        else if (cur === "spec") {
+            spec.push(a);
+        }
+        else if (cur === "defer") {
+            defer.push(a);
+        }
+    }
+    return { specRefs: spec.join(" "), deferRefs: defer.join(" ") };
+}
+/**
+ * 게이트 block이 도출한 펜딩 누락 케이스를 사람-승인 체크리스트로 일괄 분류한다(A1).
+ * - 인자 없음: 번호 체크리스트만 표시(검토 모드).
+ * - --spec/--defer refs: 승인→spec.md 등록 / 미룸→defer 등록(겹치면 spec 우선), 후 펜딩 비움.
+ */
+function cmdGateReview(cwd, args) {
+    const pending = readPendingReview(cwd);
+    if (!pending || pending.missing.length === 0) {
+        console.log("🐢 검토할 펜딩 누락 케이스가 없습니다. (게이트 block 시 도출된 누락 케이스가 여기 모입니다)");
+        return;
+    }
+    const { specRefs, deferRefs } = parseReviewArgs(args);
+    // 분류 ref 없음 = 체크리스트만(검토 모드)
+    if (specRefs === "" && deferRefs === "") {
+        console.log(`🐢 펜딩 누락 케이스 ${pending.missing.length}건 (사유: ${pending.reason} · 소스: ${pending.source}):`);
+        pending.missing.forEach((c, i) => console.log(`  ${i + 1}. ${c}`));
+        console.log(`→ 분류: gbc gate review --spec <번호|텍스트|all> --defer <번호|텍스트|all>\n` +
+            `  (승인→spec.md / 미룸→defer. 겹치면 spec 우선. 분류 후 펜딩은 비워지고, 재편집 시 등록 기준으로 재판정)`);
+        return;
+    }
+    const { toSpec, toDefer } = resolveRefs(pending.missing, specRefs, deferRefs);
+    if (toSpec.length === 0 && toDefer.length === 0) {
+        console.error("ref가 어떤 펜딩 케이스에도 매칭되지 않았습니다 — 'gbc gate review'로 번호를 확인하세요.");
+        process.exit(1);
+    }
+    const beforeHash = curHash(cwd); // 변이 전 해시 = 게이트된 작업단위와 상관(M1 churn)
+    for (const c of toSpec) {
+        addSpecCase(cwd, c);
+        logCli(cwd, "spec-add", beforeHash);
+    }
+    for (const c of toDefer) {
+        addDefer(cwd, c);
+        logCli(cwd, "defer-add", beforeHash);
+    }
+    clearPendingReview(cwd);
+    if (toSpec.length > 0)
+        console.log(`🐢 명세 등록 ${toSpec.length}건: ${toSpec.join(", ")}`);
+    if (toDefer.length > 0)
+        console.log(`🐢 미룸 등록 ${toDefer.length}건: ${toDefer.join(", ")}`);
+    console.log("→ 검토 완료(펜딩 비움). 같은 편집을 재시도하면 등록된 케이스 기준으로 재판정됩니다.");
+}
 // ---------- gbc metrics ----------
 function cmdMetrics(args) {
     const cwd = process.cwd();
-    const eventsPath = join(cwd, ".gbc", "events.jsonl");
-    const raw = existsSync(eventsPath) ? readFileSync(eventsPath, "utf8") : "";
-    const m = computeMetrics(parseEvents(raw));
+    const all = args.includes("--all");
+    // --all: 등록된 각 repo의 events.jsonl을 repo경로로 태깅 후 병합(specHash 해시충돌 차단).
+    // M1 churn축은 specHash 단독키라, 태깅 없이 합치면 repo간 boilerplate spec 해시가 충돌해
+    // 한 repo의 통과 뒤 다른 repo의 변이가 churn으로 오집계된다(M2/M3는 session-UUID 키라 안전).
+    let events;
+    let scope;
+    let source;
+    if (all) {
+        const merged = [];
+        let included = 0;
+        let skipped = 0;
+        for (const repo of loadRepos()) {
+            const abs = resolve(repo);
+            try {
+                // 단일 lstatSync로 symlink 거부 — existsSync+lstatSync 분리는 TOCTOU 경합창을 연다(보안검토 W1).
+                // lstat은 링크를 따라가지 않아 symlink면 isDirectory()=false, 부재면 throw→catch로 skip.
+                if (!lstatSync(abs).isDirectory()) {
+                    skipped++;
+                    continue;
+                }
+                const p = join(abs, ".gbc", "events.jsonl");
+                if (!existsSync(p)) {
+                    skipped++;
+                    continue;
+                }
+                merged.push(...tagEventsWithRepo(parseEvents(readFileSync(p, "utf8")), abs));
+                included++;
+            }
+            catch {
+                skipped++; // repo별 읽기 실패는 조용히 skip(fail-silent)
+            }
+        }
+        events = merged;
+        scope = `전체 ${included}개 repo 병합${skipped ? ` (${skipped}개 skip: 부재/이벤트없음)` : ""}`;
+        source = "등록 repo들의 .gbc/events.jsonl(repo 태깅 병합)";
+    }
+    else {
+        const eventsPath = join(cwd, ".gbc", "events.jsonl");
+        events = parseEvents(existsSync(eventsPath) ? readFileSync(eventsPath, "utf8") : "");
+        scope = cwd;
+        source = ".gbc/events.jsonl";
+    }
+    const m = computeMetrics(events);
     if (args.includes("--json")) {
         console.log(JSON.stringify(m, null, 2));
         return;
     }
-    console.log(`🐢 거북이 게이트 계측 — ${cwd}
-  이벤트 총 ${m.totalEvents}건  (.gbc/events.jsonl)
+    console.log(`🐢 거북이 게이트 계측 — ${scope}
+  이벤트 총 ${m.totalEvents}건  (${source})
 
   [M3] 재호출/iteration — 작업단위당 edit 반복
     작업단위 ${m.m3.workUnits} · 총 edit ${m.m3.totalEdits} · 평균 ${m.m3.avgEditsPerUnit}/단위 · 최대 ${m.m3.maxEditsPerUnit} · 반복(>1)단위 ${m.m3.multiEditUnits}
@@ -400,12 +617,48 @@ function cmdRepos(args) {
             return;
         }
         console.log(`📁 등록된 repo ${repos.length}개:`);
+        let anyStale = false;
         for (const r of repos) {
-            const exists = existsSync(r);
-            const gated = exists && existsSync(join(r, ".gbc"));
+            // 단일 lstatSync로 부재/symlink를 한 번에 판정 — existsSync+lstatSync 분리는 TOCTOU 경합창을
+            // 연다(보안검토 W1). lstat은 링크를 안 따라가 symlink면 isDir=false; 부재/권한오류는 throw→
+            // exists=false. gated가 true여야만 loadDefers·readProjectSettings로 그 경로를 읽으므로, 이
+            // 가드가 두 외부 읽기를 함께 막는다(cmdMetrics --all·buildCrossRepoHint와 동일 표준).
+            let exists = false;
+            let isDir = false;
+            try {
+                isDir = lstatSync(r).isDirectory();
+                exists = true;
+            }
+            catch {
+                /* 부재/권한오류 → exists=false */
+            }
+            const gated = isDir && existsSync(join(r, ".gbc"));
             const unresolved = gated ? loadDefers(r).filter((d) => d.status !== "resolved").length : 0;
-            const mark = !exists ? "✗부재" : !gated ? "·gbc없음" : unresolved ? `●미해결${unresolved}` : "○깨끗";
-            console.log(`  [${mark}] ${r}`);
+            const mark = !exists
+                ? "✗부재"
+                : !isDir
+                    ? "⚠️심링크거부"
+                    : !gated
+                        ? "·gbc없음"
+                        : unresolved
+                            ? `●미해결${unresolved}`
+                            : "○깨끗";
+            // 게이트 건강성(B1) — gbc 프로젝트면 hook 등록 상태로 '게이트 조용히 죽음/구식 코호트'를 표면화.
+            // (회사 repo 게이트 미작동 미스터리 차단). 명령 freshness는 cliPath 의존이라 크로스-repo 미검출.
+            let health = "";
+            if (gated) {
+                const h = assessRepoHealth(readProjectSettings(r), true);
+                const flags = [h.gateDead ? "⚠️게이트hook부재" : "", h.missingSession ? "⚠️SessionStart누락" : ""].filter(Boolean);
+                if (flags.length) {
+                    health = "  " + flags.join(" ");
+                    anyStale = true;
+                }
+            }
+            console.log(`  [${mark}] ${r}${health}`);
+        }
+        if (anyStale) {
+            console.log("\n⚠️ 게이트 hook 부재/SessionStart 누락 repo는 해당 repo에서 'gbc init --yes' 재실행으로 복구하세요.");
+            console.log("   (크로스-repo는 hook *등록 여부*만 검사 — 명령 freshness[설치경로 의존]는 각 repo에서 'gbc status'로 확인)");
         }
     }
     else {
@@ -416,7 +669,8 @@ function usage() {
     console.log(`🐢 gbc — 거북이코드 구현-전 게이트
 
 사용:
-  gbc init [--yes]                    프로젝트에 hook + /gate · /gbc-mute 스킬 설치
+  gbc init [--yes] [--no-register]    프로젝트에 hook + /gate · /gbc-mute 스킬 설치
+                                      (--no-register: 크로스-repo 레지스트리 자동등록 생략)
   gbc update [--dry-run]              전역 최신 설치 + 현재 프로젝트 재init (한방 갱신)
   gbc status                          게이트 상태 + 로드된 명세 확인
   gbc defer add "<케이스>"             케이스를 명시적으로 미루기 (→ open)
@@ -430,7 +684,14 @@ function usage() {
   gbc spec show                       등록된 케이스 목록
   gbc spec clear                      명세 비우기(작업단위 종료)
   gbc gate reset                      작업단위 게이트 리셋
-  gbc metrics [--json]                계측 리포트(M1~M3, B-모드 관측 프록시)
+  gbc gate review                     block이 도출한 누락 케이스 체크리스트 보기
+  gbc gate review --spec <ref> --defer <ref>
+                                      누락 케이스 일괄 분류(승인→spec / 미룸→defer)
+  gbc gate snapshot <on|off|status|list|clear>
+                                      골든셋 캡처 토글·상태(판정 드리프트 회귀락, 로컬 전용)
+  gbc gate snapshot replay [--samples N]
+                                      골든 케이스 재판정(temp 0)·드리프트 시 exit 1
+  gbc metrics [--all] [--json]        계측 리포트(M1~M3, B-모드 관측 프록시; --all=등록 repo 병합)
   gbc repos add [경로]                크로스-repo 레지스트리에 추가(생략 시 현재 폴더)
   gbc repos list                      등록된 repo + 미해결 defer 수
   gbc repos remove [경로]             레지스트리에서 제거

package/dist/config.js

@@ -16,3 +16,13 @@ export function setStopHintMuted(cwd, muted) {
     cfg.stopHintMuted = muted;
     writeJson(configPath(cwd), cfg);
 }
+/** 골든셋 캡처 모드인지. 파일/키 부재 시 false(기본=캡처 안 함). */
+export function isGoldenCapture(cwd) {
+    return readConfig(cwd).captureGolden === true;
+}
+/** 골든셋 캡처 모드 토글을 영속 저장(수동 off 전까지 유지). */
+export function setGoldenCapture(cwd, on) {
+    const cfg = readConfig(cwd);
+    cfg.captureGolden = on;
+    writeJson(configPath(cwd), cfg);
+}

package/dist/golden.js

@@ -0,0 +1,45 @@
+// 골든셋 캡처 + 게이트 판정 드리프트 회귀락 (A2). 순수 코어 — 비교/해시/집계는 결정론이라
+// 단위테스트 대상. judge 재실행(LLM·네트워크)·캡처 훅·CLI 출력은 비결정이라 여기 없음.
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { gbcDir, readJson, writeJson } from "./store.js";
+/**
+ * tool+edit+spec의 안정 해시 — upsert 디둑 키. 널바이트 구분자로 필드 경계 모호성 차단
+ * (("a","bc") vs ("ab","c") 충돌 방지).
+ */
+export function goldenCaseId(tool, edit, spec) {
+    return createHash("sha256").update(`${tool}\x00${edit}\x00${spec}`).digest("hex").slice(0, 16);
+}
+/** 기대 vs 재판정 비교. decisionFlip=하드, missingChanged=정보용. */
+export function diffVerdict(expected, actual) {
+    const decisionFlip = expected.verdict !== actual.verdict;
+    const norm = (xs) => [...new Set(xs)].sort();
+    const em = norm(expected.missing);
+    const am = norm(actual.missing);
+    const missingChanged = em.length !== am.length || em.some((v, i) => v !== am[i]);
+    return { decisionFlip, missingChanged, match: !decisionFlip && !missingChanged };
+}
+/** id 디둑 upsert — 같은 id면 교체(최신 expected), 없으면 추가. */
+export function upsertGolden(cases, c) {
+    return [...cases.filter((x) => x.id !== c.id), c];
+}
+/** replay 결과 집계 — 플립/정보용변화/일치 카운트 + 플립 케이스 목록. */
+export function summarizeReplay(outcomes) {
+    const flipped = outcomes.filter((o) => o.diff.decisionFlip);
+    const matched = outcomes.filter((o) => o.diff.match).length;
+    const missingOnly = outcomes.filter((o) => !o.diff.decisionFlip && o.diff.missingChanged).length;
+    return { total: outcomes.length, matched, flips: flipped.length, missingOnly, flipped };
+}
+// ---------- IO (ST-A2-2에서 구현) ----------
+function goldenPath(cwd) {
+    return join(gbcDir(cwd), "golden.json");
+}
+export function loadGolden(cwd) {
+    return readJson(goldenPath(cwd), []);
+}
+export function addGoldenCase(cwd, c) {
+    writeJson(goldenPath(cwd), upsertGolden(loadGolden(cwd), c));
+}
+export function clearGolden(cwd) {
+    writeJson(goldenPath(cwd), []);
+}

package/dist/hook.js

@@ -5,10 +5,12 @@ import { isGatedTool, normalizeEdit } from "./normalize.js";
 import { loadPlanSpec, computeSpecHash } from "./spec.js";
 import { isGated, markGated } from "./state.js";
 import { activeDeferItems, loadDefers } from "./defer.js";
-import { isStopHintMuted } from "./config.js";
+import { isStopHintMuted, isGoldenCapture } from "./config.js";
 import { loadRepos } from "./repos.js";
+import { writePendingReview } from "./review.js";
+import { addGoldenCase, goldenCaseId } from "./golden.js";
 import { readProjectSettings, buildUpdateNotice, wasNotified, markNotified } from "./notice.js";
-import { isCacheStale, readVersionCache, refreshVersionCache } from "./version.js";
+import { isCacheStale, readVersionCache, refreshVersionCache, shouldRefreshCache, } from "./version.js";
 import { appendFileSync, existsSync, lstatSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { gbcDir } from "./store.js";
@@ -27,9 +29,11 @@ export function buildBlockReason(verdict, specEmpty, source) {
             `사용자 승인 없이 자동 등록하지 마세요. (명세 소스: ${source})`);
     }
     const missingLine = verdict.missing.length > 0 ? `\n누락(침묵): ${verdict.missing.join(", ")}` : "";
+    // 누락 케이스는 .gbc/pending-review.json에 기록돼 있어 'gbc gate review'로 번호 체크리스트
+    // 일괄 분류(승인→spec / 미룸→defer)가 가능하다. 개별 처리(직접 구현·gbc defer add)도 유효.
     return (`🐢 거북이 게이트 — ${verdict.reason}${missingLine}\n` +
-        `→ 지금 이 변경에서 다루거나, 의도적으로 미룰 거면 'gbc defer add "<케이스>"'로 명시 등록 후 진행하세요.` +
-        ` (명세 소스: ${source})`);
+        `→ 누락 케이스를 'gbc gate review'로 한 번에 분류(승인→spec / 미룸→defer)하거나, 지금 이 변경에서 직접 다루세요.` +
+        ` 개별로 미룰 거면 'gbc defer add "<케이스>"'. (명세 소스: ${source})`);
 }
 /**
  * pass verdict를 작업단위 캐시(markGated)에 넣어도 되는가.
@@ -142,13 +146,46 @@ export async function runPreToolUse(ctx) {
             tool: toolName,
             decision: "cached",
         });
+        // 업데이트 안내(있으면)를 cached-skip에서도 노출 — 평상 작업은 대부분 통과된 작업단위라
+        // 이 경로가 가장 흔하다. 여기서 빠지면 보이는 배너(PreToolUse systemMessage)가 거의 안 떴음
+        // (0.2.x 가시성 갭). maybeUpdateNotice는 세션당 1회 dedup이라 노이즈 없음(매 세션 첫 편집 1회).
+        // permissionDecision 없음 → cached-pass 통과 동작 불변. 네트워크 없음(캐시만 읽음).
+        const cachedNotice = maybeUpdateNotice(cwd, session, ctx);
+        if (cachedNotice)
+            emit({ systemMessage: cachedNotice });
         process.exit(0);
     }
     // judge는 여기서만 동적 import (SDK lazy)
     const { judge } = await import("./judge.js");
     const editText = normalizeEdit(toolName, input.tool_input ?? {});
     const defers = activeDeferItems(cwd);
+    // ①신버전 캐시 자동 refresh(0.3.0) — 사용자가 'gbc status'를 안 쳐도 캐시가 최신이 되게.
+    // judge(네트워크·≥1.5s)와 *병렬*로만 건다 → 핫패스 지연 0. cache-miss(여기 = judge 도는
+    // 비-핫패스)에서만 stale일 때. cached-skip 핫패스엔 절대 네트워크 안 넣는다(0.2.7 원칙 보존).
+    // refreshVersionCache는 내부 fail-silent(reject 불가)라 judge 경로를 깨지 않는다.
+    const refreshP = shouldRefreshCache(Boolean(ctx?.cliPath)) ? refreshVersionCache() : null;
     const verdict = await judge(specText, editText, defers);
+    if (refreshP)
+        await refreshP; // judge 동안 이미 완료 — 이 편집의 notice가 갱신된 캐시를 읽도록
+    // 골든셋 캡처(A2, opt-in) — judge가 실제 평가한 cache-miss edit만, fail-open 제외(실판정 아님).
+    // editText(편집 본문)는 events.jsonl이 절대 저장 안 하는 내용 → 캡처는 .gbc/golden.json에 로컬만.
+    // 캡처 실패는 게이트를 막지 않는다(fail-silent). cached-skip 경로는 위에서 이미 return돼 도달 안 함.
+    if (!verdict.failOpen && isGoldenCapture(cwd)) {
+        try {
+            addGoldenCase(cwd, {
+                id: goldenCaseId(toolName, editText, specText),
+                at: nowIso(),
+                tool: toolName,
+                edit: editText,
+                spec: specText,
+                defers,
+                expected: { verdict: verdict.verdict, missing: verdict.missing, reason: verdict.reason },
+            });
+        }
+        catch {
+            /* 캡처 실패는 무시(fail-silent) */
+        }
+    }
     if (verdict.verdict === "pass") {
         // fail-open(판정 실패) 먼저 분기 — 빈-spec 정상 pass가 fail-open으로 오분류되지 않게.
         if (verdict.failOpen) {
@@ -195,6 +232,22 @@ export async function runPreToolUse(ctx) {
     // block: 사람 pause (ask 기본) — 사유가 사용자에게 표시됨
     // 시나리오 미지정(명세 빈약)과 침묵 누락을 다르게 안내한다.
     const reason = buildBlockReason(verdict, specText.trim() === "", source);
+    // 침묵-누락 케이스(missing[])를 펜딩-검토에 기록 → 'gbc gate review'가 번호 체크리스트로 회수.
+    // judge의 missing[]가 buildBlockReason prose로만 평탄화돼 사라지던 seam 보존(A1). missing 없으면
+    // (시나리오 미지정 등) 기록 안 함 = 검토할 케이스 없음. 쓰기 실패는 게이트를 깨지 않는다(fail-silent).
+    if (verdict.missing.length > 0) {
+        try {
+            writePendingReview(cwd, {
+                missing: verdict.missing,
+                reason: verdict.reason,
+                source,
+                at: nowIso(),
+            });
+        }
+        catch {
+            /* 펜딩 기록 실패는 무시 — 안내(reason)는 이미 미룸/직접처리 경로를 담고 있다 */
+        }
+    }
     logEvent(cwd, {
         at: nowIso(),
         session,

package/dist/install.js

@@ -79,6 +79,34 @@ export function hasSessionStartHook(settings) {
     }
     return false;
 }
+/**
+ * (read-only) PreToolUse 게이트 hook('hook pre-tool-use' 명령)이 등록돼 있는지 — cliPath 무관.
+ * hasStalePreToolUse가 *명령 freshness*(cliPath 의존)를 보는 반면, 이건 *존재 자체*만 본다.
+ * 크로스-repo 건강성 판정에 쓴다: 타 repo의 정식 cliPath를 알 수 없으므로(각 설치경로 상이) freshness는
+ * 검사 불가지만, '게이트 hook이 아예 없음'(=게이트 조용히 죽음)은 cliPath 없이도 결정론적으로 잡힌다.
+ */
+export function hasPreToolUseGate(settings) {
+    for (const entry of settings.hooks?.PreToolUse ?? []) {
+        for (const h of entry.hooks ?? []) {
+            if (h.command.includes("hook pre-tool-use"))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * 크로스-repo 게이트 건강성을 settings로 판정(cliPath 무관·결정론적). isGbcProject=false(.gbc 없음)면
+ * 게이트 대상이 아니라 둘 다 false. 명령 freshness(stale)는 *의도적으로* 검사하지 않는다 — 각 repo
+ * 설치경로가 달라 현재 런타임 cliPath로 타 repo를 stale 판정하면 false-positive가 된다(B1 트림 결정).
+ */
+export function assessRepoHealth(settings, isGbcProject) {
+    if (!isGbcProject)
+        return { gateDead: false, missingSession: false };
+    return {
+        gateDead: !hasPreToolUseGate(settings),
+        missingSession: !hasSessionStartHook(settings),
+    };
+}
 /**
  * SessionStart hook을 멱등 등록한다. matcher "startup|resume"로 신규 진입·재개에만 발화
  * (compact마다 반복 노이즈 방지). 이미 'hook session-start' 명령이 있으면 추가하지 않는다.

package/dist/judge.js

@@ -90,7 +90,7 @@ export function selectedTransport() {
     return resolveApiKey() ? "api" : "cli";
 }
 /** 직접 Anthropic API (haiku). SDK는 여기서만 lazy import → hook 핫패스 보호. */
-async function judgeViaApi(system, user) {
+async function judgeViaApi(system, user, temperature) {
     const mod = await import("@anthropic-ai/sdk");
     const Anthropic = mod.default;
     // 키를 코드에서 해석(env 또는 ~/.gbc/api-key)해 명시 전달 — 셸 주입 불필요(크로스플랫폼).
@@ -98,6 +98,9 @@ async function judgeViaApi(system, user) {
     const resp = await client.messages.create({
         model: MODEL,
         max_tokens: 1024,
+        // temperature는 replay(회귀락)에서만 0으로 핀해 결정성을 높인다. 핫패스는 undefined=API 기본
+        // (기존 판정 분포 보존). undefined면 키 자체를 안 보내 SDK 기본을 쓴다.
+        ...(temperature !== undefined ? { temperature } : {}),
         system,
         messages: [{ role: "user", content: user }],
     });
@@ -171,12 +174,13 @@ function judgeViaCliWin(system, user) {
  * 게이트 판정. ANTHROPIC_API_KEY 있으면 직접 API(빠름), 없으면 claude -p 폴백.
  * 실패 시 안전하게 pass(fail-open) — 게이트가 개발을 막아버리는 사고 방지.
  */
-export async function judge(planSpec, editText, defers = []) {
+export async function judge(planSpec, editText, defers = [], opts = {}) {
     const user = buildUserMessage(planSpec, editText, defers);
     const transport = selectedTransport();
     try {
+        // claude -p 폴백은 temperature 플래그가 없어 핀 불가 → CLI-transport replay는 best-effort.
         const raw = transport === "api"
-            ? await judgeViaApi(GATE_SYSTEM, user)
+            ? await judgeViaApi(GATE_SYSTEM, user, opts.temperature)
             : await judgeViaCli(GATE_SYSTEM, user);
         return parseVerdict(raw);
     }

package/dist/metrics.js

@@ -52,6 +52,15 @@ export function parseEvents(raw) {
     }
     return out;
 }
+/**
+ * 크로스-repo 집계용 — 비어있지 않은 specHash만 'repoTag::specHash'로 태깅한다. 빈 specHash("")는
+ * 센티넬(작업단위 식별 불가)이라 그대로 둬 computeMetrics의 교차세션 제외 가드를 유지한다. repo간
+ * 동일/boilerplate spec 해시가 firstPassAt·groupKey(session 없는 CLI 이벤트)에서 충돌해 churn을
+ * 교차오염시키는 것을 막는다(session-UUID 키인 M2/M3 hook 이벤트는 원래 안전).
+ */
+export function tagEventsWithRepo(events, repoTag) {
+    return events.map((e) => (e.specHash ? { ...e, specHash: `${repoTag}::${e.specHash}` } : e));
+}
 const M1_NOTE = "B-모드 약신호(churn proxy) — 진짜 M1(post-gate 시나리오 위반율)은 A-mode 사후대조 필요. " +
     "spec.md 비었을 때(specHash='')는 작업단위 식별 불가라 churn 집계에서 제외(교차세션 합산 방지).";
 /** 그룹핑 키: session 우선, 없으면 specHash(CLI 이벤트 상관) */

package/dist/repos.js

@@ -2,14 +2,21 @@
 // 글로벌(~/.gbc/repos.json)에 저장한다 — 크로스프로젝트라 project .gbc/가 아니라 홈.
 // (~/.gbc/api-key·~/.gbc/version-check.json과 동위. gbcDir(homedir())가 ~/.gbc를 보장.)
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { join, resolve, isAbsolute } from "node:path";
 import { gbcDir, readJson, writeJson } from "./store.js";
 function reposPath() {
     return join(gbcDir(homedir()), "repos.json");
 }
-/** 등록된 repo 절대경로 목록(없으면 []). */
+/**
+ * 등록된 repo 절대경로 목록(없으면 []). repos.json은 다른 프로세스가 수정할 수 있는 글로벌 파일이라
+ * 내용을 무조건 신뢰하지 않는다 — 비-문자열·비-절대경로 항목은 방어 필터한다(보안검토 W4). 절대경로만
+ * 통과시켜, 깨진/악의적 항목이 cmdMetrics --all 등의 읽기 대상이 되는 걸 차단한다(symlink 가드와 다층).
+ */
 export function loadRepos() {
-    return readJson(reposPath(), []);
+    const raw = readJson(reposPath(), []);
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((r) => typeof r === "string" && isAbsolute(r));
 }
 /** repo 등록(절대경로 정규화·멱등 dedup). 반환=등록 후 전체 목록. */
 export function addRepo(path) {

package/dist/review.js

@@ -0,0 +1,62 @@
+// 펜딩-검토 레이어 — 게이트 block이 도출한 침묵-누락 케이스(missing[])를 사람-승인 체크리스트로
+// 회수한다. judge의 {verdict, missing[]}가 buildBlockReason prose 평탄화로 버려지던 seam을 구조 보존:
+//   block 시 hook이 missing[]를 .gbc/pending-review.json에 기록 → `gbc gate review`가 번호 체크리스트로
+//   제시 → 사용자 분류(--spec refs / --defer refs)를 일괄 addSpecCase/addDefer로 적용 후 clear.
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { gbcDir, readJson, writeJson } from "./store.js";
+function pendingPath(cwd) {
+    return join(gbcDir(cwd), "pending-review.json");
+}
+/** 펜딩-검토 레코드 기록(block 시점). 기존 펜딩을 덮어쓴다(가장 최근 block만 유효). */
+export function writePendingReview(cwd, p) {
+    writeJson(pendingPath(cwd), p);
+}
+/** 펜딩-검토 레코드 읽기. 없으면 null. */
+export function readPendingReview(cwd) {
+    return readJson(pendingPath(cwd), null);
+}
+/** 펜딩-검토 레코드 제거(분류 완료 후). 파일 부재면 무동작(idempotent). */
+export function clearPendingReview(cwd) {
+    const path = pendingPath(cwd);
+    if (existsSync(path))
+        rmSync(path);
+}
+/**
+ * 펜딩 케이스(1-base 표시) 중 ref에 해당하는 케이스 텍스트를 고른다. defer selectTargets와 동형:
+ * - "all" → 전부
+ * - 공백구분 토큰이 전부 정수 → 복수 인덱스(1-base, 범위 밖·중복 무시)
+ * - 그 외 → 부분 텍스트 1건 매칭(공백 포함 문구 하위호환)
+ * 빈 ref → [](includes("") 오매칭 방어).
+ */
+export function selectCases(cases, ref) {
+    const trimmed = ref.trim();
+    if (trimmed === "")
+        return [];
+    if (trimmed === "all")
+        return [...cases];
+    const tokens = trimmed.split(/\s+/).filter(Boolean);
+    const allInts = tokens.length > 0 && tokens.every((t) => /^\d+$/.test(t));
+    if (allInts) {
+        const out = [];
+        for (const t of tokens) {
+            const idx = Number.parseInt(t, 10);
+            if (idx >= 1 && idx <= cases.length && !out.includes(cases[idx - 1])) {
+                out.push(cases[idx - 1]);
+            }
+        }
+        return out;
+    }
+    const found = cases.find((c) => c.includes(trimmed));
+    return found ? [found] : [];
+}
+/**
+ * 펜딩 케이스를 spec-추가 / defer-등록으로 분류한다. specRefs·deferRefs는 각각 selectCases ref.
+ * 한 케이스가 양쪽에 걸리면 **spec 우선**(승인이 미룸을 이긴다) — toDefer에서 toSpec 항목을 제외해
+ * 같은 케이스가 spec.md와 defers.json에 이중 등록되는 것을 막는다.
+ */
+export function resolveRefs(missing, specRefs, deferRefs) {
+    const toSpec = selectCases(missing, specRefs);
+    const toDefer = selectCases(missing, deferRefs).filter((c) => !toSpec.includes(c));
+    return { toSpec, toDefer };
+}

package/dist/version.js

@@ -69,6 +69,18 @@ export function buildVersionNotice(current, cache) {
     return (`🐢 거북이코드 신버전 ${cache.latest} 사용 가능(현재 ${current}). ` +
         `갱신: 'gbc update'(전역 최신 + 현재 프로젝트 재init) 또는 수동 'npm i -g geobuke-code@latest → gbc init --yes'`);
 }
+/**
+ * 캐시 자동 refresh를 해야 하는지(순수 술어). cliPath 없으면(직접 hook 호출) X, 안내 opt-out X,
+ * 캐시가 stale일 때만 true. PreToolUse cache-miss(judge 경로)에서 judge와 병렬 refresh를 거는
+ * 게이트 — 핫패스(cached-skip)는 절대 호출 안 함. env·파일 의존이라 테스트는 home/now 주입.
+ */
+export function shouldRefreshCache(hasCliPath, home, now = Date.now()) {
+    if (!hasCliPath)
+        return false;
+    if (process.env.GBC_NO_UPDATE_NOTICE === "1")
+        return false;
+    return isCacheStale(readVersionCache(home), now);
+}
 /**
  * npm 레지스트리에서 최신 버전을 받아 캐시에 쓴다(짧은 타임아웃, 비차단·fail-silent).
  * spawn(npm) 대신 fetch — Windows .cmd 실행 문제를 피한다. 실패·타임아웃은 조용히 무시.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geobuke-code",
-  "version": "0.2.9",
+  "version": "0.4.0",
   "description": "거북이코드 — 구현 직전 강제 게이트. Claude Code PreToolUse hook으로 코드 변경 전 계획 케이스 누락·시나리오 미지정을 차단한다.",
   "type": "module",
   "bin": {

package/skills/gate/SKILL.md

@@ -46,12 +46,19 @@ defer 항목은 **open(미착수) → in_progress(진행중) → resolved(해결
 | 등록된 케이스 목록 | `gbc spec show` |
 | 명세 비우기(작업단위 종료) | `gbc spec clear` |
 | 작업단위 게이트 리셋(다음 편집에서 재발동) | `gbc gate reset` |
+| block이 도출한 누락 케이스 체크리스트 보기 | `gbc gate review` |
+| 누락 케이스 일괄 분류(승인→spec / 미룸→defer) | `gbc gate review --spec <번호\|텍스트\|all> --defer <번호\|텍스트\|all>` |
+| 판정 골든셋 캡처 토글·조회 | `gbc gate snapshot <on\|off\|status\|list\|clear>` |
+| 골든 케이스 재판정·드리프트 점검(temp 0, 뒤집힘 시 exit 1) | `gbc gate snapshot replay [--samples N]` |
 
 ## 사용 흐름
 
-1. **게이트가 변경을 차단했을 때**: hook이 사유와 누락 케이스를 알려준다. 두 갈래로 해소한다:
-   - (a) 누락 케이스를 **지금 이 변경에서 다룬다** → 다시 시도하면 통과.
-   - (b) 의도적으로 나중에 할 케이스면 **`gbc defer add "케이스"`로 명시 등록** → 통과. (절대 주석으로만 미루지 말 것)
+1. **게이트가 침묵 누락으로 차단했을 때**: hook이 사유와 누락 케이스를 알려주고, 그 케이스들은 `.gbc/pending-review.json`에 기록된다. 케이스가 여러 개면 하나씩 `gbc spec add`/`gbc defer add`를 반복하지 말고 **체크리스트로 일괄 분류**한다:
+   1. `gbc gate review` — 도출된 누락 케이스를 번호 목록으로 본다.
+   2. 사용자에게 제시·검증받는다(승인할 케이스 / 미룰 케이스 구분).
+   3. `gbc gate review --spec <승인 번호들> --defer <미룸 번호들>` — 한 번에 승인은 spec.md 등록, 미룸은 defer 등록(겹치면 spec 우선). 펜딩은 비워진다.
+   4. 재시도하면 등록 기준으로 재판정 → 통과.
+   - 단건이면 종전대로 (a) 지금 이 변경에서 직접 다루거나 (b) `gbc defer add "케이스"`로 미뤄도 된다. (절대 주석으로만 미루지 말 것)
 2. **시나리오 미지정으로 차단됐을 때 — 에이전트 도출 루프**: 사용자가 명세를 수기로 쓰지 않는다. 에이전트가 다음을 수행한다:
    1. 사용자 요청에서 의도·동작 시나리오와 형제 케이스를 **도출**한다.
    2. 도출한 케이스를 사용자에게 **제시하고 검증받는다** — **사용자 승인 없이 자동 등록·구현 금지**(같은 에이전트가 도출+구현하면 고무도장이 됨).
@@ -73,4 +80,6 @@ defer 항목은 **open(미착수) → in_progress(진행중) → resolved(해결
 
 - **주석 defer는 defer가 아니다.** `// 비밀번호 검증은 다음에` 같은 코드 주석은 게이트가 침묵 누락으로 본다. 반드시 `gbc defer add`로 레지스트리에 등록해야 한다.
 - **게이트는 작업단위당 1회만 발동한다.** 명세가 바뀌거나 명세 밖 파일을 편집할 때 재발동한다. 강제로 다시 점검하려면 `gbc gate reset`.
+- **게이트가 한 repo에서 아예 안 먹는다면** hook이 미등록·구식일 수 있다. `gbc repos list`가 등록된 각 repo의 게이트 건강성(`⚠️게이트hook부재`/`⚠️SessionStart누락`)을 표시한다 — 떴으면 그 repo에서 `gbc init --yes` 재실행. (크로스-repo는 hook 등록 여부만 검사하고 명령 freshness는 각 repo `gbc status`로 확인.)
 - **`--no-gate` / `GBC_NO_GATE=1` 우회는 계측된다.** 우회 자체가 게이트 가치 측정 데이터가 된다.
+- **판정 드리프트가 의심되면**(모델/gbc 업그레이드 후 게이트가 전과 다르게 군다) `gbc gate snapshot on`으로 한동안 캡처하고, 나중에 `gbc gate snapshot replay`로 재판정해 pass↔block 뒤집힘을 점검한다. 골든셋은 **편집 본문을 로컬 `.gbc/golden.json`에만** 저장한다(gitignore·로컬 pre-flight 전용 — 커밋하면 privacy 불변식 위반).