leerness 1.36.49 → 1.36.50

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 1.36.50 — 2026-07-21 — 결함 클래스 3종 전수 스윕: 발견이 아니라 클래스를 고친다 (시스템적 진입점 3곳)
+
+6차 헌트의 개별 결함 3건을 클래스로 확장해 코드베이스 전수 스윕(교훈: fix-class call-site sweep). 개별 지점 수선 대신 시스템적 진입점 수정으로 현재+미래 지점까지 커버.
+
+- **클래스 1 — NaN 날짜 비교 fail-open** (enforce #2 의 클래스): `new Date(손상).getTime()` → NaN 비교가 조용히 통과하던 7개소. drift 4곳(무효 날짜 → mtime 폴백/제외 — advisory 는 false-BLOCK 회피 원칙), audit 1곳(무효 `Updated:` → stale 취급, --fix 가 유효 날짜로 자가 복구), handoff-gap(정보 부재 취급), session-resume(신호 산출 불가 스킵). 실측: `Updated: 2026-99-99` 종전 무언 통과 → 경고+자가복구.
+- **클래스 A — 손상 JSON 스토어 클로버** (toggle #5 의 클래스, codex 실측 21개 스토어): 개별 가드 대신 단일 진입점 `writeUtf8` 에서 "손상 JSON 위에 유효 JSON 저장"(클로버 시그니처) 감지 시 원본을 `<file>.corrupt-<ts>` 로 대피 후 저장 — 바이트 유실 0 · 수동 흐름(handoff 등) 비차단 · 미래 스토어 자동 커버. 알림은 stderr(stdout JSON 계약 불오염). 명시 fail-closed 스토어(state/teams/toggles)는 상류 거부 유지.
+- **클래스 B — --json 오류 계약** (review #7 의 클래스, codex 전수 매트릭스 40+ 실측): `fail()` 진입점 자체가 --json 시 첫 오류를 단일 `{ok:false,error,code:'error'}` 로 방출하고 이후 사람용 출력을 묵음(래치는 argv 정체성 스코프 — REPL/인프로세스에서 자동 해제). failJson 구체 code 경로는 그대로 우선. stderr-only 빈 stdout 6개소(requests complete/drop·wakeup-interval set/record·intent classify/expand)는 fail() 로 전환. enforce remove --json 성공 JSON 화.
+- 이연(정직): --json 성공경로 사람용 텍스트 6개소(resume·pre-wake-audit --last·release cleanup·lessons --auto·bare-help 4종·legacy migrate preview)는 명령별 데이터 형상이 필요해 다음 라운드 — 오류경로와 달리 exit 0 이라 소비자 오판 위험이 낮다.
+- 검증: 클로버 대피/fail 래치/NaN 3종 행위검사 포함 selftest 323(+3), 대표 오류경로 8종 + 기존 PASS 회귀 실측, e2e.
+
 ## 1.36.49 — 2026-07-21 — codex 6차 헌트: 신작 표면(1.36.28~48) 10건 전수 수정 (High 3 · Medium 5 · Low 2)
 
 이번 창에서 신설된 기능들(enforce/toggles/anchors/release note/JSON 계약)을 외부 적대 검증(codex, 30만 토큰) — 10건 발견, 10건 전수 재현 확정 후 전부 수정 (반박 0, DEFER 0).

package/README.md

@@ -122,7 +122,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.49 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.50 하네스를 사용합니다. 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.49는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **86개 도구**를 노출:
+Leerness v1.36.50는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **86개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -197,7 +197,7 @@ Leerness v1.36.49는 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.49 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
+현재 누적: **v1.9.x → 1.36.50 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
 
 ### 성능 가이드
 
@@ -235,6 +235,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.36.49: 2026-07-21
+Last synced by Leerness v1.36.50: 2026-07-21
 <!-- 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.49';
+const VERSION = '1.36.50';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -4113,10 +4113,12 @@ function _selfTestCases() {
       const io = require('../lib/io');
       if (typeof io.setQuiet !== 'function') return false;
       // quiet 면 log/ok/warn 묵음, fail/failJson 은 노출
-      let out = ''; const _w = process.stdout.write; process.stdout.write = s => { out += s; return true; };
+      // 1.36.50: fail 은 json-argv 모드에서 stderr 강등(계약 v2) — "오류는 항상 노출" 의도는 양 스트림으로 검증
+      let out = ''; const _w = process.stdout.write, _e = process.stderr.write;
+      process.stdout.write = s => { out += s; return true; }; process.stderr.write = s => { out += s; return true; };
       let quietLogSuppressed, failShown;
       try { io.setQuiet(true); io.log('HUMAN'); io.ok('OK'); quietLogSuppressed = !/HUMAN|OK/.test(out); out = ''; io.fail('ERR'); failShown = /ERR/.test(out); }
-      finally { io.setQuiet(false); process.stdout.write = _w; process.exitCode = 0; }
+      finally { io.setQuiet(false); process.stdout.write = _w; process.stderr.write = _e; process.exitCode = 0; }
       const src = read(__filename);
       const wired = src.includes("setQuiet(true);") && src.includes("action: 'init', version: VERSION, path: _initRoot, harnessFiles");
       return quietLogSuppressed && failShown && wired;
@@ -4933,6 +4935,55 @@ function _selfTestCases() {
       const dg = read(path.join(__dirname, '..', 'lib', 'diagnostics.js'));
       const wnOk = /compareVer\(fromV, toV\) > 0/.test(dg) && dg.includes("code: 'invalid_range'");
       return tOk && noteOk && revOk && wnOk;
+    } },
+    { name: '스토어 클로버 대피 (1.36.50, 클래스 스윕 A): 손상 JSON 위 유효 JSON 저장 시 원본 .corrupt-* 대피 — 행위검사', run: () => {
+      const io = require('../lib/io');
+      const tmp = fs.mkdtempSync(path.join(os.tmpdir(), '__leerness_cw_'));
+      const _ce = console.error; console.error = () => {};          // 대피 알림이 doctor(en) 등 상위 출력에 새지 않게 격리
+      try {
+        const f = path.join(tmp, 's.json');
+        fs.writeFileSync(f, '{"keep":[1,');                         // 손상
+        io.writeUtf8(f, '{"fresh":true}');
+        const baks = fs.readdirSync(tmp).filter(n => n.startsWith('s.json.corrupt-'));
+        const rescued = baks.length === 1 && fs.readFileSync(path.join(tmp, baks[0]), 'utf8') === '{"keep":[1,' && read(f) === '{"fresh":true}';
+        // 정상 파일 덮어쓰기·비-JSON 새 내용은 대피 없음(백업 증식 방지)
+        io.writeUtf8(f, '{"fresh":2}');
+        const f2 = path.join(tmp, 'n.json'); fs.writeFileSync(f2, 'not json'); io.writeUtf8(f2, 'still not json');
+        const noExtra = fs.readdirSync(tmp).filter(n => n.includes('.corrupt-')).length === 1;
+        return rescued && noExtra;
+      } finally { console.error = _ce; try { fs.rmSync(tmp, { recursive: true, force: true }); } catch {} }
+    } },
+    { name: 'NaN 날짜 fail-open 클래스 스윕 (1.36.50): drift mtime 폴백·무효날짜 제외 + audit stale 취급 + handoff-gap 정보부재 — 소스가드', run: () => {
+      const dr = read(path.join(__dirname, '..', 'lib', 'drift.js'));
+      const drOk = (dr.match(/Number\.isFinite/g) || []).length >= 4;
+      const au = read(path.join(__dirname, '..', 'lib', 'audit.js'));
+      const auOk = /if \(!Number\.isFinite\(dDays\)\) dDays = Infinity/.test(au);
+      const s = read(__filename);
+      const gapOk = /if \(!Number\.isFinite\(lastMs\)\) return \{ hasLast: false \}/.test(s);
+      return drOk && auOk && gapOk;
+    } },
+    { name: '--json 오류 계약 진입점 v2 (1.36.50, 클래스 스윕 B): fail 래치 — 사람용 stderr 강등 + JSON 페이로드 통과 + 명시 failJson(false) human 보장 — 행위검사', run: () => {
+      const io = require('../lib/io');
+      const saveArgv = process.argv, saveExit = process.exitCode; const outs = [], errs = [];
+      const _log = console.log, _err = console.error;
+      try {
+        process.argv = ['node', 'x', 'cmd', '--json'];
+        console.log = (s) => outs.push(String(s)); console.error = (s) => errs.push(String(s));
+        io.setQuiet(false);                     // 래치 초기화
+        io.fail('첫 오류'); io.fail('둘째'); io.log('사람용 잔여줄'); io.log('{"agg":true}');
+        // stdout: 집계 JSON 만 통과 · ✗/잔여줄은 stderr
+        const passThru = outs.length === 1 && outs[0] === '{"agg":true}';
+        const demoted = errs.some(e => e.includes('첫 오류')) && errs.some(e => e === '사람용 잔여줄');
+        // 명시 failJson(false) → argv 에 --json 있어도 human ✗ (호출자 결정 우선, UR-0099 계약)
+        io.setQuiet(false); outs.length = 0;
+        io.failJson(false, 'c', '사람지정');
+        const humanExplicit = outs.length === 1 && outs[0] === '✗ 사람지정';
+        // 비-json argv 사람용 ✗ 유지
+        io.setQuiet(false); process.argv = ['node', 'x', 'cmd']; outs.length = 0;
+        io.fail('사람용');
+        const human = outs.length === 1 && outs[0] === '✗ 사람용';
+        return passThru && demoted && humanExplicit && human;
+      } finally { console.log = _log; console.error = _err; process.argv = saveArgv; io.setQuiet(false); process.exitCode = saveExit; }
     } }
   ];
 }
@@ -5227,11 +5278,16 @@ function enforceCmd(root, sub) {
     return;
   }
   if (sub === 'remove') {
+    let removed = false, restored = false;
     if (exists(hookP) && read(hookP).includes(_ENFORCE_MARK)) {
-      if (exists(chainedP)) { fs.copyFileSync(chainedP, hookP); fs.unlinkSync(chainedP); try { fs.chmodSync(hookP, 0o755); } catch {} }
+      if (exists(chainedP)) { fs.copyFileSync(chainedP, hookP); fs.unlinkSync(chainedP); try { fs.chmodSync(hookP, 0o755); } catch {} restored = true; }
       else fs.unlinkSync(hookP);
-      ok('enforce 제거 — pre-commit 훅 해제' + (exists(hookP) ? ' (기존 훅 복원)' : ''));
-    } else log('enforce 훅 없음 — 변경 없음');
+      removed = true;
+    }
+    // 1.36.50 (스윕 B): --json 성공도 단일 JSON — 종전엔 사람용 텍스트/무출력이었다
+    if (json) { log(JSON.stringify({ ok: true, removed, restoredChain: restored }, null, 2)); return; }
+    if (removed) ok('enforce 제거 — pre-commit 훅 해제' + (restored ? ' (기존 훅 복원)' : ''));
+    else log('enforce 훅 없음 — 변경 없음');
     return;
   }
   // status
@@ -6380,7 +6436,7 @@ function _detectAbnormalShutdown(root) {
     if (exists(lhFp)) {
       const j = JSON.parse(read(lhFp));
       const last = j.lastAt || (j.history && j.history.length > 0 ? j.history[j.history.length - 1] : null);
-      if (last) {
+      if (last && Number.isFinite(new Date(last).getTime())) {   // 1.36.50 (NaN 날짜 클래스): 손상 타임스탬프는 신호 산출 불가 — 스킵
         const lastMs = new Date(last).getTime();
         const gapMin = Math.floor((now - lastMs) / 60000);
         if (gapMin > 60) {
@@ -7016,9 +7072,9 @@ function requestsCmd(root, sub, ...rest) {
 
   if (sub === 'complete') {
     const id = rest[0];
-    if (!id) { console.error('Usage: leerness requests complete <id>'); process.exit(1); }
+    if (!id) { fail('Usage: leerness requests complete <id>'); process.exit(1); }   // 1.36.50 (스윕 B): stderr-only → stdout 계약(fail 이 --json 인지)
     const updated = _updateUserRequest(root, id, { status: 'completed' });
-    if (!updated) { console.error(`request not found: ${id}`); process.exit(1); }
+    if (!updated) { fail(`request not found: ${id}`); process.exit(1); }
     if (has('--json')) { log(JSON.stringify(updated, null, 2)); return; }
     log(grn(`✓ completed ${updated.id}`));
     return;
@@ -7026,9 +7082,9 @@ function requestsCmd(root, sub, ...rest) {
 
   if (sub === 'drop') {
     const id = rest[0];
-    if (!id) { console.error('Usage: leerness requests drop <id>'); process.exit(1); }
+    if (!id) { fail('Usage: leerness requests drop <id>'); process.exit(1); }   // 1.36.50 (스윕 B)
     const updated = _updateUserRequest(root, id, { status: 'dropped' });
-    if (!updated) { console.error(`request not found: ${id}`); process.exit(1); }
+    if (!updated) { fail(`request not found: ${id}`); process.exit(1); }
     if (has('--json')) { log(JSON.stringify(updated, null, 2)); return; }
     log(yel(`✓ dropped ${updated.id}`));  // 1.9.354 (UR-0072 외부리뷰): 성공 동작에 실패 아이콘(✗) 대신 ✓
     return;
@@ -7405,7 +7461,7 @@ function wakeupIntervalCmd(root, sub, val) {
 
   if (sub === 'set') {
     const n = Number(val);
-    if (!val || isNaN(n) || n < 60) { console.error('Usage: leerness wakeup-interval set <secs ≥ 60>'); process.exit(1); }
+    if (!val || isNaN(n) || n < 60) { fail('Usage: leerness wakeup-interval set <secs ≥ 60>'); process.exit(1); }   // 1.36.50 (스윕 B)
     const state = _loadWakeupHistory(root);
     state.override = n;
     _writeWakeupHistory(root, state);
@@ -7444,7 +7500,7 @@ function wakeupIntervalCmd(root, sub, val) {
   if (sub === 'record') {
     const kind = val || 'auto';
     const validKinds = ['auto', 'user-trigger', 'wakeup-miss'];
-    if (!validKinds.includes(kind)) { console.error(`kind must be: ${validKinds.join('/')}`); process.exit(1); }
+    if (!validKinds.includes(kind)) { fail(`kind must be: ${validKinds.join('/')}`); process.exit(1); }   // 1.36.50 (스윕 B)
     _recordWakeupFire(root, kind);
     if (has('--json')) { log(JSON.stringify({ recorded: kind, at: new Date().toISOString() }, null, 2)); return; }
     log(grn(`✓ wakeup fire 기록: ${kind}`));
@@ -7950,7 +8006,7 @@ function intentCmd(root, sub, ...rest) {
 
   if (sub === 'classify') {
     const text = rest.filter(x => !x.startsWith('-')).join(' ');
-    if (!text) { console.error('Usage: leerness intent classify "<request text>"'); process.exit(1); }
+    if (!text) { fail('Usage: leerness intent classify "<request text>"'); process.exit(1); }   // 1.36.50 (스윕 B)
     const result = _classifyIntent(text);
     if (has('--json')) { log(JSON.stringify({ text, ...result }, null, 2)); return; }
     log(cyan(`# leerness intent classify (1.9.213)`));
@@ -7968,7 +8024,7 @@ function intentCmd(root, sub, ...rest) {
 
   if (sub === 'expand') {
     const text = rest.filter(x => !x.startsWith('-')).join(' ');
-    if (!text) { console.error('Usage: leerness intent expand "<request text>"'); process.exit(1); }
+    if (!text) { fail('Usage: leerness intent expand "<request text>"'); process.exit(1); }   // 1.36.50 (스윕 B)
     const result = _inferScopeExpansion(text, root);
     if (has('--json')) { log(JSON.stringify(result, null, 2)); return; }
     log(cyan(`# leerness intent expand (1.9.213) [DRY-RUN]`));
@@ -8047,6 +8103,7 @@ function _getLastHandoffGap(root) {
     const j = JSON.parse(read(fp));
     if (!j.last) return { hasLast: false };
     const lastMs = new Date(j.last).getTime();
+    if (!Number.isFinite(lastMs)) return { hasLast: false };   // 1.36.50 (NaN 날짜 클래스): 손상 타임스탬프 = 정보 부재로 취급
     const gapMs = Date.now() - lastMs;
     const gapMin = Math.floor(gapMs / 60000);
     // R-0001 영구 룰: 25분 (1500s). gap > 35분 (140% buffer) → wakeup miss 의심

package/lib/audit.js

@@ -102,10 +102,14 @@ function audit(root, opts = {}, deps = {}) {
   const cur = exists(currentStatePath(root)) ? read(currentStatePath(root)) : '';
   const updMatch = cur.match(/Updated: (\d{4}-\d{2}-\d{2})/);
   if (updMatch) {
-    const dDays = (Date.now() - new Date(updMatch[1]).getTime()) / 86400000;
+    // 1.36.50 (NaN 날짜 클래스 스윕): "Updated: 2026-99-99" 같은 무효 날짜는 NaN 비교로 무언 통과했다 —
+    //   신선함 증명 불가 = stale 취급(여긴 --fix 가 유효 날짜로 재스탬프하므로 자가 복구 경로).
+    let dDays = (Date.now() - new Date(updMatch[1]).getTime()) / 86400000;
+    if (!Number.isFinite(dDays)) dDays = Infinity;
     if (dDays > 7) {
-      warnings++; warn(`current-state.md stale (${Math.round(dDays)} days)`);
-      _finding('current_state_stale', 'warn', 'current-state.md stale', { days: Math.round(dDays) });
+      const dShow = Number.isFinite(dDays) ? Math.round(dDays) : '무효 날짜';
+      warnings++; warn(`current-state.md stale (${dShow} days)`);
+      _finding('current_state_stale', 'warn', 'current-state.md stale', { days: Number.isFinite(dDays) ? Math.round(dDays) : -1 });
       // 1.9.35 #5: --fix → current-state.md Updated 라인 갱신
       if (fix) {
         const stamped = cur.replace(/Updated: \d{4}-\d{2}-\d{2}/, `Updated: ${today()}`);

package/lib/drift.js

@@ -29,7 +29,9 @@ function driftCheckCmd(root, opts = {}, deps = {}) {
     const m = allGen.length ? allGen[allGen.length - 1] : null;
     let ageDays;
     if (m) {
+      // 1.36.50 (NaN 날짜 클래스 스윕): 손상 타임스탬프(NaN)는 신선함을 증명 못 함 — mtime 폴백(무언 fresh 오판 방지)
       ageDays = (now - new Date(m[1]).getTime()) / 86400000;
+      if (!Number.isFinite(ageDays)) ageDays = _ageDays(shPath);
     } else {
       ageDays = _ageDays(shPath);
     }
@@ -39,13 +41,14 @@ function driftCheckCmd(root, opts = {}, deps = {}) {
   const csPath = currentStatePath(root);
   if (exists(csPath)) {
     const m = read(csPath).match(/Updated:\s*(\d{4}-\d{2}-\d{2})/);
-    const ageDays = m ? (now - new Date(m[1]).getTime()) / 86400000 : _ageDays(csPath);
+    let ageDays = m ? (now - new Date(m[1]).getTime()) / 86400000 : _ageDays(csPath);
+    if (!Number.isFinite(ageDays)) ageDays = _ageDays(csPath);   // 1.36.50: NaN 날짜 → mtime 폴백
     signals.push({ file: 'current-state.md', ageDays, threshold: 2, weight: 20, label: t('current-state 갱신 없음', 'current-state not updated') });
   }
   // 3. progress-tracker.md 마지막 row의 updated 컬럼
   const rows = readProgressRows(root);
   if (rows.length) {
-    const dates = rows.map(r => (r.updated || '').match(/\d{4}-\d{2}-\d{2}/)).filter(Boolean).map(m => m[0]);
+    const dates = rows.map(r => (r.updated || '').match(/\d{4}-\d{2}-\d{2}/)).filter(Boolean).map(m => m[0]).filter(d => Number.isFinite(new Date(d).getTime()));   // 1.36.50: 무효 날짜("2026-99-99") 제외
     if (dates.length) {
       dates.sort();
       const latest = dates[dates.length - 1];
@@ -58,7 +61,7 @@ function driftCheckCmd(root, opts = {}, deps = {}) {
   // 4. task-log.md 마지막 entry "## YYYY-MM-DD"
   const tlPath = taskLogPath(root);
   if (exists(tlPath)) {
-    const dates = Array.from(read(tlPath).matchAll(/^## (\d{4}-\d{2}-\d{2})/gm)).map(m => m[1]);
+    const dates = Array.from(read(tlPath).matchAll(/^## (\d{4}-\d{2}-\d{2})/gm)).map(m => m[1]).filter(d => Number.isFinite(new Date(d).getTime()));   // 1.36.50: 무효 날짜 제외
     if (dates.length) {
       dates.sort();
       const latest = dates[dates.length - 1];

package/lib/io.js

@@ -9,17 +9,71 @@ const path = require('path');
 // 1.10.2 (UR-0146): quiet 모드 — 사람용 출력(log/ok/warn) 억제. init --json 등에서 큰 핸들러의 다수 log 를 비침투적으로 묵음 → 순수 JSON 1개만 출력.
 //   fail/failJson(오류)은 묵음 대상 아님(에러는 항상 노출). setQuiet 로 토글, 호출부 finally 에서 반드시 복구.
 let _quiet = false;
-function setQuiet(v) { _quiet = !!v; }
-function log(s = '') { if (_quiet) return; console.log(s); }
+function setQuiet(v) { _quiet = !!v; if (!v) { _jsonErrEmitted = false; _failLatched = false; _firstFail = null; } }   // 1.36.50: 장수 프로세스(REPL)가 명령 경계에서 복구 시 JSON-오류 래치도 해제
+function log(s = '') {
+  _unlatchIfNewCmd();
+  if (_quiet) return;
+  if (_failLatched || _jsonErrEmitted) {
+    // json-오류 래치 중: 명령 자신의 구조화 출력(JSON 페이로드)만 통과, 사람용 잔여 줄은 stderr 강등
+    const t = typeof s === 'string' ? s.trim() : '';
+    if (t && (t[0] === '{' || t[0] === '[')) { try { JSON.parse(t); console.log(s); _stdoutWrote = true; return; } catch {} }
+    console.error(s); return;
+  }
+  console.log(s); _stdoutWrote = true;
+}
 function ok(s) { log('✓ ' + s); }
 function warn(s) { log('⚠ ' + s); }
 // fail() 은 오류 신호 → exit code 1 설정 (CI/MCP/에이전트가 실패를 성공으로 오판 방지, UR-0045).
-function fail(s) { console.log('✗ ' + s); process.exitCode = 1; }  // quiet 무시(오류는 항상 노출)
+// 1.36.50 (codex 스윕 B, 40+ 실측): --json 요청 시 fail() 자체가 단일 JSON 계약을 이행 —
+//   첫 오류를 {ok:false,error,code:'error'} 로 stdout 에 내고 이후 사람용 출력(log/ok/warn·추가 fail)은
+//   묵음/stderr 로 강등해 "✗ 텍스트·혼합·빈 stdout" 클래스를 진입점 한 곳에서 종결한다.
+//   개별 명령이 failJson 으로 구체 code 를 주는 기존 경로는 그대로 우선.
+// 설계 v2 (게이트 실측 후 재설계): 즉시 JSON 방출+전면 묵음은 "내부 fail 후 자기 집계 JSON 을 내는 명령"(gate 등)을 질식시켰다.
+//   → fail() 은 json 모드에서 stdout 에 아무것도 안 쓰고(✗ 는 stderr), 사람용 후속 log 만 억제하되
+//     JSON 페이로드 log 는 통과시킨다. 프로세스 exit 때 stdout 이 여전히 비어 있으면 첫 오류를 폴백 JSON 으로 방출 —
+//     결과적으로 stdout 은 "명령 자신의 JSON" 또는 "폴백 오류 JSON" 중 정확히 하나.
+let _jsonErrEmitted = false;   // failJson 즉시 방출 후 후속 사람용 출력 억제 표식
+let _failLatched = false;      // fail() json 모드 발화 표식 (사람용 log 억제 + exit 폴백 대기)
+let _firstFail = null;
+let _stdoutWrote = false;
+let _exitHooked = false;
+let _latchArgv = null;         // 래치는 argv 정체성 스코프 — 새 명령(REPL/인프로세스 테스트가 argv 교체) 시 자동 해제
+// stdout 기록 추적은 스트림 레벨 — 일부 명령(audit 등)이 process.stdout.write 를 직접 캡처/사용해 log() 를 우회한다.
+//   모듈 로드 시 1회 투명 래핑: 이후 어떤 경로(직접 write 포함)로든 stdout 에 쓰면 exit 폴백이 이중 JSON 을 내지 않는다.
+{
+  const _rawWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = function (...a) { _stdoutWrote = true; return _rawWrite(...a); };
+}
+function _argvJsonMode() { try { return process.argv.includes('--json'); } catch { return false; } }
+function _unlatchIfNewCmd() {
+  if ((_jsonErrEmitted || _failLatched) && _latchArgv !== process.argv) { _jsonErrEmitted = false; _failLatched = false; _firstFail = null; _quiet = false; _latchArgv = null; }
+}
+function fail(s) {
+  _unlatchIfNewCmd();
+  if (_argvJsonMode()) {
+    if (_firstFail == null) _firstFail = s;
+    _failLatched = true; _latchArgv = process.argv;
+    console.error('✗ ' + s);
+    if (!_exitHooked) {
+      _exitHooked = true;
+      process.on('exit', () => { if (_failLatched && !_stdoutWrote && _firstFail != null) console.log(JSON.stringify({ ok: false, error: _firstFail, code: 'error' }, null, 2)); });
+    }
+    process.exitCode = 1; return;
+  }
+  console.log('✗ ' + s); process.exitCode = 1;  // quiet 무시(오류는 항상 노출)
+}
 // 1.9.398 (6번째 외부평가/codex P1-C, UR-0099): --json 모드 에러는 구조화 출력 — AI 에이전트가 에러 경로에서 JSON.parse 실패하지 않도록.
 //   jsonMode 면 {ok:false,error,code} + exit1, 아니면 사람용 fail(). 양쪽 exit code 1 일관.
 function failJson(jsonMode, code, msg) {
-  if (jsonMode) { console.log(JSON.stringify({ ok: false, error: msg, code }, null, 2)); process.exitCode = 1; }  // quiet 무시(오류 JSON 항상 노출)
-  else fail(msg);
+  _unlatchIfNewCmd();
+  if (jsonMode) {
+    if (!_jsonErrEmitted) { console.log(JSON.stringify({ ok: false, error: msg, code }, null, 2)); _jsonErrEmitted = true; _stdoutWrote = true; _failLatched = true; _latchArgv = process.argv; }
+    else console.error('✗ ' + msg);
+    process.exitCode = 1;
+  } else {
+    // 명시적 jsonMode=false 는 호출자의 결정 — argv 스니핑(fail)보다 우선해 human 출력 보장
+    console.log('✗ ' + msg); process.exitCode = 1;
+  }
 }
 function today() { return new Date().toISOString().slice(0, 10); }
 function now() { return new Date().toISOString(); }
@@ -38,8 +92,23 @@ function mkdirp(p) { fs.mkdirSync(p, { recursive: true }); }
 // 1.9.298 (UR-0038, 외부리뷰 3중수렴): 원자적 쓰기 — temp 파일에 기록 후 rename(원자 교체)으로 부분쓰기 손상 방지.
 //   temp 이름은 .tmp-PID-SEQ 라 *.md glob 에 안 걸림. 실패 시 temp 정리.
 let _writeSeq = 0;
+// 1.36.50 (스토어 손상 클래스 전수 스윕): "손상 JSON 위에 유효 JSON 저장" = 클로버 시그니처.
+//   개별 스토어(21곳+)를 각자 가드하는 대신 단일 진입점에서: 기존 파일이 JSON 파싱 불가이고 새 내용은 유효 JSON 이면
+//   원본을 <file>.corrupt-<ts> 로 대피(rename) 후 저장 — 유실 0 · 흐름(handoff 등 수동 기록) 비차단.
+//   명시 fail-closed 스토어(state/teams/toggles 등)는 상류에서 이미 거부하므로 여기 도달하지 않는다.
+function _rescueCorruptJson(p, s) {
+  if (!/\.json$/i.test(p) || !fs.existsSync(p)) return;
+  try { JSON.parse(s); } catch { return; }          // 새 내용이 JSON 아니면 대상 아님
+  let old;
+  try { old = read(p); } catch { return; }
+  try { JSON.parse(old); return; } catch {}          // 기존이 정상이면 통상 덮어쓰기
+  const bak = `${p}.corrupt-${Date.now()}`;
+  // 알림은 stderr — --json 명령의 stdout 단일-JSON 계약을 오염하지 않는다 (codex 스윕 B #1 실측)
+  try { fs.renameSync(p, bak); console.error(`⚠ 손상 JSON 감지 — 원본 대피 후 저장: ${path.basename(bak)} (수동 복구용)`); } catch {}
+}
 function writeUtf8(p, s) {
   mkdirp(path.dirname(p));
+  _rescueCorruptJson(p, s);
   const tmp = `${p}.tmp-${process.pid}-${++_writeSeq}`;
   try {
     fs.writeFileSync(tmp, s, { encoding: 'utf8' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.49",
+  "version": "1.36.50",
   "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",