leerness 1.36.48 → 1.36.50

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # 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).
+
+- **#1 High — rules 손상행 무언 삭제 재발 경로**: `nextRuleId` 가 파싱된 룰만 스캔해 손상행(셀 부족)의 R-id 가 새 룰에 재발급 → writeRules 보존 필터가 손상행을 기존 룰로 오인해 삭제(1.36.37 보존 로직이 지키려던 바로 그 행). 원시 파일의 모든 `| R-XXXX |` 를 카운트.
+- **#2 High — enforce check 손상 타임스탬프 통과**: `new Date('not-a-date')` → NaN → `NaN > window` 가 false 라 손상 last-handoff.json 이 강제를 통과("handoff NaNh 전"). fail-closed(Infinity 취급) + `--json` 성공 시 구조화 출력(종전 빈 stdout).
+- **#3 High — anchors 위험신호로 --apply 마다 파일 증식**: 개행/`##` 포함 package description 이 섹션 본문에 구조 마크다운으로 박혀 재적용 시 섹션 경계가 밀려 중복 증식. 신호 한 줄 정규화(`_oneLine`) + `_replaceMdSection` 본문 개행 평탄화 방어층.
+- **#4 — `## Goal` 헤딩 부재를 "작성됨"으로 오보**: 섹션 자체가 없으면 gap 미탐지 + --apply 무동작. 부재=gap + `appendIfMissing` 으로 헤딩 신설.
+- **#5 — toggle set 이 손상 toggles.json 을 기본값으로 리셋**: lens 하나 바꾸면 gate:false 가 무언 ON 복원. 변경 진입점 fail-closed(1.36.28 스토어 손상 클래스), 원본 보존.
+- **#6 — release note 정상 입력 2종 실패**: 대시 시작 노트("- first")가 nonFlagArgs 전역 필터에 걸려 입력 불가(원시 argv 복원으로 수정) + SemVer 빌드메타(`1.2.3+build.1`)의 `+` 미이스케이프로 같은 버전 헤딩 중복 생성(전체 regex 이스케이프).
+- **#7 — review --json 오류경로가 사람용 텍스트**: target/persona/파일 검증 실패 시 failJson 단일 JSON 계약 (target_required/persona_required/file_not_found/file_too_large/persona_not_found).
+- **#8 — 무효 --window 무언 보정 설치**: 0/NaN→24 무언 보정, 400자리 정수→`WIN_MIN=Infinity` 훅(상시 차단). 1~8760 정수 외 invalid_window 거부.
+- **#9 Low — 커밋 0개 저장소를 enforce audit 이 실패 처리**: unborn HEAD 를 git_log_failed 로 오분류 → `checked:0` 성공(no_commits).
+- **#10 Low — whats-new 역순 범위 빈 성공**: from > to 를 invalid_range 명시 오류로.
+- 검증: 재현→수정→재검 전 케이스 실측, selftest 316→320(행위 2 + 소스가드 2, 자기참조 트랩 회피형 앵커), e2e.
+
 ## 1.36.48 — 2026-07-16 — ACP 입장 명문화 (docs/interoperability.md, 사용자 질의)
 
 사용자 질의("ACP 가 고려돼 있는가?")에 대한 검토 결과 언급 0 — "미고려" 를 "고려 후 결정" 으로 전환. **Agent Client Protocol**(Zed 계열): 에디터↔에이전트 토폴로지라 운영 레이어인 leerness 에 직접 구현 자리 없음 — ACP 에이전트는 MCP(.mcp.json) 경유로 이미 간접 호환, enforce 는 프로토콜 무관 커버. **Agent Communication Protocol**(BeeAI, REST): 오프라인-퍼스트/0-deps 원칙 충돌 — 동일 문제는 .leerness/ substrate 가 해결. 상호운용성 문서 신설(지원 표면 표 + 신규 프로토콜 평가 기준 3항 + 재검토 트리거), README Links 연결, decision 기록.

package/README.md

@@ -122,7 +122,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.48 하네스를 사용합니다. 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.48는 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.48는 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.48 릴리스 태그 이력** (수백 라운드) · _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.48: 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.48';
+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;
@@ -4894,6 +4896,94 @@ function _selfTestCases() {
         const wired = read(path.join(__dirname, '..', 'lib', 'audit.js')).includes("require('./state-integrity')") && read(path.join(__dirname, '..', 'lib', 'health.js')).includes("require('./state-integrity')");
         return onlyBad && noHarness && wired;
       } finally { try { fs.rmSync(tmp, { recursive: true, force: true }); } catch {} }
+    } },
+    { name: 'rules 손상행 ID 충돌 방지 (1.36.49, codex 6차 #1 High): nextRuleId 가 파싱불가 행의 R-id 도 카운트 — 행위검사', run: () => {
+      const tmp = fs.mkdtempSync(path.join(os.tmpdir(), '__leerness_rid_'));
+      try {
+        fs.mkdirSync(path.join(tmp, '.harness'), { recursive: true });
+        fs.writeFileSync(path.join(tmp, '.harness', 'rules.md'), '| R-0007 | every-session |\n');
+        return nextRuleId(tmp) === 'R-0008';   // 종전: 손상행 무시 → R-0001 재발급 → writeRules 가 손상행을 무언 삭제
+      } finally { try { fs.rmSync(tmp, { recursive: true, force: true }); } catch {} }
+    } },
+    { name: 'anchors 위험신호 정규화 + 헤딩 신설 (1.36.49, codex 6차 #3 High/#4): 개행·헤딩 포함 description 평탄화 + appendIfMissing — 순수 행위검사', run: () => {
+      const p = require('../lib/pure-utils');
+      const d = p._draftAnchors({ pkgDescription: 'Alpha | Beta\n## Injected Heading\nmore' });
+      const flat = [...d.purpose, ...d.goal].every(l => !l.includes('\n') && !/^#/.test(l));
+      // 섹션 부재 + appendIfMissing → 헤딩 신설; 미지정이면 원문 불변(기존 계약 유지)
+      const base = '# T\n\n## Other\nx';
+      const appended = p._replaceMdSection(base, 'Goal', ['- g'], { appendIfMissing: true });
+      const addOk = appended.includes('## Goal') && appended.includes('- g') && p._replaceMdSection(base, 'Goal', ['- g']) === base;
+      // 본문 줄 내 개행은 평탄화(구조 오염 방어층) + 같은 입력 재적용 멱등
+      const rep1 = p._replaceMdSection('## Goal\nold\n## Next\ny', 'Goal', ['a\nb']);
+      const idem = rep1.split('\n').includes('a') && rep1.split('\n').includes('b') && p._replaceMdSection(rep1, 'Goal', ['a\nb']) === rep1;
+      return flat && addOk && idem;
+    } },
+    { name: 'enforce fail-closed 3종 (1.36.49, codex 6차 #2 High/#8/#9): 손상 타임스탬프·무효 window·unborn HEAD — 소스가드', run: () => {
+      const s = read(__filename);
+      const nanClosed = /const ageH = Number\.isFinite\(lastMs\)/.test(s) && /new Date\(lastAt\)\.getTime\(\) : NaN/.test(s);
+      const winValid = /failJson\(json, 'invalid_window'/.test(s) && /Number\.isInteger\(windowHours\) \|\| windowHours < 1/.test(s);
+      const unborn = /does not have any commits\|unknown revision/.test(s) && /note: 'no_commits'/.test(s);
+      const jsonOk = /ok: true, lastHandoff: lastAt/.test(s);   // --json 성공도 구조화 출력
+      return nanClosed && winValid && unborn && jsonOk;
+    } },
+    { name: '스토어/계약 4종 (1.36.49, codex 6차 #5/#6/#7/#10): toggle set fail-closed·release note 대시/regex·review failJson·whats-new 역순 — 소스가드', run: () => {
+      const tg = read(path.join(__dirname, '..', 'lib', 'toggles.js'));
+      const tOk = /JSON\.parse\(read\(f\)\)/.test(tg) && tg.includes('덮어쓰기 거부');
+      const s = read(__filename);
+      const noteOk = /raw\.indexOf\('note'\)/.test(s) && /version\.replace\(\/\[\.\*\+\?\^/.test(s);
+      const revOk = /failJson\(_rj, 'file_not_found'/.test(s) && /failJson\(_rj, 'persona_not_found'/.test(s);
+      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; }
     } }
   ];
 }
@@ -5081,7 +5171,11 @@ function enforceCmd(root, sub) {
   if (sub === 'install') {
     if (!exists(path.join(root, '.git'))) { failJson(json, 'not_a_git_repo', `git 저장소가 아님: ${root} — pre-commit 강제는 git 저장소에서만 가능`); return; }
     if (!exists(path.join(root, '.harness'))) { failJson(json, 'harness_missing', `leerness 미설치: ${root} — 먼저 leerness init`); return; }
-    const windowHours = Math.max(1, parseInt(arg('--window', '24'), 10) || 24);
+    // 1.36.49 (codex 6차 #8): 명시된 무효 window 는 24로 무언 보정하지 않고 거부 — 종전엔 0/NaN→24,
+    //   400자리 정수→Infinity 가 그대로 설치돼 훅에 WIN_MIN=Infinity(find -mmin 상시 실패=상시 차단)가 박혔다.
+    const winRaw = arg('--window', '24');
+    const windowHours = Number(winRaw);
+    if (!Number.isInteger(windowHours) || windowHours < 1 || windowHours > 8760) { failJson(json, 'invalid_window', `--window 는 1~8760 정수(시간)만: 받음 "${winRaw}"`); return; }
     const strict = has('--strict');
     mkdirp(path.dirname(_enforceCfgPath(root)));
     writeUtf8(_enforceCfgPath(root), JSON.stringify({ windowHours, strict, installedAt: now() }, null, 2) + '\n');
@@ -5130,7 +5224,11 @@ function enforceCmd(root, sub) {
     const lhf = _lastHandoffPath(root);
     let lastAt = null;
     try { if (exists(lhf)) { const j = JSON.parse(read(lhf)); lastAt = j.last || (Array.isArray(j.history) && j.history.length ? j.history[j.history.length - 1] : null); } } catch {}
-    const ageH = lastAt ? (Date.now() - new Date(lastAt).getTime()) / 3600000 : Infinity;
+    // 1.36.49 (codex 6차 #2 High): 손상 타임스탬프 fail-closed — 종전엔 new Date('not-a-date') → NaN,
+    //   NaN > windowHours 가 false 라서 손상 파일이 강제를 통과("handoff NaNh 전")했다.
+    const lastMs = lastAt ? new Date(lastAt).getTime() : NaN;
+    const ageH = Number.isFinite(lastMs) ? (Date.now() - lastMs) / 3600000 : Infinity;
+    if (!Number.isFinite(lastMs)) lastAt = null;
     if (ageH > cfg.windowHours) {
       fail(`🔒 leerness 강제: 최근 ${cfg.windowHours}h 내 handoff 흔적 없음${lastAt ? ` (마지막: ${lastAt})` : ''}`);
       log(`  → 커밋 전 실행: leerness handoff .   (컨텍스트 적재 + 사용 흔적)`);
@@ -5141,7 +5239,9 @@ function enforceCmd(root, sub) {
       const r = cp.spawnSync(process.execPath, [__filename, 'gate', root], { encoding: 'utf8', env: { ...process.env, LEERNESS_INTERNAL: '1' } });
       if (r.status !== 0) { fail(`🔒 leerness 강제(strict): gate 실패 — 커밋 차단`); process.stdout.write((r.stdout || '').slice(-1500)); process.exitCode = 1; return; }
     }
-    if (!json) ok(`enforce check 통과 (handoff ${lastAt ? Math.round(ageH * 10) / 10 + 'h 전' : '-'}${cfg.strict ? ' + gate' : ''})`);
+    // 1.36.49 (codex 6차 #2 부속): --json 성공 시 빈 stdout 이 아니라 구조화 객체를 내보낸다.
+    if (json) { log(JSON.stringify({ ok: true, lastHandoff: lastAt, ageHours: Number.isFinite(ageH) ? Math.round(ageH * 10) / 10 : null, windowHours: cfg.windowHours, strict: !!cfg.strict }, null, 2)); return; }
+    ok(`enforce check 통과 (handoff ${lastAt ? Math.round(ageH * 10) / 10 + 'h 전' : '-'}${cfg.strict ? ' + gate' : ''})`);
     return;
   }
   if (sub === 'audit') {
@@ -5152,6 +5252,11 @@ function enforceCmd(root, sub) {
     let handoffs = [];
     try { const j = JSON.parse(read(_lastHandoffPath(root))); handoffs = (j.history || []).map(t => new Date(t).getTime()).filter(n => !Number.isNaN(n)); } catch {}
     const gl = cp.spawnSync('git', ['-C', root, 'log', '-n', '30', '--pretty=format:%H|%ct|%s'], { encoding: 'utf8', timeout: 10000 });
+    // 1.36.49 (codex 6차 #9): 커밋 0개(unborn HEAD)는 정상 저장소 — 실패가 아니라 "검사 대상 없음" 성공.
+    if (gl.status !== 0 && /does not have any commits|unknown revision|bad default revision|ambiguous argument/i.test(gl.stderr || '')) {
+      if (json) { log(JSON.stringify({ checked: 0, windowHours: cfg2.windowHours, suspects: [], note: 'no_commits' }, null, 2)); return; }
+      ok('  커밋 0개 — 검사 대상 없음'); return;
+    }
     if (gl.status !== 0) { failJson(json, 'git_log_failed', 'git log 실패 — git 저장소인지 확인'); return; }
     const winMs = cfg2.windowHours * 3600000;
     const suspects = [];
@@ -5173,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
@@ -5205,8 +5315,10 @@ function anchorsCmd(root, sub) {
   const naM = '<!-- leerness:na';
   // 1.36.47: draft 마커가 남아있는 섹션(미확정 초안)은 재초안 대상 — 초안 품질 개선을 기존 적용본에도 전파 가능.
   const _draftM = '<!-- draft: leerness anchors';
-  const briefGap = !!briefTxt && !briefTxt.includes(naM) && (_briefUnfilled(briefTxt) || (_mdSectionBody(briefTxt, 'Purpose') || '').includes(_draftM));
-  const planGap = !!planTxt && !planTxt.includes(naM) && (_planGoalUnfilled(planTxt) || (_mdSectionBody(planTxt, 'Goal') || '').includes(_draftM));
+  // 1.36.49 (codex 6차 #4): 헤딩 자체가 없는 파일도 gap — 종전 _sectionUnfilled 는 "섹션 없음→미플래그"(감지용 보수 기본)라
+  //   ## Goal 이 아예 없는 plan.md 가 "작성됨"으로 보고되고 draft --apply 도 무동작이었다. apply 시 헤딩을 신설한다.
+  const briefGap = !!briefTxt && !briefTxt.includes(naM) && (_briefUnfilled(briefTxt) || _mdSectionBody(briefTxt, 'Purpose') == null || (_mdSectionBody(briefTxt, 'Purpose') || '').includes(_draftM));
+  const planGap = !!planTxt && !planTxt.includes(naM) && (_planGoalUnfilled(planTxt) || _mdSectionBody(planTxt, 'Goal') == null || (_mdSectionBody(planTxt, 'Goal') || '').includes(_draftM));
   if (!sub || sub === 'status') {
     if (json) { log(JSON.stringify({ briefUnfilled: briefGap, planGoalUnfilled: planGap }, null, 2)); return; }
     log(`# leerness anchors — 정체성앵커 상태`);
@@ -5228,10 +5340,10 @@ function anchorsCmd(root, sub) {
     const apply = has('--apply');
     const applied = [];
     if (briefGap && draft.purpose.length) {
-      if (apply) { writeUtf8(bf, _replaceMdSection(briefTxt, 'Purpose', draft.purpose)); applied.push('project-brief.md#Purpose'); }
+      if (apply) { writeUtf8(bf, _replaceMdSection(briefTxt, 'Purpose', draft.purpose, { appendIfMissing: true })); applied.push('project-brief.md#Purpose'); }
     }
     if (planGap && draft.goal.length) {
-      if (apply) { writeUtf8(pf, _replaceMdSection(planTxt, 'Goal', draft.goal)); applied.push('plan.md#Goal'); }
+      if (apply) { writeUtf8(pf, _replaceMdSection(planTxt, 'Goal', draft.goal, { appendIfMissing: true })); applied.push('plan.md#Goal'); }
     }
     if (json) { log(JSON.stringify({ briefUnfilled: briefGap, planGoalUnfilled: planGap, draft: { purpose: draft.purpose, goal: draft.goal }, applied, dryRun: !apply }, null, 2)); return; }
     log(`# leerness anchors draft ${apply ? '(적용)' : '(dry-run — 적용: --apply)'}`);
@@ -6324,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) {
@@ -6960,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;
@@ -6970,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;
@@ -7349,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);
@@ -7388,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}`));
@@ -7894,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)`));
@@ -7912,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]`));
@@ -7991,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 의심
@@ -14168,22 +14281,24 @@ function personaCmd(root, sub, idOrName, ...rest) {
 
 function reviewCmd(root, target) {
   root = absRoot(root || process.cwd());
-  if (!target) { fail('review <file> 필요. 예: leerness review src/api.js --persona security'); return process.exit(1); }
+  // 1.36.49 (codex 6차 #7): --json 요청 시 오류 경로도 단일 JSON 계약(failJson) — 종전 fail() 은 사람용 텍스트를 냈다.
+  const _rj = has('--json');
+  if (!target) { failJson(_rj, 'target_required', 'review <file> 필요. 예: leerness review src/api.js --persona security'); return process.exit(1); }
   const personaIds = (arg('--persona', null) || '').split(',').map(s => s.trim()).filter(Boolean);
-  if (!personaIds.length) { fail('--persona <id> 필요. \`leerness persona list\`로 확인'); return process.exit(1); }
+  if (!personaIds.length) { failJson(_rj, 'persona_required', '--persona <id> 필요. `leerness persona list`로 확인'); return process.exit(1); }
 
   // 파일 확인
   const filePath = path.isAbsolute(target) ? target : path.join(root, target);
-  if (!exists(filePath)) { fail(`파일 없음: ${filePath}`); return process.exit(1); }
+  if (!exists(filePath)) { failJson(_rj, 'file_not_found', `파일 없음: ${filePath}`); return process.exit(1); }
   const fileContent = read(filePath);
   const fileSize = Buffer.byteLength(fileContent, 'utf8');
-  if (fileSize > 100 * 1024) { fail(`파일 너무 큼: ${fileSize} bytes. 100KB 미만 권장.`); return process.exit(1); }
+  if (fileSize > 100 * 1024) { failJson(_rj, 'file_too_large', `파일 너무 큼: ${fileSize} bytes. 100KB 미만 권장.`); return process.exit(1); }
 
   // 페르소나 해석
   const personas = [];
   for (const id of personaIds) {
     const p = _resolvePersona(root, id);
-    if (!p) { fail(`페르소나 없음: ${id}. \`leerness persona list\` 확인`); return process.exit(1); }
+    if (!p) { failJson(_rj, 'persona_not_found', `페르소나 없음: ${id}. \`leerness persona list\` 확인`); return process.exit(1); }
     personas.push(p);
   }
 
@@ -15592,6 +15707,15 @@ function nextRuleId(root) {
     const m = r.id.match(/^R-(\d{4,})$/);
     if (m) max = Math.max(max, Number(m[1]));
   }
+  // 1.36.49 (codex 6차 #1 High): 파싱 불가(손상) 행의 R-id 도 카운트 — 종전엔 파싱된 룰만 스캔해
+  //   손상 행과 같은 ID 가 새 룰에 재발급되고, writeRules 의 보존 필터(l.startsWith('| '+id))가
+  //   그 손상 행을 "이미 표에 있는 룰"로 오인해 무언 삭제했다(보존 로직이 지키려던 바로 그 행).
+  try {
+    if (exists(rulesPath(root))) {
+      const re = /(?:^|\n)\|\s*R-(\d+)\s*\|/g; const raw = read(rulesPath(root)); let m2;
+      while ((m2 = re.exec(raw))) max = Math.max(max, Number(m2[1]));
+    }
+  } catch {}
   // 1.11.3 (14th 버그헌트 P2, UR-0180): 아카이브의 R-id 도 카운트 — 기존엔 활성 rules 만 스캔해 rule remove 후 같은 R-id 가 다른 룰에 재사용됐음(아카이브 ID 충돌).
   try {
     if (exists(rulesArchivePath(root))) {
@@ -15812,7 +15936,9 @@ function releaseNote(root, text) {
   if (exists(pkgFile)) { try { version = JSON.parse(read(pkgFile)).version || 'unknown'; } catch {} }
   const clFile = path.join(root, 'CHANGELOG.md');
   const date = today();
-  const headerRe = new RegExp(`^## ${version.replace(/\./g, '\\.')} — `, 'm');
+  // 1.36.49 (codex 6차 #6b): 점만 이스케이프하던 종전 regex 는 SemVer 빌드메타(1.2.3+build.1)의 `+` 를 수량자로
+  //   해석해 기존 헤딩을 못 찾고 같은 버전 헤딩을 중복 생성했다 — 전체 regex 특수문자 이스케이프.
+  const headerRe = new RegExp('^## ' + version.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + ' — ', 'm');
   if (exists(clFile)) {
     const cur = read(clFile);
     if (headerRe.test(cur)) {
@@ -22405,7 +22531,16 @@ async function main() {
   // 1.30.4 (14th리뷰 F7): rule 하위명령 미매칭 시 잘못된 토큰 명시 + usage(종전엔 top-level 'unknown_command: rule' 로 유효 부모명을 오인 표기).
   if (cmd === 'rule')                               { failJson(has('--json'), 'unknown_subcommand', `알 수 없는 rule 하위명령: ${args[1] || '(없음)'} — leerness rule add|list|remove|pause|resume|stop|resume-all|verify`); return process.exit(process.exitCode || 1); }
   if (cmd === 'release' && args[1] === 'bump')      return releaseBump(args[2] || arg('--path', process.cwd()));
-  if (cmd === 'release' && args[1] === 'note')      return releaseNote(arg('--path', process.cwd()), args.slice(2).filter(x => !x.startsWith('-')).join(' '));
+  // 1.36.49 (codex 6차 #6a): nonFlagArgs 가 대시 시작 토큰을 전역에서 걷어내 "- first" 같은 정상 노트가 입력 불가였다.
+  //   원시 argv 에서 note 이후를 복원 — `--` 플래그(+값)만 스킵하고 단일 대시 텍스트("- …")는 노트로 보존.
+  if (cmd === 'release' && args[1] === 'note') {
+    const raw = process.argv.slice(2); const ni = raw.indexOf('note'); const toks = [];
+    for (let i = ni + 1; i < raw.length && ni >= 0; i++) {
+      if (raw[i].startsWith('--')) { if (raw[i] === '--path' && raw[i + 1]) i++; continue; }
+      toks.push(raw[i]);
+    }
+    return releaseNote(arg('--path', process.cwd()), toks.join(' '));
+  }
   if (cmd === 'release' && args[1] === 'publish')   return releasePublish(args[2] || arg('--path', process.cwd()));
   if (cmd === 'release' && args[1] === 'pack')      return await releasePackCmd(args[2] || arg('--path', process.cwd()));
   if (cmd === 'release' && args[1] === 'sync-main') return releaseSyncMainCmd(args[2] || arg('--path', process.cwd()));

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/diagnostics.js

@@ -7,7 +7,7 @@
 const cp = require('child_process');
 const path = require('path');
 const { log, fail, absRoot, exists, read } = require('./io');
-const { parseHarnessVersion, _parseChangelogBetween } = require('./pure-utils');
+const { parseHarnessVersion, _parseChangelogBetween, compareVer } = require('./pure-utils');
 
 function doctorCmd(opts = {}, deps = {}) {
   const { VERSION, uiLang, _selfTestCases, _detectShellCtx, _mcpToolCount, has, harnessPath } = deps;
@@ -147,6 +147,12 @@ function whatsNewCmd(root, deps = {}) {
     fail(t('현재 버전을 파악할 수 없습니다. --from <version> 명시', 'cannot determine current version. specify --from <version>'));
     return process.exit(1);
   }
+  // 1.36.49 (codex 6차 #10): 역순 범위(from > to)는 빈 성공이 아니라 명시 오류 — 인자 순서 착오를 조용히 삼키지 않는다.
+  if (compareVer(fromV, toV) > 0) {
+    if (has('--json')) { log(JSON.stringify({ ok: false, code: 'invalid_range', error: `--from(${fromV}) 이 --to(${toV}) 보다 큼 — 인자 순서 확인` }, null, 2)); return process.exit(1); }
+    fail(t(`--from(${fromV}) 이 --to(${toV}) 보다 큼 — 인자 순서 확인`, `--from (${fromV}) is newer than --to (${toV}) — check argument order`));
+    return process.exit(1);
+  }
   // CHANGELOG.md — 우선 root, 없으면 leerness-pkg 자체 (lib/../CHANGELOG.md = pkg 루트)
   let changelogPath = path.join(root, 'CHANGELOG.md');
   if (!exists(changelogPath)) changelogPath = path.join(__dirname, '..', 'CHANGELOG.md');

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/lib/pure-utils.js

@@ -1151,7 +1151,11 @@ function _planGoalUnfilled(content) { return _sectionUnfilled(content, 'Goal', _
 function _draftAnchors(sig = {}) {
   const purpose = [];
   const goal = [];
-  const desc = String(sig.pkgDescription || '').trim();
+  // 1.36.49 (codex 6차 #3 High): 외부 신호 한 줄 정규화 — description 에 개행/헤딩(`##`)이 들어오면
+  //   섹션 본문에 구조 마크다운이 박혀 다음 --apply 의 섹션 경계 인식이 밀리고 파일이 실행마다 자란다.
+  //   개행→공백, 줄머리 헤딩 마커 제거(불릿 "- " 접두가 있으므로 줄 중간 # 은 무해).
+  const _oneLine = (s) => String(s || '').replace(/\s*\r?\n\s*/g, ' ').replace(/^#+\s*/, '').trim();
+  const desc = _oneLine(sig.pkgDescription);
   // README 첫 문단: 제목/배지/빈줄 건너뛰고 첫 산문 줄
   let readmeLead = '';
   for (const line of String(sig.readmeText || '').split(/\r?\n/)) {
@@ -1173,8 +1177,8 @@ function _draftAnchors(sig = {}) {
   const ms = (sig.milestones || []).filter(m => m && m.title).slice(0, 3);
   const activeTasks = (sig.tasks || []).filter(t => t && /in-progress|planned|requested/.test(String(t.status || ''))).slice(0, 3);
   if (desc || readmeLead) goal.push(`- 제품을 동작 상태로 유지·발전시킨다: ${_cutAt(desc || readmeLead, 140)}`);
-  for (const m of ms) goal.push(`- [${m.id || 'M'}] ${String(m.title).slice(0, 120)}${m.status ? ` (${m.status})` : ''}`);
-  if (!goal.length && activeTasks.length) for (const t of activeTasks) goal.push(`- ${t.id}: ${String(t.request || '').slice(0, 100)}`);
+  for (const m of ms) goal.push(`- [${m.id || 'M'}] ${_oneLine(m.title).slice(0, 120)}${m.status ? ` (${m.status})` : ''}`);
+  if (!goal.length && activeTasks.length) for (const t of activeTasks) goal.push(`- ${t.id}: ${_oneLine(t.request).slice(0, 100)}`);
   const marker = '<!-- draft: leerness anchors — 실신호 기반 초안. AI/사용자가 검토·수정 후 이 주석을 지우면 확정 -->';
   return {
     hasSignal: purpose.length > 0 || goal.length > 0,
@@ -1183,11 +1187,18 @@ function _draftAnchors(sig = {}) {
   };
 }
 
-// 섹션 본문 교체(## <heading> 다음부터 다음 ## 전까지) — 파일 나머지는 불변. 대상 섹션 없으면 원문 그대로.
-function _replaceMdSection(content, heading, newBodyLines) {
+// 섹션 본문 교체(## <heading> 다음부터 다음 ## 전까지) — 파일 나머지는 불변.
+// 대상 섹션 없으면 원문 그대로(appendIfMissing 지정 시 파일 끝에 `## <heading>` 신설 — 1.36.49 codex 6차 #4).
+function _replaceMdSection(content, heading, newBodyLines, opts = {}) {
+  // 1.36.49 (codex 6차 #3 방어층): 본문 줄 안의 개행 평탄화 — 어떤 호출자가 개행 포함 줄을 넘겨도 구조 오염 방지.
+  newBodyLines = (newBodyLines || []).flatMap(l => String(l).split('\n'));
   const lines = String(content || '').replace(/\r\n/g, '\n').split('\n');
   const start = lines.findIndex(l => l.trim().replace(/^#+\s*/, '').toLowerCase() === String(heading).toLowerCase() && /^#+\s/.test(l.trim()));
-  if (start < 0) return content;
+  if (start < 0) {
+    if (!opts.appendIfMissing) return content;
+    const base = String(content || '').replace(/\r\n/g, '\n').replace(/\n*$/, '');
+    return (base ? base + '\n\n' : '') + `## ${heading}\n\n` + newBodyLines.join('\n') + '\n';
+  }
   let end = lines.length;
   for (let i = start + 1; i < lines.length; i++) if (/^##\s/.test(lines[i])) { end = i; break; }
   return [...lines.slice(0, start + 1), '', ...newBodyLines, '', ...lines.slice(end)].join('\n');

package/lib/toggles.js

@@ -58,6 +58,13 @@ function toggleCmd(root, sub, id, val, deps = {}) {
     if (!TOGGLE_REGISTRY[id]) { fail(`알 수 없는 토글: ${id} (가능: ${Object.keys(TOGGLE_REGISTRY).join(', ')})`); process.exitCode = 1; return; }
     const on = String(val).toLowerCase();
     if (on !== 'on' && on !== 'off') { fail(`값은 on|off (받음: ${val})`); process.exitCode = 1; return; }
+    // 1.36.49 (codex 6차 #5): 손상 toggles.json 위에 set 하면 loadToggles 의 기본값 폴백이 저장돼
+    //   무관한 토글(예: gate:false)이 무언 ON 으로 리셋됐다 — 변경 진입점은 fail-closed (1.36.28 스토어 손상 클래스).
+    const f = _togglesPath(root);
+    if (exists(f)) {
+      try { JSON.parse(read(f)); }
+      catch { fail(`toggles.json 손상(JSON 파싱 실패) — 덮어쓰기 거부: ${f}\n  복구하거나 삭제(전 토글 기본 ON 복원) 후 재시도`); process.exitCode = 1; return; }
+    }
     cur[id] = on === 'on';
     saveToggles(root, cur);
     if (json) { log(JSON.stringify({ ok: true, id, value: cur[id], toggles: cur }, null, 2)); return; }

package/package.json

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