leerness 1.36.91 → 1.36.92

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 1.36.92 — 2026-07-30 — 동의 없는 외부 CLI 실행 차단 · 과소평가 우회 3종 · 손상 토글 fail-closed
+
+1.36.88~91 에서 새로 만든 표면(bugfix 게이트·라우팅·대시보드·인증 축)을 6렌즈 적대 헌트(41 에이전트)로 훑어 **21건 확인 / 14건 반증**. 이번 릴리스는 그중 상위 5건 + codex 32차 검수 8건을 반영했고, 나머지 16건은 다음 라운드로 기록해 두었다.
+
+**동의 없이 외부 CLI 를 실행하고 있었다(가장 심각).** `agents route "<작업>"` — 토글 OFF · `--confirm` 없음 · `LEERNESS_ENABLE_CODEX` 미설정 — 이 **제안 한 번**에 codex 를 두 번(`--version`, `login status`) 띄웠다. PATH shim 으로 argv 를 로깅해 증명했고, `LEERNESS_ENABLE_CODEX=1` 대조군이 **동일한 spawn** 을 내 문서화된 opt-out 이 이 경로에서 완전한 no-op 임을 확정했다. 공개된 capability 표면과 SECURITY.md 는 "사용자 동의 없이 외부 LLM/API/CLI 를 자동 호출하지 않는다"고 말한다. 원인: 인증 확인이 `plan()` 안에서 돌았고 `plan()` 은 토글·`--confirm`·거부 판정보다 **먼저** 실행된다.
+→ 확인은 **확정 요청 + 토글 ON + provider opt-in(`LEERNESS_ENABLE_*=1`)** 이 모두 참일 때만. 제안 단계는 프로세스 0회.
+
+**과소평가 우회 3종** — tiny 는 "범위가 좁다"는 주장인데, 규칙이 읽지 못하는 입력에서 그 주장이 통과했다:
+- **다국어**: 고위험 규칙 어휘는 영어·한국어뿐인데 tiny 어휘(css/lint/typo)는 라틴이라 살아남아, `支付退款逻辑修改 css`(중국어 결제 환불)가 **tiny** 로 확정됐다.
+- **전각**: `ＰＡＹＭＥＮＴ ｒｅｆｕｎｄ` 이 어떤 규칙에도 안 걸려 normal 로 떨어졌다(반각은 high-risk) → 매칭 전 NFKC 정규화(실측 3500자 200회 4ms).
+- **제로폭**: `pa<ZWSP>yment re<ZWSP>fund css` 로 영문 키워드를 쪼개 우회 → 서식문자 제거.
+- 악센트 라틴(스페인어 등)도 미커버로 본다. **한계는 그대로 적었다**: 악센트 없는 비영어 라틴 문장은 여전히 구분하지 못한다.
+
+**손상 토글에서 게이트가 무언 통과했다** — `bugfix-receipt` 는 defaultOff 라 손상 = OFF 다. 앞선 수정은 `toggle list` 에 경고만 달고 **강제 시점을 그대로 뒀다**(codex 32차 #1 BLOCK: "화면에 경고를 띄우는 것과 실제로 막는 것은 다른 일"). 이제 done 전이에서 fail-closed 로 보류하고, `{"bugfix-receipt":"banana"}` 처럼 **JSON 은 멀쩡한데 값을 못 읽는** 경우도 같은 취급을 한다.
+
+**그 밖에:**
+- `bugfix start|receipt|drop` 이 위치 경로를 **조용히 무시**했다(`list` 만 인식) — 지목한 프로젝트는 무보호로 done 되고 cwd 의 같은 번호 task 가 갇혔다. 경로형 토큰을 인식하고(UNC 포함), 위치 경로와 `--path` 를 **둘 다** 주면 거부한다.
+- 시크릿 마스킹: `Authorization: Bearer <토큰>` 이 통과하면서 옆에 `***` 가 찍혀 **가려졌다는 거짓 안심**을 줬다(안 가리는 것보다 나쁘다). 짧은 토큰(`Basic YTpi`)과 `~` 포함 token68 을 잡으려 규칙을 넓히면 산문(`Basic authentication flow`)이 훼손되므로, **authorization 헤더 문맥에 앵커**해 값 전체를 지운다 — 우회 7종 차단 · 오탐 0건 실측.
+- 감사 기록은 **입력 원문**을 남긴다(분류용 정규화본이 아니라). 단 git 추적 파일이므로 시크릿 값만 가린다.
+- 인증 미확인 사유를 구분한다 — "이 등급에서는 확인하지 않음" 과 "확인 수단이 등록되지 않음" 은 다른 말인데, 유일하게 확인 명령이 있는 codex 를 "수단 없는 provider" 로 읽게 만들고 있었다.
+- `_EXEC_NOTE` 의 "상태 명령만 실행" 도 부정확했다 — `--version` 도 함께 돈다. 실행 시점과 대상을 정확히 적었다.
+- `--approved-by` 의 제로폭 문자 제거 — 보이지 않는 승인자가 감사 기록에 남지 않게.
+
+**가드**: PATH shim 으로 "프로세스를 띄우지 않는다"를 증명한다 — 종전 테스트에는 그걸 증명할 수단이 **아예 없었다**. 제안 0회 / 확정 N회 / opt-out OFF 0회의 3방향 판별을 단언하고, shim 은 배치되는 provider 전부(codex·claude)에 건다. 라우팅 변이 14/14 · 인증축 변이 9/10(1건은 등가 변이, 대조 변이 M9·M10 로 확인).
+
+**작업 중 내 대조군이 내 수정을 잡았다**: 정규식 **리터럴**에 백슬래시를 두 개 넣어 `/[\\u0370-\\u03ff]/` 가 되면서 문자 클래스가 `\`·`u`·숫자·`f` 를 뜻하게 됐고, `fix typo in css` 의 `f` 가 "그리스 문자"로 잡혀 tiny 가 normal 로 떨어졌다. 대조군을 함께 돌리지 않았다면 "다국어 방어 강화"라고 보고하면서 멀쩡한 영어 입력을 망가뜨린 채 출하했을 것이다.
+
+게이트: exit 0 · E2E 412/412 · selftest 341/341 · ✗ 0건
+
 ## 1.36.91 — 2026-07-30 — 인증 축: **설치됨 ≠ 사용가능**을 고지에서 실제 판정으로
 
 1.36.89 의 라우팅은 "설치·활성만 확인했고 인증·쿼터·과금 권한은 확인하지 않았다"를 **말하기만** 했다. 이번엔 확인할 수 있는 것을 실제로 확인하고, 확인할 수 없는 것은 그대로 남긴다.

package/README.md

@@ -122,7 +122,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.91 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.92 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
 
 ### 정체성 — AI 에이전트 운영 레이어 (UR-0030)
 
@@ -176,7 +176,7 @@ leerness memory restore decision <date|title>
 
 ### MCP server (외부 AI 통합)
 
-Leerness v1.36.91는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
+Leerness v1.36.92는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -197,7 +197,7 @@ Leerness v1.36.91는 stdio JSON-RPC MCP server를 내장합니다 — Claude Cod
 `<<autonomous-loop-dynamic>>` 신호만 보내면 AI가:
 1) 다음 라운드 후보 선정 → 2) 코드 변경 → 3) 회귀 테스트 갱신 → 4) 전체 e2e 스위트 통과 → 5) npm publish + git tag → 6) main push → 7) session close → 8) 다음 라운드 예약.
 
-현재 누적: **v1.9.x → 1.36.91 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
+현재 누적: **v1.9.x → 1.36.92 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
 
 ### 성능 가이드
 
@@ -235,5 +235,5 @@ leerness release pack --close --auto-main-push
 - `.harness/session-handoff.md`: 다음 세션 인수인계 (자동 작성)
 - `.harness/lessons.md` / `decisions.md` / `rules.md`: 영구 메모리 (5 surface)
 
-Last synced by Leerness v1.36.91: 2026-07-30
+Last synced by Leerness v1.36.92: 2026-07-30
 <!-- leerness:project-readme:end -->

package/bin/leerness.js

@@ -34,7 +34,7 @@ const { CAPABILITY_SURFACE, POWERFUL_COMMANDS, ADAPTERS, REUSE_CATEGORIES, REUSE
 const { tokenizeForRank: _tokenizeForRank, expandQuery: _expandQuery, scoreHits: _scoreHits, suggestTerms: _suggestTerms } = require('../lib/search-core');  // 1.36.23: memory search 랭킹 코어(순수·0-deps)
 const { findCorruptedStateJson: _findCorruptedStateJson } = require('../lib/state-integrity');  // 1.36.1 (클린룸 리뷰 FN): .harness/*.json 상태 무결성 (audit/health/check 공유)
 
-const VERSION = '1.36.91';
+const VERSION = '1.36.92';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -10024,11 +10024,27 @@ let _lastBugfixLines = null;   // 통과 시 렌더용 — 직후 호출자가 _
 function _consumeBugfixLines() { const l = _lastBugfixLines; _lastBugfixLines = null; return l; }
 function upsertProgress(root, row) {
   // 게이트는 **락 밖에서** — probe 는 최대 10분까지 도는 사용자 명령이라 progress 락을 물고 있으면 안 된다.
-  if (row && row.status === 'done' && _tgl.toggleOn(root, 'bugfix-receipt')) {
-    const _bfm = require('../lib/bugfix');
-    const _r = _bfm.checkDoneTransition(root, row.id);
-    if (_r.blocked) throw new _bfm.BugfixBlocked(_r, row.id);
-    _lastBugfixLines = _r.lines || null;
+  if (row && row.status === 'done') {
+    // 1.36.92 (codex 32차 #1 BLOCK): 손상 토글에서 기본값으로 조용히 되돌아가면 **켜 뒀던 차단 게이트가 꺼진다**
+    //   (bugfix-receipt 는 defaultOff → 손상 = OFF). `toggle list` 에만 경고를 달았던 앞선 수정은
+    //   **강제 시점을 그대로 뒀다** — 정작 막아야 할 곳이 무언 통과였다. 여기서 fail-closed 한다.
+    const _tchk = _tgl.loadTogglesChecked(root);
+    const _tBad = _tchk.corrupt || (_tchk.unreadable || []).includes('bugfix-receipt');
+    if (_tBad) {
+      const _why = _tchk.corrupt ? (_tchk.reason || '형상 무효') : `'bugfix-receipt' 값을 읽을 수 없음`;
+      const _bfm = require('../lib/bugfix');
+      throw new _bfm.BugfixBlocked({
+        code: 'toggles_unreadable',
+        message: `toggles.json 을 신뢰할 수 없어(${_why}) 완료 판정을 보류합니다 — 켜 두었던 게이트가 꺼진 채 통과하는 것을 막습니다: ${_tgl._togglesPath(root)}`,
+        lines: [`복구: 파일을 고치거나 삭제 후 leerness toggle set <id> on|off 로 다시 설정하세요.`],
+      }, row.id);
+    }
+    if (_tchk.toggles['bugfix-receipt'] === true) {
+      const _bfm = require('../lib/bugfix');
+      const _r = _bfm.checkDoneTransition(root, row.id);
+      if (_r.blocked) throw new _bfm.BugfixBlocked(_r, row.id);
+      _lastBugfixLines = _r.lines || null;
+    }
   }
   // 1.9.303 (UR-0043): read-modify-write 전체를 락으로 직렬화 — 동시 task 쓰기 lost-update 방지.
   return _withLock(progressPath(root), () => {
@@ -24107,7 +24123,11 @@ async function main() {
     const _providerAuth = (pid) => {
       if (_authCache.has(pid)) return _authCache.get(pid);
       const def = (_allProviders(_authRoot) || []).find(a => a.id === pid);
-      const v = (def && def.authCheck) ? (_checkAgent(def, { auth: true }).auth || 'unknown') : 'unknown';
+      // 1.36.92 (codex 32차 #2): 문서화된 opt-out 을 실제로 지킨다 — `LEERNESS_ENABLE_<X>=1` 이 아닌 provider 는
+      //   프로세스를 띄우지 않는다. 종전엔 `enabled` 를 계산만 하고 확인 실행 전에 보지 않아, 외부 도구를 꺼 뒀다고
+      //   믿는 사용자의 환경에서 CLI 가 실행됐다(실측: 플래그 유무와 무관하게 동일 spawn).
+      const _enabled = !!(def && def.envFlag && process.env[def.envFlag] === '1');
+      const v = (def && def.authCheck && _enabled) ? (_checkAgent(def, { auth: true }).auth || 'unknown') : 'unknown';
       _authCache.set(pid, v);
       return v;
     };
@@ -24270,9 +24290,27 @@ async function main() {
     //   등록된 probe 를 "없음"으로 보고했다 — 다른 명령들과 같은 규율로 위치 경로를 받는다.
     //   (start/receipt/drop 의 첫 토큰은 task id 이므로, 경로로 오인하지 않도록 list/무인자에서만 적용)
     const _bfSub = _bfToks[0];
-    const _bfRest = _bfToks.slice(1);
+    let _bfRest = _bfToks.slice(1);
     let _bfRoot = arg('--path', null);
     if (!_bfRoot && (!_bfSub || _bfSub === 'list')) _bfRoot = _taskPositionalPath(['bugfix', ...(_bfSub ? [_bfSub] : []), ..._bfRest], _bfSub ? 2 : 1);
+    // 1.36.92 (헌트 #9, High): start/receipt/drop 은 위치 경로를 **조용히 무시**했다 — `bugfix start T-0002 <경로>` 가
+    //   지목한 프로젝트가 아니라 cwd 프로젝트에 probe 를 등록해, 지목한 쪽은 무보호로 done 되고 cwd 의 같은 번호
+    //   task 는 영문도 모른 채 갇혔다(실측). id 뒤의 경로형 토큰을 인식하고, 인식할 수 없으면 **거부**한다.
+    if (_bfSub === 'start' || _bfSub === 'receipt' || _bfSub === 'drop') {
+      //   UNC(\\server\share)도 경로다. 판별 못 하는 토큰은 **거부**한다 — 조용히 버리면 엉뚱한 프로젝트에 쓴다.
+      const _pathLike = (s) => typeof s === 'string' && /^([A-Za-z]:[\\/]|\\\\|\/|\.\.?[\\/])/.test(s);
+      const _stray = _bfRest.slice(1).filter(Boolean);
+      if (_stray.length) {
+        const _p = _stray.find(_pathLike);
+        // codex 32차 #5: 위치 경로와 --path 를 **둘 다** 주면 종전엔 위치 경로를 조용히 버렸다 —
+        //   어느 프로젝트에 쓸지 사용자 의도가 갈리는데 한쪽을 말없이 무시하면 안 된다. 거부한다.
+        if (_p && _stray.length === 1 && arg('--path', null)) {
+          fail(`경로가 두 번 지정됐습니다: 위치 인자 '${_p}' 와 --path '${arg('--path', null)}' — 하나만 쓰세요`); process.exitCode = 1; return;
+        }
+        if (_p && _stray.length === 1) { _bfRoot = absRoot(_p); _bfRest = [_bfRest[0]]; }
+        else { fail(`알 수 없는 인자: ${_stray.join(' ')} — 경로는 마지막에 하나만 두거나 --path <경로> 를 쓰세요 (예: leerness bugfix ${_bfSub} ${_bfRest[0] || '<T-ID>'} --path .)`); process.exitCode = 1; return; }
+      }
+    }
     // _withLock: 동시 등록이 서로를 지우면 게이트가 조용히 꺼진다(실측 4→2)
     // _taskExists: 존재하지 않는 id 로 등록되면 오타 하나로 "보호받는 줄 아는" 무보호 상태가 된다(출하전 헌트 #3)
     return require('../lib/bugfix').bugfixCmd(_bfRoot || process.cwd(), _bfSub, _bfRest,

package/lib/pure-utils.js

@@ -13,9 +13,22 @@ function _isSecretKey(k) {
 //   1.36.91: 대시보드와 인증 확인 evidence 두 곳이 필요해 여기(순수 함수)로 올렸다.
 //   표면마다 다시 구현하면 한쪽만 고쳐지는 불일치가 생긴다(1.36.90 에서 이미 겪은 클래스).
 const _SECRET_ASSIGN = /\b([A-Za-z0-9_]*(?:TOKEN|KEY|SECRET|PASSWORD|PASSWD|PWD|CREDENTIAL|AUTH)[A-Za-z0-9_]*)\s*[=:]\s*("[^"]*"|'[^']*'|\S+)/gi;
-const _SECRET_SHAPE = /\b(sk-[A-Za-z0-9_-]{8,}|ghp_[A-Za-z0-9]{16,}|gho_[A-Za-z0-9]{16,}|xox[baprs]-[A-Za-z0-9-]{8,}|AKIA[0-9A-Z]{12,}|eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,})/g;
+// 1.36.92 (헌트 #13): `Authorization: Bearer <토큰>` 이 통과했다 — 키 이름 뒤 값이 `Bearer` 로 끝나 거기서 멈추고
+//   실제 토큰은 다음 토큰이라 그대로 남았다. 게다가 옆에 `***` 가 찍혀 **가려졌다는 거짓 안심**을 줬다
+//   (안 가리는 것보다 나쁘다). 스킴 뒤의 값까지 함께 지운다.
+// 1.36.92 (codex 32차 #4/#6): 종전 규칙은 두 방향으로 틀렸다 —
+//   ① 짧은 자격증명을 놓쳤다: `Authorization: Basic YTpi`(= a:b) 가 그대로 남았고, token68 에 허용되는 `~` 가
+//      문자군에 없어 `Bearer abcdefgh~SECRET` 의 뒷부분이 살아남았다.
+//   ② 멀쩡한 산문을 훼손했다: `Basic authentication flow` → `Basic *** flow`, `Token release/1.2.3` → `Token ***`.
+//   그래서 **authorization 헤더 문맥에 앵커**하고, 값은 token68 전체를 길이 제한 없이 지운다.
+//   (헤더 밖의 맨 `Bearer <값>` 은 아래 SHAPE 규칙이 형태로 잡는다 — 산문 훼손 위험을 감수하지 않는다.)
+const _SECRET_AUTH_HEADER = /\b((?:proxy-)?authorization)([ \t]*[:=][ \t]*)(?:(Bearer|Basic|Token|ApiKey|Digest)([ \t]+))?([A-Za-z0-9._~+/-]+=*)/gi;
+const _SECRET_SHAPE = /\b(sk-[A-Za-z0-9_-]{8,}|ghp_[A-Za-z0-9]{16,}|gho_[A-Za-z0-9]{16,}|ghs_[A-Za-z0-9]{16,}|github_pat_[A-Za-z0-9_]{20,}|xox[baprs]-[A-Za-z0-9-]{8,}|AKIA[0-9A-Z]{12,}|ASIA[0-9A-Z]{12,}|AIza[A-Za-z0-9_-]{20,}|eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,})/g;
 function redactSecrets(s, max) {
-  let out = String(s == null ? '' : s).replace(_SECRET_ASSIGN, (m, k) => `${k}=***`).replace(_SECRET_SHAPE, '***');
+  let out = String(s == null ? '' : s)
+    .replace(_SECRET_AUTH_HEADER, (m, key, sep, scheme, gap) => `${key}${sep}${scheme ? scheme + (gap || ' ') : ''}***`)
+    .replace(_SECRET_ASSIGN, (m, k) => `${k}=***`)
+    .replace(_SECRET_SHAPE, '***');
   if (max && out.length > max) out = out.slice(0, max) + '…';
   return out;
 }

package/lib/routing.js

@@ -53,18 +53,51 @@ const TINY = [
 const BROAD = /\b(entire|whole|all |everything|rewrite|overhaul|refactor all|across the|end.to.end)\b|전체|전면|모든|갈아엎|재작성|통째/i;
 const TINY_MAX_LEN = 80;
 
-function _norm(s) { return String(s == null ? '' : s).trim(); }
+// 1.36.92 (자체 적대 검증): 전각 문자로 고위험 규칙을 우회할 수 있었다 —
+//   `ＰＡＹＭＥＮＴ ｒｅｆｕｎｄ` 는 어떤 규칙에도 안 걸려 normal 로 떨어졌다(반각은 high-risk).
+//   매칭 전에 NFKC 로 정규화한다(실측 비용: 3500자 200회에 4ms). 표시·기록은 원문을 쓴다.
+function _norm(s) {
+  const raw = String(s == null ? '' : s).trim();
+  let t = raw;
+  try { t = raw.normalize('NFKC'); } catch { t = raw; }
+  // codex 32차 #3: 제로폭 문자를 끼워 넣으면 영문 키워드가 쪼개져 고위험 규칙을 통째로 빠져나간다
+  //   (예: pa<ZWSP>yment re<ZWSP>fund css → tiny). 매칭 전에 서식문자를 제거한다.
+  return t.replace(new RegExp('[\\u200b-\\u200f\\u2060\\ufeff\\u00ad]', 'g'), '');
+}
+
+// 규칙이 커버하는 문자 체계는 라틴(영문)과 한글뿐이다 — 그 외가 섞이면 고위험 규칙이 침묵한다는 뜻이므로,
+//   tiny 로 내리는 근거가 될 수 없다. 어떤 체계가 섞였는지 이름을 돌려 사용자에게 사유를 그대로 보여준다.
+const _SCRIPTS = [
+  ['일본어', /[぀-ヿ]/],
+  ['중국어(한자)', /[一-鿿]/],
+  ['키릴', /[Ѐ-ӿ]/],
+  ['아랍어', /[؀-ۿ]/],
+  ['히브리어', /[֐-׿]/],
+  ['태국어', /[฀-๿]/],
+  ['데바나가리', /[ऀ-ॿ]/],
+  ['그리스', /[\u0370-\u03ff]/],
+  // codex 32차 #3: "라틴 문자면 커버된다"는 가정이 틀렸다 — 규칙 어휘는 **영어**뿐이라
+  //   "modificar lógica de reembolso de pago css"(스페인어 결제 환불) 가 tiny 로 떨어졌다.
+  //   악센트 라틴이 섞이면 영어가 아닐 가능성이 크므로 tiny 주장을 인정하지 않는다.
+  //   한계(정직하게): 악센트 없는 비영어 라틴 문장(예: "pago reembolso css")은 여전히 구분하지 못한다.
+  ['비영어 라틴(악센트)', /[\u00c0-\u024f]/],
+];
+function _hasUncoveredScript(t) {
+  const hit = _SCRIPTS.find(([, re]) => re.test(t));
+  return hit ? hit[0] : null;
+}
 
 // 사용자에게 반복 노출되는 고지 — **이 모듈이 실제로 한 일만** 말한다.
 //   1.36.89 (codex 28차 #7): 종전 문구는 "설치·활성 여부만 확인했습니다"였는데, 이 모듈은 역할 매핑만 읽고
 //   설치 확인(`--version`)을 **한 번도 하지 않는다**. 하지 않은 확인을 했다고 말하는 것이 바로 이 제품이 잡는 결함이다.
 //   1.36.91: 인증 축이 생겼다 — 확인 가능한 provider 만 판정하고 나머지는 '확인안됨' 이다. 쿼터·과금 권한은 여전히 아무도 확인하지 않는다.
-const _AVAIL_NOTE = '역할별 인증 표시는 무료·비대화형 확인 명령이 있는 provider 만 판정한 결과입니다(나머지는 "확인안됨") — 모델 사용권한·쿼터·과금 권한은 어느 provider 도 확인하지 않았습니다(상세: leerness agents check).';
+const _AVAIL_NOTE = '인증 확인은 **--confirm 으로 고위험 구성을 확정할 때만** 실행합니다(제안 단계에서는 외부 CLI 를 띄우지 않습니다). 확인하더라도 무료·비대화형 확인 명령이 등록된 provider 만 판정되며, 모델 사용권한·쿼터·과금 권한은 어느 provider 도 확인하지 않습니다(상세: leerness agents check).';
 const _CLASS_NOTE = '난이도는 텍스트 규칙 매칭 결과이며 측정값이 아닙니다.';
 //   1.36.91 (codex 30차 #3): 인증 축이 생기면서 이 문구가 **거짓이 됐다** — 인증 확인은 외부 CLI 를
 //   실제로 실행한다(`<bin> --version` · 등록된 status 명령). "모델을 호출하지 않는다"와 "프로세스를 전혀
 //   띄우지 않는다"는 다른 말이고, 전자만 참이다. 문구를 사실에 맞춘다.
-const _EXEC_NOTE = 'leerness 는 여기서 작업을 대신 수행하지 않습니다 — 계획을 확정하고 기록할 뿐이며, 모델 호출(과금)은 하지 않습니다. (고위험 등급에서는 인증 확인을 위해 해당 CLI 의 상태 명령만 실행합니다.)';
+//   1.36.92 (헌트 #3): "상태 명령만 실행" 도 부정확했다 — 인증 확인은 `--version` 도 함께 돌린다(감지용).
+const _EXEC_NOTE = 'leerness 는 여기서 작업을 대신 수행하지 않습니다 — 계획을 확정하고 기록할 뿐이며, 모델 호출(과금)은 하지 않습니다. (고위험 구성을 --confirm 으로 확정할 때만, 인증 확인을 위해 해당 CLI 의 버전 확인과 로그인 상태 명령을 실행합니다.)';
 
 // 난이도 판정 — 순서가 곧 정책이다. (1) 사용자 명시 (2) 고위험 도메인 (3) 초소형 (4) 기본 normal
 function classify(text, opts = {}) {
@@ -111,6 +144,15 @@ function classify(text, opts = {}) {
   // tiny 는 "범위가 좁다"는 주장이다 — 광범위 신호가 있거나 설명이 길면 그 주장을 인정하지 않는다.
   const broad = BROAD.test(t);
   const longText = t.length > TINY_MAX_LEN;
+  //   1.36.92 (헌트 #15, High): 고위험 규칙은 **영어·한국어 어휘만** 담고 있다. 설명이 다른 언어로 쓰이면
+  //   고위험 규칙은 통째로 침묵하는데, tiny 어휘(css/lint/typo/rename/format)는 라틴 문자라 그대로 살아남아
+  //   결제·인증·전체삭제 작업이 **tiny 로 확정**됐다(실측). 규칙이 못 읽는 언어에서 "좁다"고 단정할 근거가 없다.
+  //   → 커버하지 않는 문자 체계가 섞여 있으면 tiny 주장을 인정하지 않는다(normal 로 보수 처리).
+  const uncovered = _hasUncoveredScript(t);
+  if (uncovered) {
+    reasons.push(`고위험 규칙이 다루지 않는 문자 체계(${uncovered})가 섞여 있습니다 — 규칙이 읽지 못하는 언어에서는 "범위가 좁다"고 단정할 수 없어 normal 로 둡니다. 실제로 사소하면 --tier tiny 로 지정하세요`);
+    return { ok: true, tier: 'normal', confidence: 'low', signals, reasons, conflict: true };
+  }
   if (broad || longText) {
     reasons.push(`초소형 신호(${tiny.map(r => r.ko).join(', ')})가 있지만 ${broad ? '광범위 신호가 함께 있어' : `설명이 ${t.length}자로 길어(기준 ${TINY_MAX_LEN}자)`} 좁은 범위로 볼 수 없습니다 — normal 로 둡니다`);
     return { ok: true, tier: 'normal', confidence: 'low', signals, reasons, conflict: true };
@@ -151,8 +193,16 @@ function plan(root, cls, deps = {}) {
   //   거의 모든 고위험 작업이 잠긴다(false-BLOCK). 확실히 아닌 것만 막고, 모르는 것은 모른다고 표시한다.
   //   codex 30차 #3: 인증 확인은 외부 프로세스를 띄운다(provider 당 최대 version 5s + status 8s).
   //   차단에 쓰이는 곳은 고위험뿐이므로 **고위험에서만** 확인한다 — tiny/normal 은 지연도 실행도 없다.
-  const authOf = (spec.humanApproval && typeof deps._providerAuth === 'function') ? deps._providerAuth : () => 'unknown';
-  assignments.forEach(a => { a.auth = a.resolved ? authOf(a.provider) : null; });
+  //   1.36.92 (헌트 #2/#3): 그런데 **제안만 하는 호출에서도** 확인이 돌았다 — 토글 OFF·`--confirm` 없음·
+  //   `LEERNESS_ENABLE_*` 미설정 상태에서 `agents route "..."` 한 번이 codex 를 두 번 띄웠다(실측 shim 로그).
+  //   공개된 opt-out("LEERNESS_ENABLE_* 미설정 시 비활성")과 "사용자 동의 없이 외부 CLI 를 자동 호출하지 않는다"는
+  //   주장에 정면으로 어긋난다. 그래서 **확정 요청(--confirm)일 때만** 확인한다 — 제안은 프로세스를 띄우지 않는다.
+  const mayCheck = spec.humanApproval && deps.authAllowed === true && typeof deps._providerAuth === 'function';
+  const authOf = mayCheck ? deps._providerAuth : () => 'unknown';
+  //   왜 'unknown' 인지 사유를 구분한다 — 헌트 #1: 종전엔 tiny/normal 에서도 "확인 명령이 없어서"라고 설명해,
+  //   유일하게 확인 명령이 등록된 codex 를 "확인 수단 없는 provider"로 읽게 만들었다.
+  const authReason = mayCheck ? 'checked' : 'not-checked-at-this-tier';
+  assignments.forEach(a => { a.auth = a.resolved ? authOf(a.provider) : null; a.authReason = a.resolved ? authReason : null; });
   const notAuthed = assignments.filter(a => a.resolved && a.auth === 'no').map(a => `${a.role}:${a.provider}`);
 
   const blockers = [];
@@ -208,11 +258,14 @@ function routeCmd(root, taskText, deps = {}) {
 
   const cls = classify(taskText, { tier: (arg ? arg('--tier', '') : '') || '' });
   if (!cls.ok) { failJson(json, cls.code, cls.error); return; }
-  const p = plan(root, cls, deps);
-
   const wantDispatch = !!(has && (has('--confirm') || has('--dispatch')));
-  const approvedBy = _norm(arg ? arg('--approved-by', '') : '');
   const gateOn = typeof deps._toggleOn === 'function' ? deps._toggleOn(root, 'difficulty-routing') : false;
+  //   인증 확인은 외부 프로세스를 띄운다 — **확정을 요청했고 토글도 켜져 있을 때만** 허용한다.
+  //   codex 32차 #7: 종전엔 확정 요청만 보아, 토글이 꺼져 **어차피 거부될 호출**에서도 CLI 를 실행했다.
+  const p = plan(root, cls, Object.assign({}, deps, { authAllowed: wantDispatch && gateOn }));
+  //   승인자는 정규화(NFKC)하지 않은 원문을 쓰되, 보이지 않는 문자만 제거한다 — 제로폭 문자로 채운 값이
+  //   "승인자 있음"으로 통과하면 감사 기록에 보이지 않는 승인자가 남는다.
+  const approvedBy = String((arg ? arg('--approved-by', '') : '') || '').replace(new RegExp('[\\u200b-\\u200f\\u2060\\ufeff]', 'g'), '').trim();
 
   // 실행 거부 사유 — 하나라도 있으면 dispatch 하지 않는다(고위험은 fail-closed).
   const refusals = [];
@@ -226,7 +279,9 @@ function routeCmd(root, taskText, deps = {}) {
   const confirmed = wantDispatch && !refusals.length;
   const rec = {
     at: now(),
-    task: _norm(taskText).slice(0, 300),
+    //   1.36.92: 감사 기록은 **사용자가 실제로 입력한 문자열**을 남긴다(분류용 NFKC 정규화본이 아니라).
+    //   다만 이 파일은 git 에 추적되므로 시크릿은 값만 가린다(헌트 #6 — 대시보드와 같은 술어).
+    task: require('./pure-utils').redactSecrets(String(taskText == null ? '' : taskText).trim(), 300),
     tier: cls.tier, confidence: cls.confidence, conflict: !!cls.conflict,
     signals: cls.signals.map(s => `${s.kind}:${s.id}`),
     assignments: p.assignments.map(a => ({ role: a.role, provider: a.provider, model: a.model })),
@@ -255,7 +310,9 @@ function routeCmd(root, taskText, deps = {}) {
   cls.reasons.forEach(r => log(`  · ${r}`));
   log(`\n  구성(${p.ko}):`);
   p.assignments.forEach(a => {
-    const authMark = a.auth === 'ok' ? ' [인증 확인됨]' : a.auth === 'no' ? ' [🔴 미인증]' : a.resolved ? ' [인증 확인안됨]' : '';
+    //   사유를 구분해 표시한다 — "확인 안 함"과 "확인할 수단이 없음"은 다른 말이다(헌트 #1).
+    const authMark = a.auth === 'ok' ? ' [인증 확인됨]' : a.auth === 'no' ? ' [🔴 미인증]'
+      : a.resolved ? (a.authReason === 'checked' ? ' [인증 확인 수단 없음]' : ' [인증 미확인 — 이 등급에서는 확인하지 않음]') : '';
     log(`    ${a.role.padEnd(10)} ${a.resolved ? `${a.provider}${a.model ? ' / ' + a.model : ''}${authMark}` : '⚠ 미설정 — leerness roles set ' + a.role + ' --provider <id>'}`);
   });
   if (p.reviewerIndependent === false) log(`    ⚠ 검수자와 구현자가 같은 provider — 독립 검수가 아닙니다`);

package/lib/toggles.js

@@ -39,19 +39,32 @@ function _coerceToggle(v, dflt) {
   return dflt;
 }
 
-function loadToggles(root) {
+// 1.36.92 (헌트 #5): 손상 파일에서 조용히 기본값으로 돌아가면 **켜 뒀던 차단 게이트가 무경고로 꺼진다**
+//   (bugfix-receipt 는 defaultOff 라 손상 = OFF). 사용자는 `toggle list` 에서도 그냥 "OFF" 만 본다.
+//   손상 사실을 함께 돌려주고, 호출부가 그걸 사용자에게 알린다. (읽기 경로는 계속 fail-open 이지만 **조용하지 않다**.)
+function loadTogglesChecked(root) {
   const out = {};
   for (const [id, meta] of Object.entries(TOGGLE_REGISTRY)) out[id] = !(meta && meta.defaultOff);
   const f = _togglesPath(root);
-  if (!exists(f)) return out;
+  if (!exists(f)) return { toggles: out, corrupt: false, unreadable: [] };
   try {
     const j = JSON.parse(read(f));
-    if (!j || typeof j !== 'object' || Array.isArray(j)) return out;   // 배열/스칼라 저장본 → 기본값
-    for (const [k, v] of Object.entries(j)) if (k in out) out[k] = _coerceToggle(v, out[k]);
-  } catch {}
-  return out;
+    if (!j || typeof j !== 'object' || Array.isArray(j)) return { toggles: out, corrupt: true, reason: '최상위가 객체가 아닙니다', unreadable: [] };
+    // codex 32차 #1: JSON 은 멀쩡한데 **값을 못 읽는** 경우(`"banana"`)도 저장 의도가 유실된 것이다 —
+    //   기본값으로 조용히 되돌리면 켜 뒀던 차단 게이트가 꺼진다. 어떤 키가 그랬는지 함께 돌려준다.
+    const unreadable = [];
+    for (const [k, v] of Object.entries(j)) {
+      if (!(k in out)) continue;
+      const coerced = _coerceToggle(v, out[k]);
+      if (_coerceToggle(v, true) !== _coerceToggle(v, false)) unreadable.push(k);   // 기본값에 따라 답이 갈리면 = 못 읽은 값
+      out[k] = coerced;
+    }
+    return { toggles: out, corrupt: false, unreadable };
+  } catch { return { toggles: out, corrupt: true, reason: 'JSON 파싱 실패', unreadable: [] }; }
 }
 
+function loadToggles(root) { return loadTogglesChecked(root).toggles; }
+
 // 단일 토글 조회 헬퍼 — 호출부 한 줄용. defaultOff 토글은 명시적으로 켜야 true.
 function toggleOn(root, id) {
   const st = loadToggles(root);
@@ -71,10 +84,13 @@ function toggleCmd(root, sub, id, val, deps = {}) {
   const { has, VERSION } = deps;
   root = absRoot(root);
   const json = has && has('--json');
-  const cur = loadToggles(root);
+  const _chk = loadTogglesChecked(root);
+  const cur = _chk.toggles;
   if (!sub || sub === 'list') {
-    if (json) { log(JSON.stringify({ version: VERSION, toggles: cur, registry: TOGGLE_REGISTRY }, null, 2)); return; }
+    if (json) { log(JSON.stringify({ version: VERSION, toggles: cur, corrupt: !!_chk.corrupt, corruptReason: _chk.reason, registry: TOGGLE_REGISTRY }, null, 2)); return; }
     log(`# leerness toggle — 기능 토글 (온톨로지 그래프 뷰 ⚙ 탭과 연동)`);
+    // 손상 시 "그냥 OFF" 로 보이면 켜 뒀던 게이트가 꺼진 줄 모른다 — 사실을 먼저 알린다(헌트 #5).
+    if (_chk.corrupt) log(`  ⚠ toggles.json 손상(${_chk.reason}) — 아래는 **저장값이 아니라 기본값**입니다. 켜 두었던 토글이 꺼져 보일 수 있습니다: ${_togglesPath(root)}`);
     for (const [k, meta] of Object.entries(TOGGLE_REGISTRY)) {
       log(`  ${cur[k] ? '🟢 ON ' : '⚪ OFF'}  ${k.padEnd(17)} ${meta.desc}  [${meta.affects}]`);
     }
@@ -101,4 +117,4 @@ function toggleCmd(root, sub, id, val, deps = {}) {
   fail(`알 수 없는 하위명령: ${sub} (가능: list, set)`); process.exitCode = 1;
 }
 
-module.exports = { TOGGLE_REGISTRY, loadToggles, toggleOn, saveToggles, toggleCmd, _togglesPath, _coerceToggle };
+module.exports = { TOGGLE_REGISTRY, loadToggles, loadTogglesChecked, toggleOn, saveToggles, toggleCmd, _togglesPath, _coerceToggle };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.91",
+  "version": "1.36.92",
   "description": "The AI-coding operations layer that makes \"done\" require evidence — persistent memory, evidence-gated completion checks, and clean handoffs for any AI agent (Claude Code, Codex, Cursor). State lives as plain files in your repo. CLI + MCP, 0 runtime dependencies.",
   "keywords": [
     "leerness",

package/scripts/e2e.js

@@ -7801,15 +7801,18 @@ total++;
     const human = R(['agents', 'route', '주문 필터', '--path', d]).o;
     const logHuman = R(['agents', 'route', '--log', '--path', d]).o;
     const cj = J(R(['agents', 'route', '주문 필터 추가', '--confirm', '--path', d, '--json'])) || {};
-    const honestOk = /확인하지 않았습니다/.test(human) && /측정값이 아닙니다/.test(human)
+    const honestOk = /확인하지 않습니다/.test(human) && /측정값이 아닙니다/.test(human)
       && !/설치·활성 여부만 확인/.test(human)                       // 하지 않은 확인을 했다고 말하던 옛 문구
-      && /확인하지 않았습니다/.test(logHuman) && /작업을 대신 수행하지 않습니다/.test(logHuman)
+      && /확인하지 않습니다/.test(logHuman) && /작업을 대신 수행하지 않습니다/.test(logHuman)
       && cj.executed === false && typeof cj.confirmed === 'boolean' && !('dispatched' in cj)
-      //   1.36.91: 인증 축이 생기면서 "외부 CLI 를 전혀 실행하지 않는다"는 **거짓이 됐다**(고위험에서 상태 명령을 실행한다).
-      //   문구가 그 구분을 담고 있는지 단언하고, 옛 과장 문구가 되살아나지 않는지도 함께 본다.
+      //   1.36.91: 인증 축이 생기면서 "외부 CLI 를 전혀 실행하지 않는다"는 **거짓이 됐다**(확정 시 상태 명령을 실행한다).
+      //   1.36.92: "상태 명령만" 도 부정확했다 — `--version` 도 함께 돈다. 문구가 실행 시점과 대상을 정확히
+      //   말하는지 단언하고, **옛 과장 문구 두 형태가 되살아나지 않는지**도 함께 본다.
       && /모델 호출\(과금\)은 하지 않습니다/.test(JSON.stringify(cj))
-      && /인증 확인을 위해 해당 CLI 의 상태 명령만 실행/.test(JSON.stringify(cj))
-      && !/외부 CLI 를 실행하지 않습니다/.test(JSON.stringify(cj));
+      && /--confirm 으로 확정할 때만/.test(JSON.stringify(cj))
+      && /버전 확인과 로그인 상태 명령을 실행/.test(JSON.stringify(cj))
+      && !/외부 CLI 를 실행하지 않습니다/.test(JSON.stringify(cj))
+      && !/상태 명령만 실행/.test(JSON.stringify(cj));
     // 모델명 비하드코딩 — 정책 모듈에 벤더 모델 id 가 있으면 안 된다(몇 달이면 낡는다)
     //   경로는 CLI 기준으로 잡는다 — 검사 대상이 "지금 실행 중인 그 설치본"이어야 한다(__dirname 은 실행 위치에 따라 어긋난다).
     const srcOk = !/(claude-(opus|sonnet|haiku)|gpt-[45]|o[34]-mini|gemini-)/i.test(fs.readFileSync(path.join(path.dirname(CLI), '..', 'lib', 'routing.js'), 'utf8'));
@@ -7979,25 +7982,32 @@ total++;
     // A4~A6: 라우팅 연동 — unknown 은 통과, 확실한 미인증만 고위험에서 차단, normal 은 무관
     const RTm = require(path.join(path.dirname(CLI), '..', 'lib', 'routing.js'));
     const roles = { architect: 'codex', commander: 'codex', coder: 'codex', reviewer: 'claude' };
-    const planWith = (tier, authMap) => RTm.plan(d, { tier }, {
+    //   1.36.92: 인증 확인은 **확정 요청(authAllowed)** 일 때만 돈다 — 제안이 외부 프로세스를 띄우던 동의 위반을 막았다.
+    //   그래서 차단 판정을 보려면 authAllowed:true 를 줘야 하고, 주지 않으면 확인 자체가 없어야 한다(판별 대조).
+    const planWith = (tier, authMap, allowed = true) => RTm.plan(d, { tier }, {
+      authAllowed: allowed,
       _resolveRole: (r, role) => ({ provider: roles[role] }),
       _providerAuth: (pid) => authMap[pid] || 'unknown',
     });
     const hasAuthBlock = (p) => p.blockers.some(b => b.code === 'provider_not_authenticated');
-    A4 = !hasAuthBlock(planWith('high-risk', {}));                       // 전부 unknown → 막지 않는다
+    A4 = !hasAuthBlock(planWith('high-risk', {}))                        // 전부 unknown → 막지 않는다
+      && !hasAuthBlock(planWith('high-risk', { codex: 'no' }, false));   // 확정 요청 없으면 확인도 차단도 없다
     A5 = hasAuthBlock(planWith('high-risk', { codex: 'no', claude: 'ok' }));  // 확실한 미인증 → 막는다
     //   codex 30차 #3: 인증 확인은 외부 프로세스를 띄운다 — 차단에 쓰이는 고위험에서만 확인해야
     //   tiny/normal 에 지연이 붙지 않고, "여기서 CLI 를 실행한다"는 범위도 좁게 유지된다.
     //   호출 횟수를 직접 센다(결과만 보면 "확인은 하고 무시하는" 구현과 구분되지 않는다).
     let calls = 0;
-    const counting = (tier) => RTm.plan(d, { tier }, {
+    const counting = (tier, allowed) => RTm.plan(d, { tier }, {
+      authAllowed: allowed,
       _resolveRole: (r, role) => ({ provider: roles[role] }),
       _providerAuth: () => { calls++; return 'no'; },
     });
-    calls = 0; const normalPlan = counting('normal'); const normalCalls = calls;
-    calls = 0; counting('high-risk'); const highCalls = calls;
+    calls = 0; const normalPlan = counting('normal', true); const normalCalls = calls;
+    calls = 0; counting('high-risk', true); const highCalls = calls;
+    calls = 0; counting('high-risk', false); const noConsentCalls = calls;
     A6 = !hasAuthBlock(planWith('normal', { codex: 'no', claude: 'no' }))     // normal 은 무관
       && !hasAuthBlock(normalPlan) && normalCalls === 0 && highCalls > 0      // normal 은 확인 자체를 안 한다
+      && noConsentCalls === 0                                                 // 확정 요청 없으면 고위험도 확인 안 한다(동의)
       && planWith('high-risk', {}).assignments.every(a => 'auth' in a);       // auth 축이 계획에 실린다
     ok = A1 && A2 && A3 && A4 && A5 && A6;
     if (!ok) console.log(`   [인증축 디버그] 축노출=${A1} 미확인은unknown=${A2} list무확인=${A3} unknown통과=${A4} 미인증차단=${A5} normal무관+축노출=${A6}`);
@@ -8007,6 +8017,92 @@ total++;
   if (!ok) failed++;
 }
 
+// 1.36.92 (신규표면 헌트 확정 5건): 동의 없는 외부 CLI 실행 · 사유 오귀인 · 다국어 과소평가 ·
+//   위치경로 무시 · Bearer 토큰 미마스킹 · 손상 토글 무경고.
+//   **PATH shim** 으로 "프로세스를 띄우지 않는다"를 증명한다 — 종전 테스트에는 그걸 증명할 수단이 아예 없었다.
+total++;
+{
+  let ok = false;
+  const _d = [];
+  let N1 = false, N2 = false, N3 = false, N4 = false, N5 = false;
+  try {
+    const shimDir = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-shim-')); _d.push(shimDir);
+    const shimLog = path.join(shimDir, 'calls.log');
+    const isWin = process.platform === 'win32';
+    //   codex 32차 #8: shim 이 codex 하나뿐이면 다른 provider 로 새는 회귀를 못 잡는다 — 배치된 provider 전부에 건다.
+    for (const binName of ['codex', 'claude']) {
+      if (isWin) fs.writeFileSync(path.join(shimDir, `${binName}.cmd`), `@echo off\r\n>>"${shimLog}" echo ${binName} %*\r\nif "%1"=="--version" (echo ${binName}-shim 1.0.0& exit /b 0)\r\necho Logged in using shim\r\nexit /b 0\r\n`);
+      else { const p = path.join(shimDir, binName); fs.writeFileSync(p, `#!/bin/sh\necho "${binName} $@" >> "${shimLog}"\nif [ "$1" = "--version" ]; then echo "${binName}-shim 1.0.0"; exit 0; fi\necho "Logged in using shim"\nexit 0\n`); try { fs.chmodSync(p, 0o755); } catch {} }
+    }
+    //   provider opt-in 을 **켠 상태**로 돌린다 — 그래야 "확정에서는 실행된다"는 대조가 성립하고,
+    //   아래 N1b 가 "끄면 실행되지 않는다"를 별도로 확인한다(문서화된 opt-out 의 실제 검증).
+    const env = Object.assign({}, process.env, {
+      PATH: shimDir + path.delimiter + process.env.PATH,
+      LEERNESS_ENABLE_CODEX: '1', LEERNESS_ENABLE_CLAUDE: '1',
+    });
+    const envOff = Object.assign({}, env, { LEERNESS_ENABLE_CODEX: '0', LEERNESS_ENABLE_CLAUDE: '0' });
+    const RS = (a, e) => { const r = cp.spawnSync(process.execPath, [CLI, ...a], { encoding: 'utf8', timeout: 120000, env: e || env }); return { s: r.status, o: ((r.stdout || '') + (r.stderr || '')).trim() }; };
+    const calls = () => { try { return fs.readFileSync(shimLog, 'utf8').trim().split('\n').filter(Boolean).length; } catch { return 0; } };
+    const clear = () => { try { fs.rmSync(shimLog, { force: true }); } catch {} };
+
+    const d = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-h2-')); _d.push(d);
+    RS(['init', d, '--yes', '--language', 'ko', '--no-stale-check']);
+    ['commander', 'coder', 'architect'].forEach(x => RS(['roles', 'set', x, '--provider', 'codex', '--path', d]));
+    RS(['roles', 'set', 'reviewer', '--provider', 'claude', '--path', d]);
+    // N1: **제안은 외부 프로세스를 띄우지 않는다**(동의 전 실행 금지). 확정에서는 띄운다 — 판별 대조.
+    clear(); RS(['agents', 'route', 'implement oauth token refresh', '--path', d]);
+    const suggestCalls = calls();
+    clear(); RS(['agents', 'route', 'implement oauth token refresh', '--path', d, '--json']);
+    const suggestJsonCalls = calls();
+    RS(['toggle', 'set', 'difficulty-routing', 'on', '--path', d]);
+    clear(); RS(['agents', 'route', 'implement oauth token refresh', '--confirm', '--approved-by', '검증자', '--path', d]);
+    const confirmCalls = calls();
+    //   N1b: **문서화된 opt-out 을 실제로 지키는지** — LEERNESS_ENABLE_* 를 끄면 확정에서도 띄우지 않는다.
+    //   (종전엔 이 플래그가 이 경로에서 완전한 no-op 이라, 외부 도구를 껐다고 믿는 사용자 환경에서 CLI 가 돌았다.)
+    clear(); RS(['agents', 'route', 'implement oauth token refresh', '--confirm', '--approved-by', '검증자', '--path', d], envOff);
+    const optOutCalls = calls();
+    N1 = suggestCalls === 0 && suggestJsonCalls === 0 && confirmCalls > 0 && optOutCalls === 0;
+    // N2: "확인 안 함"과 "확인 수단 없음"을 구분해 말한다(같은 provider 가 등급에 따라 갈리던 오귀인)
+    const tinyOut = RS(['agents', 'route', 'fix typo in button label', '--path', d]).o;
+    N2 = /이 등급에서는 확인하지 않음/.test(tinyOut)
+      && !/무료·비대화형 확인 명령이 있는 provider 만 판정한 결과/.test(tinyOut)
+      && /버전 확인과 로그인 상태 명령을 실행/.test(RS(['agents', 'route', '--log', '--path', d]).o);
+    // N3: 규칙이 못 읽는 문자 체계가 섞이면 tiny 로 내리지 않는다(결제·인증이 tiny 로 확정되던 구멍)
+    const RTm = require(path.join(path.dirname(CLI), '..', 'lib', 'routing.js'));
+    N3 = RTm.classify('支付退款逻辑修改 css').tier === 'normal'
+      && RTm.classify('決済リファンド css 修正').tier === 'normal'
+      && RTm.classify('fix typo in css').tier === 'tiny'           // 대조군: 커버되는 언어는 그대로 tiny
+      //   전각 문자로 고위험 규칙을 우회할 수 있었다(ＰＡＹＭＥＮＴ → normal) — 매칭 전 NFKC 정규화
+      && RTm.classify('ＰＡＹＭＥＮＴ ｒｅｆｕｎｄ ｌｏｇｉｃ').tier === 'high-risk';
+    // N4: bugfix start 가 위치 경로를 인식한다(cwd 오염 없이 대상 프로젝트에 등록)
+    const d2 = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-h2b-')); _d.push(d2);
+    RS(['init', d2, '--yes', '--language', 'ko', '--no-stale-check']);
+    const aid = ((RS(['task', 'add', '대상 작업', '--path', d2, '--json', '--no-review']).o.match(/"id"\s*:\s*"([^"]+)"/)) || [])[1];
+    fs.writeFileSync(path.join(d2, 'app.js'), 'console.error("BUG_HERE"); process.exit(3);');
+    const stRes = RS(['bugfix', 'start', aid, '--repro', 'node app.js', '--expect-bad', 'BUG_HERE', d2]);
+    N4 = stRes.s === 0 && fs.existsSync(path.join(d2, '.harness', 'bugfix-receipts.json'));
+    // N5: Bearer/Basic 토큰 마스킹 + 손상 토글 무경고 금지
+    const red = require(path.join(path.dirname(CLI), '..', 'lib', 'pure-utils.js')).redactSecrets;
+    const maskOk = !red('Authorization: Bearer sk-live-ABCDEFGH12345', 200).includes('sk-live-ABCDEFGH12345')
+      && !red('curl -H "Authorization: Basic dXNlcjpwYXNz" api', 200).includes('dXNlcjpwYXNz');
+    fs.writeFileSync(path.join(d, '.harness', 'toggles.json'), '{손상');
+    const tl = RS(['toggle', 'list', '--path', d]);
+    let tj = null; try { const o = RS(['toggle', 'list', '--path', d, '--json']).o; tj = JSON.parse(o.slice(o.indexOf('{'))); } catch {}
+    //   감사 기록은 **입력 원문**(분류용 정규화본이 아님)을 남기되, git 추적 파일이므로 시크릿은 가린다
+    const d3 = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-h2c-')); _d.push(d3);
+    RS(['init', d3, '--yes', '--language', 'ko', '--no-stale-check']);
+    RS(['agents', 'route', 'ＰＡＹＭＥＮＴ 수정 API_TOKEN=sk-live-SECRET123', '--path', d3]);
+    const lgRaw = fs.readFileSync(path.join(d3, '.harness', 'routing-log.json'), 'utf8');
+    const auditOk = !/sk-live-SECRET123/.test(lgRaw) && /API_TOKEN=\*\*\*/.test(lgRaw) && /ＰＡＹＭＥＮＴ/.test(lgRaw);
+    N5 = maskOk && auditOk && /toggles\.json 손상/.test(tl.o) && !!tj && tj.corrupt === true;
+    ok = N1 && N2 && N3 && N4 && N5;
+    if (!ok) console.log(`   [헌트5 디버그] 제안무실행=${N1}(제안 ${suggestCalls}/${suggestJsonCalls} · 확정 ${confirmCalls} · optout ${optOutCalls}) 사유구분=${N2} 다국어=${N3} 위치경로=${N4} 마스킹+손상고지=${N5}`);
+  } catch (e) { console.log('   [헌트5 디버그] 예외: ' + ((e && e.message) || e)); }
+  finally { _d.forEach(x => { try { fs.rmSync(x, { recursive: true, force: true }); } catch {} }); }
+  console.log(ok ? '✓ B(1.36.92) 신규표면 헌트 5건: 제안은 외부 프로세스 0회(PATH shim 증명)·확정에서만 실행 · 인증 미확인 사유 구분 · 미커버 문자체계는 tiny 금지 · bugfix 위치경로 인식 · Bearer 마스킹 + 손상 토글 경고' : '✗ 신규표면 헌트 5건 실패');
+  if (!ok) failed++;
+}
+
 // 1.36.76 (9차 헌트 이월 3건 종결): 손상 아카이브 복원 거부 · MCP read-only 무변형 · 긴 파생 id 안전화
 total++;
 {