leerness 1.9.303 → 1.9.305

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # Changelog
 
+## 1.9.305 — 2026-06-04 — honesty-check: AI 인식론적 정직성 점검 (사용자 명시)
+
+**🧠 사용자 요청 — AI 가 (1) 모르는 걸 아는 척, (2) 정보를 안 모으고, (3) 검증 없이 섣부르게 판단하는지를 점검하는 인식론적 정직성 가드 신설.**
+
+### 배경 (사용자 명시)
+"AI 가 모르는 정보를 아는 척하지 않는지 / 모르는 정보를 알기 위해 정확한 정보를 수집하는지 / 수집 후 검증 없이 섣부른 판단을 하지 않는지" 점검 요청. 기존 leerness 는 부분 커버만: `optimism-check`(행동 주장 vs 코드 흔적, 11종), `api-skill`(외부 문서 수집, opt-in), `verify-claim`(검증). **3차원을 통합 점검하는 정직성 가드는 없었음.**
+
+### 구현
+1. **`_epistemicHonestyCheck(text)`** (lib/analyzers.js, 순수) — 3차원 휴리스틱:
+   - **pretend-knowledge**(high) — 단정 표현(반드시/항상/100%/always…)인데 근거·출처(파일/문서/테스트/로그) 없음
+   - **premature-judgment**(high) — 추정 표현(아마/추정/probably/should…) + 완료·성공 결론인데 검증 근거 없음
+   - **no-info-gathering**(med) — 외부 API/버전/스펙 언급인데 수집 흔적(공식문서/api-skill/조회) 없음 (파일경로 `api.js` 오탐 제외)
+2. **`leerness honesty-check <T-ID> | --text "<주장>"`** — 양호 시 exit 0, high 발견 시 exit 1(에이전트 self-gate). `--json`.
+3. **MCP `leerness_honesty_check` (82번째 도구, read-only)** — 에이전트가 단언 전 자기 주장 self-check.
+4. **`verify-claim --strict-claims` 통합** — high-severity 정직성 발견도 strict 실패에 반영(낙관 + 정직성 통합 게이트).
+5. selftest 52→53 · e2e 249→250.
+
+### 검증
+- **selftest 53/53 PASS** · **E2E 250/250 PASS** (회귀 0).
+- 실측: "이 기능은 항상 동작"→pretend-knowledge(exit1), "아마 될 것 같다. 완료"→premature-judgment, "이 API rate limit 초당 5회"→no-info-gathering, "src/api.js 수정 12/12 통과(Exit:0)"→양호(exit0). 오탐 0(6/6 케이스).
+- 휴리스틱 advisory — 근거(파일·문서·테스트·로그)나 수집 흔적(공식문서·api-skill·조회) 명시 시 해소.
+
+## 1.9.304 — 2026-06-04 — UR-0025 (6단계): 순수 분석/검증 함수 → lib/analyzers.js 모듈 분리
+
+**🧩 모놀리스 분리 계속 — 순수 분석/검증 함수 4종을 비파괴 분리. lib 6모듈 체제(630줄 외부화).**
+
+### 배경
+외부 리뷰 핵심(UR-0038~0043) 완료 후, 두 리뷰 공통 지적인 단일 대형 파일을 계속 점진 분리. 데이터 카탈로그(1~5단계) 다음으로 **순수 함수**(부작용 0, 입력→출력) 클러스터를 분리.
+
+### 구현 (UR-0025 6단계)
+1. **`lib/analyzers.js` 신설** — 순수 분석/검증 함수 4종(62줄):
+   - `_evidenceQuality`(evidence 완전성: 파일/테스트/로그 근거)
+   - `_parseEvidenceStats`(review-evidence pass/fail 집계)
+   - `_shellGuardAnalyze`(셸 호환성 6규칙 정적 분석)
+   - `_claimFileInGit`(verify-claim git 교차검증 매칭)
+2. **비파괴 require-based 분리** — verify-claim/shell-guard/review-evidence 소비처는 동일 바인딩. 모두 순수(내부 의존 0) 검증.
+3. **harness.js 21686→21630줄**. lib 6모듈: pure-utils+agent-registry+role-catalog+catalogs+mcp-tools+analyzers = 630줄 외부화.
+4. selftest 51→52 (4함수 동일참조 단일출처 + 인라인 제거) · e2e 248→249 (모듈 standalone + shell-guard 동작 회귀).
+
+### 검증
+- **selftest 52/52 PASS** · **E2E 249/249 PASS** (회귀 0).
+- 기존 selftest(_evidenceQuality/_parseEvidenceStats/_shellGuardAnalyze ×2/_claimFileInGit)가 추출 정합성 즉시 검증.
+- `shell-guard "a && b" --json` 정상 동작(모듈 분리 후 회귀 없음).
+
 ## 1.9.303 — 2026-06-04 — UR-0043: 상태 파일 lost-update 락 (외부 AI 리뷰 — 멀티에이전트 안전 완성)
 
 **🔐 원자적 쓰기(UR-0038)가 막지 못한 동시 read-modify-write lost-update를 advisory 락으로 차단. Codex/Opus가 지적한 "상태 쓰기에 락 0건" 해소 — 멀티에이전트 동시 쓰기 안전성 완성.**

package/README.md

@@ -3,7 +3,7 @@
 > **AI 코딩 에이전트의 거짓 완료·중복·망각·충돌을 막아주는 검수·기억·협업 CLI 하네스.**
 > **A CLI harness that stops AI coding agents from faking completion, duplicating work, forgetting context, and colliding.**
 
-[![npm](https://img.shields.io/badge/npm-leerness-blue)](https://www.npmjs.com/package/leerness) [![version](https://img.shields.io/badge/version-1.9.303-green)]() [![tests](https://img.shields.io/badge/e2e-248%2F248-success)]() [![selftest](https://img.shields.io/badge/selftest-51-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-81-brightgreen)]() [![providers](https://img.shields.io/badge/AI_providers-10-brightgreen)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
+[![npm](https://img.shields.io/badge/npm-leerness-blue)](https://www.npmjs.com/package/leerness) [![version](https://img.shields.io/badge/version-1.9.305-green)]() [![tests](https://img.shields.io/badge/e2e-250%2F250-success)]() [![selftest](https://img.shields.io/badge/selftest-53-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-82-brightgreen)]() [![providers](https://img.shields.io/badge/AI_providers-10-brightgreen)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
 
 ```
   ╔══════════════════════════════════════════════════════════════╗
@@ -471,7 +471,7 @@ MIT — © leerness contributors
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.9.303 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.9.305 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
 
 ### 정체성 — AI 에이전트 운영 레이어 (UR-0030)
 
@@ -525,7 +525,7 @@ leerness memory restore decision <date|title>
 
 ### MCP server (외부 AI 통합)
 
-Leerness v1.9.303는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **81개 도구**를 노출:
+Leerness v1.9.305는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **82개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -538,7 +538,7 @@ Leerness v1.9.303는 stdio JSON-RPC MCP server를 내장합니다 — Claude Cod
 // • Workflow: session_close / agents_list / task_export / env_check / usage_stats / reuse_map / whats_new
 
 // MCP server 실행: leerness mcp serve
-// tools/list 응답: 81 도구
+// tools/list 응답: 82 도구
 ```
 
 ### Autonomous mode (자율 모드)
@@ -546,7 +546,7 @@ Leerness v1.9.303는 stdio JSON-RPC MCP server를 내장합니다 — Claude Cod
 `<<autonomous-loop-dynamic>>` 신호만 보내면 AI가:
 1) 다음 라운드 후보 선정 → 2) 코드 변경 → 3) stress-v* 신규 작성 + 누적 회귀 → 4) e2e 219/219 → 5) npm pack + git tag + GitHub release → 6) main 자동 push (1.9.140+) → 7) session close → 8) 다음 라운드 예약.
 
-현재 누적: **70 라운드 (1.9.40 → 1.9.303)** · 매 라운드 GitHub release/태그 생성 · _reports/는 비공개 보존.
+현재 누적: **70 라운드 (1.9.40 → 1.9.305)** · 매 라운드 GitHub release/태그 생성 · _reports/는 비공개 보존.
 
 ### 성능 가이드 (1.9.140 측정)
 
@@ -584,6 +584,6 @@ 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.9.303: 2026-06-04
+Last synced by Leerness v1.9.305: 2026-06-04
 <!-- leerness:project-readme:end -->
 

package/bin/harness.js

@@ -9,10 +9,12 @@ const readline = require('readline');
 // 1.9.274 (UR-0025 1단계): 순수 유틸 함수 모듈 분리 (require-based, 비파괴). selftest 7종이 동작 검증.
 const { _isSecretKey, compareVer, parseHarnessVersion, _classifyCJK, _riskLabel, _detectSystemLang, _parseSlashFromHelp,
   PERMISSION_TIERS, _tierRank, _requiredTier, _policyAllows, _resolveNpmTag, _mcpJsonContent, _newRunRecord } = require('../lib/pure-utils');
+// 1.9.304 (UR-0025): 순수 분석/검증 함수 모듈 분리.
+const { _evidenceQuality, _parseEvidenceStats, _shellGuardAnalyze, _claimFileInGit, _epistemicHonestyCheck } = require('../lib/analyzers');
 // 1.9.295 (UR-0025 4단계): 정적 데이터 카탈로그 모듈 분리 (비파괴, require-based).
 const { CAPABILITY_SURFACE, POWERFUL_COMMANDS, ADAPTERS, REUSE_CATEGORIES, REUSE_CHECKLIST } = require('../lib/catalogs');
 
-const VERSION = '1.9.303';
+const VERSION = '1.9.305';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -3068,6 +3070,8 @@ function _selfTestCases() {
     { name: 'MCP requiredTier 메타데이터 + 정책 minTier 게이트 (UR-0041 외부리뷰 1.9.301)', run: () => { const T = require('../lib/mcp-tools'); const allValid = T.length >= 81 && T.every(t => PERMISSION_TIERS.includes(t.requiredTier)); const get = n => (T.find(t => t.name === n) || {}).requiredTier; const classOk = get('leerness_state_record') === 'safe-write' && get('leerness_provider_add') === 'safe-write' && get('leerness_web') === 'network' && get('leerness_handoff') === 'read-only' && get('leerness_audit') === 'read-only'; const src = read(__filename); const gateOk = /_tierRank\(minTier\) > _tierRank\(required\)/.test(src) && /_policyEnforce\(targetPath, cliArgs\.join\(' '\), _toolDef/.test(src); return allValid && classOk && gateOk; } },
     { name: 'verify-claim git diff 시맨틱 교차검증: _gitChangedFiles/_claimFileInGit + strict FAIL 통합 (UR-0042 외부리뷰 1.9.302)', run: () => { const fnOk = typeof _gitChangedFiles === 'function' && typeof _claimFileInGit === 'function'; const matchOk = _claimFileInGit('src/api.js', new Set(['src/api.js'])) === true && _claimFileInGit('./src/api.js', new Set(['src/api.js'])) === true && _claimFileInGit('other.js', new Set(['src/api.js'])) === false && _claimFileInGit('x', null) === null; const src = read(__filename); const wired = /git diff 교차검증/.test(src) && /\|\| !gitClaimOk/.test(src) && /_gitChangedFiles\(root\)/.test(src); return fnOk && matchOk && wired; } },
     { name: '_withLock/_updateRun: lost-update 락(O_EXCL+재진입) + 적용 (UR-0043 외부리뷰 1.9.303)', run: () => { const src = read(__filename); const fnOk = typeof _withLock === 'function' && typeof _sleepSyncMs === 'function' && typeof _updateRun === 'function'; const reentrant = /if \(_heldLocks\.has\(lockPath\)\) return fn\(\)/.test(src); const excl = /fs\.openSync\(lockPath, 'wx'\)/.test(src); const applied = /const id = _withLock\(progressPath\(root\)/.test(src) && /_updateRun\(root, curId/.test(src); return fnOk && reentrant && excl && applied; } },
+    { name: 'lib/analyzers: 분석/검증 함수 4종 모듈 단일출처 분리 (UR-0025 1.9.304)', run: () => { const m = require('../lib/analyzers'); return m._evidenceQuality === _evidenceQuality && m._shellGuardAnalyze === _shellGuardAnalyze && m._parseEvidenceStats === _parseEvidenceStats && m._claimFileInGit === _claimFileInGit && !/function _evidenceQuality\(evidence\) \{/.test(read(__filename)) && !/function _shellGuardAnalyze\(cmd, ctx\) \{/.test(read(__filename)); } },
+    { name: 'honesty-check: AI 인식론적 정직성 3차원 + MCP/CLI/strict 통합 (사용자명시 1.9.305)', run: () => { const h = _epistemicHonestyCheck; const d1 = h('이 기능은 항상 정상 동작합니다').findings.some(f => f.dim === 'pretend-knowledge'); const d2 = h('아마 될 것 같습니다. 구현 완료했습니다').findings.some(f => f.dim === 'premature-judgment'); const d3 = h('이 API 의 rate limit 은 초당 5회입니다').findings.some(f => f.dim === 'no-info-gathering'); const clean = h('src/api.js 수정, 12/12 통과 (Exit: 0)').ok === true; const src = read(__filename); const wired = require('../lib/mcp-tools').some(t => t.name === 'leerness_honesty_check') && /if \(cmd === 'honesty-check'\)/.test(src) && /honestyFindings = _epistemicHonestyCheck/.test(src); return d1 && d2 && d3 && clean && wired; } },
     { name: 'VERSION 형식 (x.y.z)', run: () => /^\d+\.\d+\.\d+$/.test(VERSION) }
   ];
 }
@@ -3111,38 +3115,7 @@ function selfTestCmd(opts = {}) {
 //   leerness 는 셸을 직접 가로챌 수 없으므로(0-dep Node CLI) → 실행 전 정적 분석 + 실패 기록/회수로 대응.
 //   ctx: { shell: 'powershell'|'cmd'|'bash'|'sh', psVersion: '5'|'7'|null }
 //   반환: { shell, psVersion, issues: [{ rule, severity, detail, suggestion }] } — 순수 함수 (단위 테스트 가능)
-function _shellGuardAnalyze(cmd, ctx) {
-  const c = String(cmd || '');
-  const shell = (ctx && ctx.shell) || 'unknown';
-  const psVer = ctx && ctx.psVersion != null ? parseInt(ctx.psVersion, 10) : null;
-  const issues = [];
-  const isWinPowerShell = shell === 'powershell' && psVer != null && psVer < 6;  // 5.1 = Windows PowerShell
-  // 규칙 1: PowerShell 5.1 에서 && / || 체이닝 미지원 (pwsh 7+ 부터 지원)
-  if (isWinPowerShell && /\s&&\s|\s\|\|\s/.test(c)) {
-    issues.push({ rule: 'ps5-chain', severity: 'error', detail: 'Windows PowerShell 5.1 은 && / || 연산자를 지원하지 않습니다 (PowerShell 7+ 부터 지원).', suggestion: 'A; if ($?) { B }  (조건부) 또는 A; B  (무조건) 로 분리. 또는 pwsh 7 설치.' });
-  }
-  // 규칙 2: PowerShell 에서 2>/dev/null → 2>$null
-  if (shell === 'powershell' && /2>\s*\/dev\/null/.test(c)) {
-    issues.push({ rule: 'ps-devnull', severity: 'error', detail: 'PowerShell 은 /dev/null 경로가 없습니다.', suggestion: '2>$null 사용 (PowerShell 리다이렉트).' });
-  }
-  // 규칙 3: PowerShell 에서 inline env (VAR=val cmd) 미지원
-  if (shell === 'powershell' && /^[A-Z_][A-Z0-9_]*=[^\s]+\s+\S/.test(c.trim())) {
-    issues.push({ rule: 'ps-inline-env', severity: 'error', detail: 'PowerShell 은 VAR=val cmd 형식의 inline 환경변수를 지원하지 않습니다.', suggestion: "$env:VAR='val'; cmd  로 분리." });
-  }
-  // 규칙 4: PowerShell 에서 Unix 전용 명령 (rm -rf / ls -la 등) — 별칭은 되나 플래그 오류 가능
-  if (shell === 'powershell' && /\brm\s+-rf\b/.test(c)) {
-    issues.push({ rule: 'ps-rm-rf', severity: 'warn', detail: 'PowerShell 에서 rm -rf 는 -rf 플래그 파싱 오류 가능 (rm 은 Remove-Item 별칭).', suggestion: 'Remove-Item -Recurse -Force <path> 사용.' });
-  }
-  // 규칙 5: CMD 에서 ; 는 명령 구분자가 아님 (한 줄로 실행됨)
-  if (shell === 'cmd' && /;/.test(c) && !/&&|\|\|/.test(c)) {
-    issues.push({ rule: 'cmd-semicolon', severity: 'warn', detail: 'CMD 는 ; 를 명령 구분자로 처리하지 않습니다 (인자로 전달됨).', suggestion: 'A && B  (조건부) 또는 A & B  (무조건) 사용.' });
-  }
-  // 규칙 6: PowerShell 에서 && 가 있으나 버전 미상 — 정보성
-  if (shell === 'powershell' && psVer == null && /\s&&\s/.test(c)) {
-    issues.push({ rule: 'ps-version-unknown', severity: 'info', detail: 'PowerShell 버전 미상 — 5.1 이면 && 미지원, 7+ 이면 지원.', suggestion: '$PSVersionTable.PSVersion 확인. 안전하게 A; if ($?) { B } 권장.' });
-  }
-  return { shell, psVersion: psVer, issues };
-}
+// _shellGuardAnalyze → lib/analyzers.js (1.9.304 UR-0025)
 function _shellFailuresPath(root) { return path.join(absRoot(root), '.harness', 'shell-failures.json'); }
 function _loadShellFailures(root) {
   try { const f = _shellFailuresPath(root); if (!exists(f)) return { failures: [] }; const j = JSON.parse(read(f)); return j && Array.isArray(j.failures) ? j : { failures: [] }; } catch { return { failures: [] }; }
@@ -9435,17 +9408,7 @@ function reuseMapCmd(root) {
 // "src/foo.js + 5개 테스트 (54/54 통과)" 같은 주장을 파싱해 실제 파일/카운트 확인
 // 1.9.287 (Codex 리뷰 수렴): evidence 완전성 평가 — "테스트 통과만으로 done" 차단.
 //   done 주장은 (a) 수정 파일 경로 (b) 테스트명/개수 가 evidence 에 있어야 신뢰 가능. 순수 함수(selftest).
-function _evidenceQuality(evidence) {
-  const e = String(evidence || '');
-  const hasFile = /(?:[A-Za-z][\w-]*[\/\\])?[A-Za-z][\w./\\-]*\.(?:js|ts|tsx|jsx|mjs|cjs|py|go|rs|rb|kt|cs|gd|java|php|swift|c|cpp|h|html|css|scss|vue|svelte|json|yaml|yml|toml|md|sql|sh)\b/i.test(e);
-  const hasTest = /(\d+)\s*(?:\/\s*\d+\s*)?(?:통과|passed|passing|개\s*테스트)|\btests?\b\s*[:=]?\s*\d|Tests?:\s*\d|\b\d+\s*tests?\b/i.test(e);
-  const hasLog = /Exit\s*[:=]|exit\s*code|Command\s*[:=]|npm\s+(?:test|run)|pytest|cargo\s+test|go\s+test/i.test(e);
-  const missing = [];
-  if (!hasFile) missing.push('수정 파일 경로');
-  if (!hasTest) missing.push('테스트명/개수');
-  if (!hasLog) missing.push('실행 로그(Command/Exit)');
-  return { hasFile, hasTest, hasLog, ok: hasFile && hasTest, missing };
-}
+// _evidenceQuality → lib/analyzers.js (1.9.304 UR-0025)
 // 1.9.302 (UR-0042, 외부리뷰 Opus G-1): git 변경 파일 집합 — verify-claim 시맨틱 교차검증용.
 //   working tree(staged/unstaged/untracked) + 직전 커밋(HEAD~1..HEAD) 변경을 합쳐, "주장한 파일이 실제로 변경됐는가" 판정.
 //   git repo 아니거나 git 미설치면 null(검증 불가 → 페널티 X). 경로는 root-relative forward-slash.
@@ -9467,12 +9430,7 @@ function _gitChangedFiles(root) {
   } catch { return null; }
 }
 // 주장 파일이 git 변경 집합에 있는지(상대경로 prefix 차이 허용).
-function _claimFileInGit(claimed, gitSet) {
-  if (!gitSet) return null;
-  const c = String(claimed).replace(/\\/g, '/').replace(/^\.\//, '');
-  for (const g of gitSet) { if (g === c || g.endsWith('/' + c) || c.endsWith('/' + g)) return true; }
-  return false;
-}
+// _claimFileInGit → lib/analyzers.js (1.9.304 UR-0025)
 function verifyClaimCmd(root, taskId) {
   root = absRoot(root);
   if (!taskId) return fail('verify-claim <T-ID> 필요. 예: leerness verify-claim T-0008');
@@ -9648,10 +9606,13 @@ function verifyClaimCmd(root, taskId) {
   // 1.9.26: --strict-claims — 낙관적 표시 자동 감지 (evidence vs 코드 호출 흔적)
   let optimismSuspects = [];
   let strictOk = true;
+  let honestyFindings = [];
   if (has('--strict-claims')) {
     const codeText = _scanCodeForPatterns(root);
     optimismSuspects = _detectOptimism(evidence, codeText);
-    strictOk = optimismSuspects.length === 0;
+    // 1.9.305 (사용자 명시): 인식론적 정직성 high 발견(근거없는 단정/미검증 판단)도 strict 실패에 반영.
+    honestyFindings = _epistemicHonestyCheck(evidence).findings.filter(f => f.severity === 'high');
+    strictOk = optimismSuspects.length === 0 && honestyFindings.length === 0;
   }
 
   log('');
@@ -9665,10 +9626,11 @@ function verifyClaimCmd(root, taskId) {
     if (declaredPass) log(`  - 주장과 실행 결과 일치: ${declaredPassMatchesActual ? '✓ pass' : '⚠ 다름'}`);
   }
   if (has('--strict-claims')) {
-    if (strictOk) log(`  - 낙관적 표시 (--strict-claims): ✓ pass (의심 없음)`);
+    if (strictOk) log(`  - 낙관적 표시 + 정직성 (--strict-claims): ✓ pass (의심 없음)`);
     else {
-      log(`  - 낙관적 표시 (--strict-claims): ⚠ FAIL (${optimismSuspects.length}건 의심)`);
+      log(`  - 낙관적 표시 + 정직성 (--strict-claims): ⚠ FAIL (낙관 ${optimismSuspects.length} · 정직성 ${honestyFindings.length})`);
       for (const s of optimismSuspects) log(`    · [${s.kind}] ${s.label}: evidence에 주장 있는데 코드에 호출 흔적 없음`);
+      for (const f of honestyFindings) log(`    · [정직성:${f.dim}] ${f.label}: ${f.detail}`);
     }
   }
   // 1.9.302 (UR-0042): git diff 시맨틱 교차검증 — 주장한 파일이 실제 git 변경(working tree+직전커밋)에 있는가.
@@ -10293,6 +10255,33 @@ function _computeConfidence(evidence, codeText) {
   return Math.round(confidence * 100) / 100;
 }
 
+// 1.9.305 (사용자 명시): AI 인식론적 정직성 점검 — 모르는 걸 아는 척 / 정보 미수집 / 미검증 섣부른 판단.
+//   leerness honesty-check <T-ID>  또는  --text "<주장>". 휴리스틱 advisory, high-severity 시 exit 1(에이전트 self-gate).
+function honestyCheckCmd(root, arg1) {
+  root = absRoot(root || process.cwd());
+  const isTty = process.stdout && process.stdout.isTTY;
+  const cy = s => isTty ? `\x1b[36m${s}\x1b[0m` : s, gr = s => isTty ? `\x1b[32m${s}\x1b[0m` : s, rd = s => isTty ? `\x1b[31m${s}\x1b[0m` : s, dm = s => isTty ? `\x1b[2m${s}\x1b[0m` : s;
+  const textArg = arg('--text', null);
+  let subject = '', sourceLabel = '';
+  if (textArg) { subject = String(textArg); sourceLabel = '--text'; }
+  else if (arg1 && !arg1.startsWith('-')) {
+    const row = readProgressRows(root).find(r => r.id === arg1);
+    if (!row) { fail(`progress-tracker.md에 ${arg1} 없음.`); process.exitCode = 1; return; }
+    subject = row.evidence || ''; sourceLabel = `${arg1} evidence`;
+  } else { fail('사용법: leerness honesty-check <T-ID>  또는  leerness honesty-check --text "<주장>"'); process.exitCode = 1; return; }
+  const r = _epistemicHonestyCheck(subject);
+  const high = r.findings.filter(f => f.severity === 'high').length;
+  if (has('--json')) { log(JSON.stringify({ source: sourceLabel, ...r, highCount: high }, null, 2)); if (high > 0) process.exitCode = 1; return; }
+  log(cy(`# leerness honesty-check (1.9.305) — AI 인식론적 정직성 점검`));
+  log(dm(`  대상: ${sourceLabel} · "${subject.slice(0, 80)}${subject.length > 80 ? '…' : ''}"`));
+  log('');
+  if (r.ok) { log(gr('  ✓ 정직성 신호 양호 — 근거 없는 단정 / 미검증 섣부른 판단 / 외부정보 미수집 흔적 없음')); return; }
+  log(rd(`  ⚠ ${r.findings.length}건 발견:`));
+  for (const f of r.findings) { log(`  ${f.severity === 'high' ? '🔴' : '🟡'} [${f.dim}] ${f.label}`); log(dm(`     ${f.detail}`)); }
+  log('');
+  log(dm('  ℹ 휴리스틱 advisory — 근거(파일·문서·테스트·로그) 또는 수집 흔적(공식문서·api-skill·조회) 명시 시 해소.'));
+  if (high > 0) process.exitCode = 1;
+}
 function optimismCheckCmd(root, taskId) {
   root = absRoot(root || process.cwd());
   if (!taskId) return fail('optimism-check <T-ID> 필요. 예: leerness optimism-check T-0001');
@@ -16932,6 +16921,9 @@ function mcpServeCmd(root) {
           case 'leerness_about':
             cliArgs = ['about', '--json'];
             break;
+          case 'leerness_honesty_check':
+            cliArgs = ['honesty-check', ...(args.text ? ['--text', String(args.text)] : [String(args.taskId || '')]), '--path', targetPath, '--json'];
+            break;
           default:
             return send({ jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown tool: ${name}` } });
         }
@@ -18497,19 +18489,7 @@ function reuseCheckCmd(root, feature, opts = {}) {
 //   "설치한 스킬이 코딩 성능/정확도에 긍정 영향?" — 무거운 벤치 harness 가 아니라, 기존 데이터
 //   (skill 사용 빈도 + review-evidence 검증 통과율)를 상관(인과 아님)으로 advisory 제시. offline.
 // review-evidence.md 파싱 (순수) — 검증 항목 수 + pass/fail 추정 (Exit 0 / 'PASS' vs 'fail'/Exit !=0).
-function _parseEvidenceStats(text) {
-  const t = String(text || '');
-  const blocks = t.split(/\n(?=## )/).filter(b => /Command:|Exit:|verify|test/i.test(b));
-  let pass = 0, fail = 0;
-  for (const b of blocks) {
-    const exitM = b.match(/Exit:\s*(-?\d+)/i);
-    if (exitM) { (parseInt(exitM[1], 10) === 0 ? pass++ : fail++); continue; }
-    if (/\bPASS\b|통과|성공|✓/i.test(b)) pass++;
-    else if (/\bFAIL\b|실패|오류|error|✗/i.test(b)) fail++;
-  }
-  const entries = blocks.length;
-  return { entries, pass, fail, rate: (pass + fail) ? Math.round(pass / (pass + fail) * 100) : null };
-}
+// _parseEvidenceStats → lib/analyzers.js (1.9.304 UR-0025)
 function skillImpactCmd(root) {
   root = absRoot(root || process.cwd());
   const json = has('--json');
@@ -21334,6 +21314,7 @@ async function main() {
   if (cmd === 'deps')         return depsImpactCmd(arg('--path', process.cwd()), args[1]);
   if (cmd === 'register-pending') return registerPendingCmd(arg('--path', process.cwd()), args.slice(1).filter(x => !x.startsWith('-')));
   if (cmd === 'optimism-check') return optimismCheckCmd(arg('--path', process.cwd()), args[1]);
+  if (cmd === 'honesty-check') return honestyCheckCmd(arg('--path', process.cwd()), args[1]);
   if (cmd === 'persona') return personaCmd(arg('--path', process.cwd()), args[1], args[2]);
   if (cmd === 'review') return reviewCmd(arg('--path', process.cwd()), args[1]);
   if (cmd === 'agents') return agentsCmd(arg('--path', process.cwd()), args[1], ...args.slice(2));

package/lib/analyzers.js

@@ -0,0 +1,90 @@
+// lib/analyzers.js — 순수 분석/검증 함수 (부작용 0, 입력→출력).
+// 1.9.304 (UR-0025): bin/harness.js 에서 비파괴 분리. selftest(evidenceQuality/parseEvidenceStats/shellGuardAnalyze/claimFileInGit)가 동작 검증.
+'use strict';
+
+function _shellGuardAnalyze(cmd, ctx) {
+  const c = String(cmd || '');
+  const shell = (ctx && ctx.shell) || 'unknown';
+  const psVer = ctx && ctx.psVersion != null ? parseInt(ctx.psVersion, 10) : null;
+  const issues = [];
+  const isWinPowerShell = shell === 'powershell' && psVer != null && psVer < 6;  // 5.1 = Windows PowerShell
+  // 규칙 1: PowerShell 5.1 에서 && / || 체이닝 미지원 (pwsh 7+ 부터 지원)
+  if (isWinPowerShell && /\s&&\s|\s\|\|\s/.test(c)) {
+    issues.push({ rule: 'ps5-chain', severity: 'error', detail: 'Windows PowerShell 5.1 은 && / || 연산자를 지원하지 않습니다 (PowerShell 7+ 부터 지원).', suggestion: 'A; if ($?) { B }  (조건부) 또는 A; B  (무조건) 로 분리. 또는 pwsh 7 설치.' });
+  }
+  // 규칙 2: PowerShell 에서 2>/dev/null → 2>$null
+  if (shell === 'powershell' && /2>\s*\/dev\/null/.test(c)) {
+    issues.push({ rule: 'ps-devnull', severity: 'error', detail: 'PowerShell 은 /dev/null 경로가 없습니다.', suggestion: '2>$null 사용 (PowerShell 리다이렉트).' });
+  }
+  // 규칙 3: PowerShell 에서 inline env (VAR=val cmd) 미지원
+  if (shell === 'powershell' && /^[A-Z_][A-Z0-9_]*=[^\s]+\s+\S/.test(c.trim())) {
+    issues.push({ rule: 'ps-inline-env', severity: 'error', detail: 'PowerShell 은 VAR=val cmd 형식의 inline 환경변수를 지원하지 않습니다.', suggestion: "$env:VAR='val'; cmd  로 분리." });
+  }
+  // 규칙 4: PowerShell 에서 Unix 전용 명령 (rm -rf / ls -la 등) — 별칭은 되나 플래그 오류 가능
+  if (shell === 'powershell' && /\brm\s+-rf\b/.test(c)) {
+    issues.push({ rule: 'ps-rm-rf', severity: 'warn', detail: 'PowerShell 에서 rm -rf 는 -rf 플래그 파싱 오류 가능 (rm 은 Remove-Item 별칭).', suggestion: 'Remove-Item -Recurse -Force <path> 사용.' });
+  }
+  // 규칙 5: CMD 에서 ; 는 명령 구분자가 아님 (한 줄로 실행됨)
+  if (shell === 'cmd' && /;/.test(c) && !/&&|\|\|/.test(c)) {
+    issues.push({ rule: 'cmd-semicolon', severity: 'warn', detail: 'CMD 는 ; 를 명령 구분자로 처리하지 않습니다 (인자로 전달됨).', suggestion: 'A && B  (조건부) 또는 A & B  (무조건) 사용.' });
+  }
+  // 규칙 6: PowerShell 에서 && 가 있으나 버전 미상 — 정보성
+  if (shell === 'powershell' && psVer == null && /\s&&\s/.test(c)) {
+    issues.push({ rule: 'ps-version-unknown', severity: 'info', detail: 'PowerShell 버전 미상 — 5.1 이면 && 미지원, 7+ 이면 지원.', suggestion: '$PSVersionTable.PSVersion 확인. 안전하게 A; if ($?) { B } 권장.' });
+  }
+  return { shell, psVersion: psVer, issues };
+}
+function _evidenceQuality(evidence) {
+  const e = String(evidence || '');
+  const hasFile = /(?:[A-Za-z][\w-]*[\/\\])?[A-Za-z][\w./\\-]*\.(?:js|ts|tsx|jsx|mjs|cjs|py|go|rs|rb|kt|cs|gd|java|php|swift|c|cpp|h|html|css|scss|vue|svelte|json|yaml|yml|toml|md|sql|sh)\b/i.test(e);
+  const hasTest = /(\d+)\s*(?:\/\s*\d+\s*)?(?:통과|passed|passing|개\s*테스트)|\btests?\b\s*[:=]?\s*\d|Tests?:\s*\d|\b\d+\s*tests?\b/i.test(e);
+  const hasLog = /Exit\s*[:=]|exit\s*code|Command\s*[:=]|npm\s+(?:test|run)|pytest|cargo\s+test|go\s+test/i.test(e);
+  const missing = [];
+  if (!hasFile) missing.push('수정 파일 경로');
+  if (!hasTest) missing.push('테스트명/개수');
+  if (!hasLog) missing.push('실행 로그(Command/Exit)');
+  return { hasFile, hasTest, hasLog, ok: hasFile && hasTest, missing };
+}
+function _claimFileInGit(claimed, gitSet) {
+  if (!gitSet) return null;
+  const c = String(claimed).replace(/\\/g, '/').replace(/^\.\//, '');
+  for (const g of gitSet) { if (g === c || g.endsWith('/' + c) || c.endsWith('/' + g)) return true; }
+  return false;
+}
+function _parseEvidenceStats(text) {
+  const t = String(text || '');
+  const blocks = t.split(/\n(?=## )/).filter(b => /Command:|Exit:|verify|test/i.test(b));
+  let pass = 0, fail = 0;
+  for (const b of blocks) {
+    const exitM = b.match(/Exit:\s*(-?\d+)/i);
+    if (exitM) { (parseInt(exitM[1], 10) === 0 ? pass++ : fail++); continue; }
+    if (/\bPASS\b|통과|성공|✓/i.test(b)) pass++;
+    else if (/\bFAIL\b|실패|오류|error|✗/i.test(b)) fail++;
+  }
+  const entries = blocks.length;
+  return { entries, pass, fail, rate: (pass + fail) ? Math.round(pass / (pass + fail) * 100) : null };
+}
+
+// 1.9.305 (사용자 명시): AI 인식론적 정직성 점검 — 모르는 걸 아는 척 / 정보 미수집 / 미검증 섣부른 판단 휴리스틱 탐지.
+//   순수 함수(텍스트→findings). 휴리스틱 advisory — 단정/추정/외부참조 표현 vs 근거·수집 흔적 대조. opt-in 점검용.
+function _epistemicHonestyCheck(text) {
+  const t = String(text || '');
+  const findings = [];
+  // 공통: 근거/출처 흔적 (파일경로·URL·테스트결과·Exit·문서·api-skill·인용·조회 흔적)
+  const hasSource = /(?:[\w./-]+\.(?:js|ts|tsx|jsx|py|go|rs|rb|md|json|ya?ml|toml|sql|sh)\b)|https?:\/\/|\bExit\s*[:=]|\d+\s*\/\s*\d+\s*(?:통과|passed)|\b(?:passed|passing)\b|근거[:：]|출처[:：]|api-skill|공식\s*문서|문서\s*(?:확인|참조|에\s*따르면)|읽었|조회(?:함|했|함\b)|확인(?:함|했|됨)|grep|로그[:：]/i.test(t);
+  // 차원1: 모르는 걸 아는 척 — 단정 표현인데 근거 없음
+  const definitive = /(반드시|항상|언제나|무조건|확실(?:히|함|하게)|당연히|틀림없|100\s*%|always|never|guaranteed|definitely|obviously|certainly)/i.test(t);
+  if (definitive && !hasSource) findings.push({ dim: 'pretend-knowledge', severity: 'high', label: '근거 없는 단정', detail: '단정적 표현이 있으나 근거/출처(파일·문서·테스트·로그)가 없음 — 모르는 정보를 아는 척할 위험.' });
+  // 차원2: 미검증 섣부른 판단 — 추정 표현 + 완료/성공 결론인데 근거 없음
+  const assumption = /(아마|추정|것\s*같|듯\s*(?:하|싶)|probably|likely|maybe|perhaps|i\s*(?:think|assume|guess|believe|suppose)|should\s*(?:work|be|pass|fix)|생각(?:됩니다|된다|함|돼)|일\s*것|예상(?:됩니다|된다|됨)|짐작)/i.test(t);
+  const conclusion = /(완료|done|성공|통과|해결(?:됨|했|함|되었)|fixed|resolved|works?\b|작동(?:함|한다|됨)|구현(?:됨|했|완료))/i.test(t);
+  if (assumption && conclusion && !hasSource) findings.push({ dim: 'premature-judgment', severity: 'high', label: '검증 없는 섣부른 판단', detail: '가정·추정 표현과 완료·성공 결론이 함께 있으나 검증 근거가 없음 — 검증 없이 섣부르게 판단할 위험.' });
+  // 차원3: 정보 미수집 — 외부 API/라이브러리/버전/스펙 언급인데 수집·근거 흔적 없음
+  //   \bAPI\b(?!\.[a-z]) 로 파일경로(api.js/api.ts) 오탐 제외. 강한 근거(hasSource)나 수집 흔적(gathered) 있으면 통과.
+  const externalRef = /(\bAPI\b(?!\.[a-z])|\bSDK\b|라이브러리|\blibrary\b|\bpackage\b|엔드포인트|\bendpoint\b|버전\s*\d|v\d+\.\d+|\bspec\b|rate\s*limit|레이트\s*리밋|문서에\s*따르면)/i.test(t);
+  const gathered = /(https?:\/\/|api-skill|공식\s*문서|\bdocs?\b|문서\s*(?:확인|참조|읽)|읽었|조회(?:함|했)|확인(?:함|했|됨)|fetch|검색(?:함|했)|레퍼런스|reference)/i.test(t);
+  if (externalRef && !gathered && !hasSource) findings.push({ dim: 'no-info-gathering', severity: 'medium', label: '외부 정보 미수집', detail: '외부 API/라이브러리/버전/스펙 언급이 있으나 정보 수집(공식문서·api-skill·조회) 흔적이 없음 — 정확한 정보를 먼저 수집 권장.' });
+  return { ok: findings.length === 0, findings, dimensions: ['pretend-knowledge', 'premature-judgment', 'no-info-gathering'] };
+}
+
+module.exports = { _evidenceQuality, _parseEvidenceStats, _shellGuardAnalyze, _claimFileInGit, _epistemicHonestyCheck };

package/lib/mcp-tools.js

@@ -85,5 +85,6 @@ module.exports = [
   { name: 'leerness_state_verify', requiredTier: 'safe-write', description: '1.9.279 (UR-0031) — request_verification / verify_done. 현재 run 의 검증 결과 기록. 인자: { path?, result (required: "pass"|"fail"), note? }. 응답: { verified, result, run }.', inputSchema: { type: 'object', properties: { path: { type: 'string' }, result: { type: 'string', enum: ['pass', 'fail'] }, note: { type: 'string' } }, required: ['result'] } },
   { name: 'leerness_state_handoff', requiredTier: 'safe-write', description: '1.9.279 (UR-0031) — create_handoff / make_handoff. 현재 run 을 마감하고 다음 에이전트용 .leerness/handoff/latest.{md,json} 작성 (Claude→Goose→Codex 인수인계 표준). 인자: { path?, summary (required) }. 응답: { handoff, run }.', inputSchema: { type: 'object', properties: { path: { type: 'string' }, summary: { type: 'string' } }, required: ['summary'] } },
   { name: 'leerness_get_project_context', requiredTier: 'read-only', description: '1.9.292 (UR-0031) — get_project_context. 외부 에이전트가 작업 시작 전 단 1콜로 "지금 무엇을 알아야 하는가"를 파악하는 집약 컨텍스트. 여러 소스(현재 작업/미답 사용자 요청/최근 결정/활성 룰/next-actions/memory surface/프로젝트 의도)를 한 번에 구조화 회수. read-only. 인자: { path? }. 응답: { version, project, currentTask, openRequests, recentDecisions, activeRules, nextActions, memory }.', inputSchema: { type: 'object', properties: { path: { type: 'string' } } } },
-  { name: 'leerness_about', requiredTier: 'read-only', description: '1.9.296 (UR-0030) — leerness 정체성/포지셔닝 회수. leerness 가 무엇인가: "AI 에이전트 운영 레이어"(실행기 아님) — 기억·정책·인수인계·검증·감사 5계층. read-only. 어떤 에이전트든 "이 도구가 무엇이고 무엇을 보완하는가"를 1콜로 파악. 응답: { identity, isNot, tagline, layers[], complements, entryPoints, surface }.', inputSchema: { type: 'object', properties: {} } }
+  { name: 'leerness_about', requiredTier: 'read-only', description: '1.9.296 (UR-0030) — leerness 정체성/포지셔닝 회수. leerness 가 무엇인가: "AI 에이전트 운영 레이어"(실행기 아님) — 기억·정책·인수인계·검증·감사 5계층. read-only. 어떤 에이전트든 "이 도구가 무엇이고 무엇을 보완하는가"를 1콜로 파악. 응답: { identity, isNot, tagline, layers[], complements, entryPoints, surface }.', inputSchema: { type: 'object', properties: {} } },
+  { name: 'leerness_honesty_check', requiredTier: 'read-only', description: '1.9.305 (사용자 명시) — AI 인식론적 정직성 점검. 주장/evidence 텍스트가 (1) 모르는 걸 아는 척(근거 없는 단정), (2) 검증 없는 섣부른 판단(추정+완료 결론), (3) 외부 정보 미수집(API/버전/스펙 언급+수집흔적 없음) 중 무엇에 해당하는지 휴리스틱 탐지. read-only. 에이전트가 자기 주장을 단언 전 self-check. 인자: { path?, taskId?, text? }. 응답: { ok, findings[], dimensions[], highCount }.', inputSchema: { type: 'object', properties: { path: { type: 'string' }, taskId: { type: 'string' }, text: { type: 'string' } } } }
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.9.303",
+  "version": "1.9.305",
   "description": "Leerness: 비파괴 마이그레이션, 자동 버전 감지·업데이트, 계획/진행/핸드오프 자동화, 게으름·시크릿·인코딩 자동 가드, Claude Code 슬래시 통합을 갖춘 한국어 우선 AI 개발 하네스.",
   "keywords": [
     "leerness",

package/scripts/e2e.js

@@ -654,7 +654,7 @@ total++;
   fs.appendFileSync(path.join(tmpS, '.harness/progress-tracker.md'),
     '| T-0050 | done | DB 마이그레이션 | 사용자 데이터 DB에 저장, 1000건 insert 성공 | (완료) | 2026-05-15 |\n');
   const r = cp.spawnSync(process.execPath, [CLI, 'verify-claim', 'T-0050', '--path', tmpS, '--strict-claims'], { encoding: 'utf8', timeout: 10000 });
-  const ok = r.status !== 0 && /낙관적 표시 \(--strict-claims\): ⚠ FAIL/.test(r.stdout) && /DB 호출/.test(r.stdout);
+  const ok = r.status !== 0 && /낙관적 표시.*\(--strict-claims\): ⚠ FAIL/.test(r.stdout) && /DB 호출/.test(r.stdout);
   console.log(ok ? '✓ B(1.9.26) verify-claim --strict-claims: DB 거짓 evidence 통합 감지' : '✗ --strict-claims 실패');
   if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
 }
@@ -3432,5 +3432,50 @@ total++;
   if (!ok) failed++;
 }
 
+// 1.9.304 회귀 (UR-0025): lib/analyzers.js 모듈 분리 — 단일출처 + 부작용 0 + 소비 명령 회귀
+total++;
+{
+  let ok = false;
+  try {
+    const a = require(path.resolve(__dirname, '..', 'lib', 'analyzers.js'));
+    const dataOk = typeof a._evidenceQuality === 'function' && typeof a._parseEvidenceStats === 'function' &&
+      typeof a._shellGuardAnalyze === 'function' && typeof a._claimFileInGit === 'function' &&
+      a._evidenceQuality('src/api.js 수정, 12/12 통과 (Exit: 0)').ok === true &&
+      a._shellGuardAnalyze('a && b', { shell: 'powershell', psVersion: '5' }).issues.some(i => i.rule === 'ps5-chain') &&
+      a._claimFileInGit('src/api.js', new Set(['src/api.js'])) === true;
+    const harnessSrc = fs.readFileSync(path.resolve(__dirname, '..', 'bin', 'harness.js'), 'utf8');
+    const movedOut = !/function _evidenceQuality\(evidence\) \{/.test(harnessSrc) && !/function _shellGuardAnalyze\(cmd, ctx\) \{/.test(harnessSrc) && /require\('\.\.\/lib\/analyzers'\)/.test(harnessSrc);
+    // 소비 명령 회귀: shell-guard (_shellGuardAnalyze 사용)
+    const sg = cp.spawnSync(process.execPath, [CLI, 'shell-guard', 'a && b', '--json'], { cwd: tmp, encoding: 'utf8', timeout: 20000 });
+    const cmdOk = sg.status === 0 && /"shell"/.test(sg.stdout || '');
+    ok = dataOk && movedOut && cmdOk;
+  } catch {}
+  console.log(ok ? '✓ B(1.9.304) lib/analyzers 모듈 분리: 단일출처 + 인라인 제거 + shell-guard 동작 (UR-0025)' : '✗ analyzers 모듈 분리 실패');
+  if (!ok) failed++;
+}
+
+// 1.9.305 회귀 (사용자 명시): honesty-check — AI 인식론적 정직성 3차원 + exit code + MCP 노출
+total++;
+{
+  let ok = false;
+  try {
+    // 양호(근거 있음) → exit 0 + ✓
+    const good = cp.spawnSync(process.execPath, [CLI, 'honesty-check', '--text', 'src/api.js 수정, 12/12 통과 (Exit: 0)'], { cwd: tmp, encoding: 'utf8', timeout: 15000 });
+    const goodOk = good.status === 0 && /정직성 신호 양호/.test(good.stdout || '');
+    // 근거 없는 단정 → exit 1 + pretend-knowledge
+    const bad1 = cp.spawnSync(process.execPath, [CLI, 'honesty-check', '--text', '이 기능은 항상 정상 동작합니다', '--json'], { cwd: tmp, encoding: 'utf8', timeout: 15000 });
+    const b1 = JSON.parse(bad1.stdout); const bad1Ok = bad1.status === 1 && b1.findings.some(f => f.dim === 'pretend-knowledge');
+    // 미검증 섣부른 판단 → premature-judgment
+    const bad2 = cp.spawnSync(process.execPath, [CLI, 'honesty-check', '--text', '아마 될 것 같습니다. 구현 완료했습니다', '--json'], { cwd: tmp, encoding: 'utf8', timeout: 15000 });
+    const bad2Ok = JSON.parse(bad2.stdout).findings.some(f => f.dim === 'premature-judgment');
+    // MCP tools/list 에 노출
+    const ml = cp.spawnSync(process.execPath, [CLI, 'mcp', 'serve'], { cwd: tmp, encoding: 'utf8', timeout: 15000, input: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list' }) + '\n' });
+    const mcpOk = JSON.parse(ml.stdout.split('\n').filter(Boolean)[0]).result.tools.some(t => t.name === 'leerness_honesty_check');
+    ok = goodOk && bad1Ok && bad2Ok && mcpOk;
+  } catch {}
+  console.log(ok ? '✓ B(1.9.305) honesty-check: 3차원 탐지 + exit code + MCP 노출 (모르는걸 아는척/미검증판단/정보미수집)' : '✗ honesty-check 실패');
+  if (!ok) failed++;
+}
+
 console.log(`\nE2E result: ${total - failed}/${total} passed · ${((Date.now() - _e2eStart) / 1000).toFixed(0)}s`);
 if (failed > 0) process.exit(1);