leerness 1.36.107 → 1.36.109

package/README.md

@@ -122,7 +122,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.107 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.109 하네스를 사용합니다. 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.107는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
+Leerness v1.36.109는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -197,7 +197,7 @@ Leerness v1.36.107는 stdio JSON-RPC MCP server를 내장합니다 — Claude Co
 `<<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.107 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
+현재 누적: **v1.9.x → 1.36.109 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
 
 ### 성능 가이드
 
@@ -235,5 +235,5 @@ leerness release pack --close --auto-main-push
 - `.harness/session-handoff.md`: 다음 세션 인수인계 (자동 작성)
 - `.harness/lessons.md` / `decisions.md` / `rules.md`: 영구 메모리 (5 surface)
 
-Last synced by Leerness v1.36.107: 2026-08-08
+Last synced by Leerness v1.36.109: 2026-08-10
 <!-- 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.107';
+const VERSION = '1.36.109';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -175,6 +175,9 @@ function _withLock(targetPath, fn, opts = {}) {
   if (_heldLocks.has(lockPath)) return fn();  // 이미 이 프로세스가 보유 → 재진입(중첩 호출 안전)
   const maxWaitMs = opts.maxWaitMs || 10000;  // 1.9.375 (UR-0084): 5s→10s — 고부하 경합 시 fail-open(락 없이 진행) 전 인내 상향, lost-update 창 축소
   const staleMs = opts.staleMs || 30000;
+  // ⚠ 여기서 mkdirp 를 빼면 안 된다(1.36.108 에서 한 번 뺐다가 게이트가 5건을 잡았다).
+  //   `state`·hunts 등 여러 호출부가 **이 mkdirp 가 만들어 주는 디렉토리에 기대어** 곧바로 파일을 쓴다 —
+  //   공유 헬퍼의 부작용을 없애면 그 의존이 한꺼번에 끊긴다. 미초기화 디렉토리 문제는 락을 다는 쪽에서 막는다.
   try { mkdirp(path.dirname(lockPath)); } catch {}
   const start = Date.now();
   let held = false;
@@ -187,8 +190,18 @@ function _withLock(targetPath, fn, opts = {}) {
     }
   }
   if (held) _heldLocks.add(lockPath);
-  try { return fn(); }
-  finally { if (held) { _heldLocks.delete(lockPath); try { fs.unlinkSync(lockPath); } catch {} } }
+  // 1.36.108 (T-0097, 자체 적대 검사에서 발견): fn 이 **프로미스를 돌려주면** 동기 finally 가 그 즉시 락을 푼다 —
+  //   비동기 본체(네트워크 fetch 등)는 락 없이 도는데 호출부는 보호받는다고 믿는다. 가장 나쁜 조합이다
+  //   (`provider sync` 를 감싸면서 실제로 이 형태를 만들었다). thenable 이면 **정착 후에** 푼다.
+  const release = () => { if (held) { _heldLocks.delete(lockPath); try { fs.unlinkSync(lockPath); } catch {} } };
+  let out;
+  try { out = fn(); }
+  catch (e) { release(); throw e; }
+  if (out && typeof out.then === 'function') {
+    return out.then(v => { release(); return v; }, e => { release(); throw e; });
+  }
+  release();
+  return out;
 }
 // 1.9.327 (UR-0025): _getLocalTz / _formatLocal → lib/pure-utils.js 로 이동 (순수 TZ/날짜 포맷, require 사용).
 // 자동 모드 활성 여부 (R-XXXX every-round 룰 존재 시 true)
@@ -2417,8 +2430,16 @@ function _writeUserRequests(root, requests) {
     return true;
   } catch { return false; }
 }
+// 1.36.108 (T-0097): read-modify-write 를 락으로 감싼다. **함수 안에서** 감싸는 것이 핵심이다 —
+//   호출부마다 거는 방식은 이 저장소에서 이미 실패했다: rules.md 는 add 만 보호되고 pause/resume/remove
+//   셋이 락 밖이었다(런타임 계측으로 실측). 진입점이 늘면 그만큼 구멍이 는다.
+//   유실은 가설이 아니라 재현이다 — 2프로세스 프로브에서 동시 `requests add` 한쪽이 통째로 사라졌다
+//   (대조군 previews/decisions 는 B 가 2.4초 대기 후 둘 다 생존 → 락이 실제로 막는다는 것도 같이 확인).
 function _recordUserRequest(root, text, opts = {}) {
   if (!text || typeof text !== 'string') return null;
+  return _withLock(_userRequestsPath(root), () => _recordUserRequestLocked(root, text, opts));
+}
+function _recordUserRequestLocked(root, text, opts) {
   const state = _loadUserRequests(root);
   if (state.unrecognized) { warn(`user-requests.json 형태 인식 불가 — 기록 건너뜀(원본 덮어쓰기 방지). 파일 확인: ${_userRequestsPath(root)}`); return null; }  // 1.36.21: 읽지 못한 데이터 파괴 차단
   // 중복 방지: 동일 텍스트 + open 상태 이미 존재 시 skip
@@ -2443,6 +2464,9 @@ function _recordUserRequest(root, text, opts = {}) {
   return entry;
 }
 function _updateUserRequest(root, id, patch) {
+  return _withLock(_userRequestsPath(root), () => _updateUserRequestLocked(root, id, patch));
+}
+function _updateUserRequestLocked(root, id, patch) {
   const state = _loadUserRequests(root);
   if (state.unrecognized) { warn(`user-requests.json 형태 인식 불가 — 업데이트 건너뜀(원본 덮어쓰기 방지). 파일 확인: ${_userRequestsPath(root)}`); return null; }  // 1.36.21
   const idx = state.requests.findIndex(r => r && r.id === id);
@@ -5154,10 +5178,17 @@ function _selfTestCases() {
         && E('module.exports = require("./x"); void 0;\n') === false;
       return base && bypass && real && noop && noopFP;
     } },
-    { name: '위장 스텁 차단 (1.18.2): stub 루프 _vcImplIsEmpty 사용 + 메시지 + FILE_EXTS java/php 정합 (소스 가드)', run: () => {
-      const src = read(__filename);
-      return src.includes('if (_vcImplIsEmpty(body)) stubFiles.push(c.file);') && src.includes('비주석 코드 0줄 또는 빈 export 껍데기')
-        && /const FILE_EXTS = '[^']*\bjava\b[^']*\bphp\b[^']*'/.test(src);
+    { name: '위장 스텁 차단 (1.18.2 · 1.36.109 행위전환): 빈껍데기 판정이 실제로 동작 + 스텁 루프가 그 판정을 쓴다', run: () => {
+      // 1.36.109: 종전엔 스텁 루프의 호출 줄을 **정확 리터럴**로 붙잡았다. 이번 라운드에 그 줄을 리팩터하자
+      //   (마커 파일 판정을 끼워야 했다) 리터럴이 사라져 메타가드가 즉시 잡았다 — 자기참조 소스가드가 공허해지는 형태다.
+      //   표현이 아니라 **동작**을 본다.
+      //   ⚠ 배선(루프가 이 판정을 실제로 호출하는가)은 **여기서 소스로 확인하지 않는다**: 그 정규식을 쓰자
+      //   바로 위 설명 주석이 스스로를 만족시켜 변이가 생존했다(자체 변이 시험이 잡았다 — 같은 함정의 재생산).
+      //   배선은 e2e 블록 M 이 행위로 지킨다(0바이트 파일 → stub-impl). 배선을 끊으면 그 블록이 실패한다.
+      const shells = ['', '   \n\n ', '/' + '/ TODO\n' + '/' + '/ later\n', '"use strict"; module.exports = {};\n', '/* c */\nvoid 0;\n'];
+      const reals = ['function f(){return 1;}\nmodule.exports={f};\n', 'def f():\n    return 1\n', 'export const x = 1;\nexport function g(){ return x; }\n'];
+      const judged = shells.every(s => _vcImplIsEmpty(s) === true) && reals.every(s => _vcImplIsEmpty(s) === false);
+      return judged && read(__filename).includes('비주석 코드 0줄 또는 빈 export 껍데기');
     } },
     { name: '품질 렌즈 (1.18.3): 카탈로그 무결성 — 사용자 원문 질문 + affects 상호참조 유효 (행위)', run: () => {
       const keys = Object.keys(LENS_CATALOG);
@@ -6399,7 +6430,7 @@ function _selfTestCases() {
       return clar && shape && noDbUrl && reqOk && guards && uiOk && _p0013LibraryOk() && _p0088CurrentStatePreserved()
         && _p0101SurfaceOk() && _p0101SkillIdOk() && _p0101PathStrictOk() && _p0102HonestyOk()
         && _p0103FlagsOk() && _p0103JsonOk() && _p0103RootOk() && _p0104UsageOk()
-        && _p0014SecretBaselineOk() && _p0104ReminderOk() && _p0015ModeOk();
+        && _p0014SecretBaselineOk() && _p0104ReminderOk() && _p0015ModeOk() && _p0097AsyncLockOk() && _p0109ClaimGateOk();
     } },
     { name: '시크릿 스캐너 F-06 (1.36.56, 외부감사): 무명 확장자 소형 텍스트 스캔(이진 NUL 제외) + 같은 토큰 중복 보고 dedupe — 행위검사', run: () => {
       const tmp = fs.mkdtempSync(path.join(os.tmpdir(), '__leerness_sc56_'));
@@ -8071,6 +8102,62 @@ function _p0015ModeOk() {
 }
 // 1.36.104: handoff 가 사람이 쓴 .harness/agent-reminders.md 를 통째로 지웠다(exit 0 · 안내 없음 · 백업 없음).
 //   대조군이 필수다 — 자동 생성분까지 남기면 그 파일이 영구 잔존해 매 세션 거짓 경보가 된다.
+// 1.36.108 (T-0097, 자체 적대 검사에서 발견): `_withLock` 에 **비동기 fn** 을 넘기면 동기 finally 가
+//   프로미스가 정착하기 전에 락을 푼다 — 본체는 락 없이 돌면서 호출부는 보호받는다고 믿는다.
+//   `provider sync`(15초 네트워크 fetch)를 감싸며 실제로 이 형태를 만들었고, e2e 는 그 명령을 돌리지 않아 못 잡았다.
+//   순수 호출로 계약을 고정한다: 프로미스가 끝나기 전에는 락 파일이 살아 있어야 하고, 끝나면 사라져야 한다.
+//   selftest 는 `c.run() === true` 만 통과시키므로(프로미스는 자동 실패) **동기 thenable** 로 같은 분기를
+//   결정적으로 밟는다 — `typeof out.then === 'function'` 이라는 판별 조건이 동일하다.
+// 1.36.109 (완료게이트 사냥): 두 결함을 **순수 호출**로 고정한다. 둘 다 양방향으로 단언한다 —
+//   막아야 할 것을 막는지, 그리고 통과해야 할 것이 계속 통과하는지. false-BLOCK 은 false-PASS 보다 나쁘다.
+function _p0109ClaimGateOk() {
+  try {
+    const an = require('../lib/analyzers');
+    // ① 빈 파일은 가장 명백한 스텁이다. 종전엔 `!body` 때문에 "스텁 아님" 이었고, 공백 3자보다 0바이트가 더 쉽게 통과했다.
+    const emptyIsStub = _vcImplIsEmpty('') === true && _vcImplIsEmpty('   \n\n ') === true;
+    const realIsNot = _vcImplIsEmpty('function f(){return 1;}\nmodule.exports={f};\n') === false
+      && _vcImplIsEmpty('def f():\n    return 1\n') === false;          // 대조군 — 실코드는 스텁이 아니다
+    const badInput = _vcImplIsEmpty(null) === false && _vcImplIsEmpty(undefined) === false;  // 문자열 아닌 입력은 판정하지 않는다
+    // ② 밑줄로 시작하는 파일명이 **잘리지 않고 통째로** 추출돼야 한다. 잘리면 없는 파일을 찾아 정직한 주장을 거부한다.
+    const grab = (s) => (String(s).match(an._EVIDENCE_FILE_RE()) || [])[0] || null;
+    const underscore = grab('src/_helpers.js 구현 완료') === 'src/_helpers.js'
+      && grab('pages/_app.tsx 수정') === 'pages/_app.tsx'
+      && grab('pkg/__init__.py 추가') === 'pkg/__init__.py'
+      && grab('_private/util.ts 정리') === '_private/util.ts';
+    const plainStill = grab('src/normal.js 구현') === 'src/normal.js'                 // 대조군 — 기존 인식 유지
+      && grab('ops/containers/Dockerfile 작성') === 'ops/containers/Dockerfile'
+      && grab('.github/workflows/ci.yml 갱신') === '.github/workflows/ci.yml';
+    return emptyIsStub && realIsNot && badInput && underscore && plainStill;
+  } catch { return false; }
+}
+function _p0097AsyncLockOk() {
+  const os2 = require('os');
+  const arena = fs.mkdtempSync(path.join(os2.tmpdir(), 'leerness-p97lk-'));
+  try {
+    const target = path.join(arena, 'store.json');
+    const lockFile = target + '.lock';
+    fs.writeFileSync(target, '{}');
+    // ① 비동기 본체: 아직 정착하지 않은 동안 락이 살아 있어야 한다(조기 해제 = 보호 0).
+    let heldWhilePending = null;
+    const thenable = { then(onOk) { heldWhilePending = fs.existsSync(lockFile); onOk('done'); return 'settled'; } };
+    const r1 = _withLock(target, () => thenable);
+    const releasedAfterSettle = !fs.existsSync(lockFile) && r1 === 'settled';
+    // ② 대조군 — 동기 fn 은 종전대로 즉시 해제되고 값을 그대로 돌려준다(회귀로 락을 붙잡지 않았는지).
+    const r2 = _withLock(target, () => 42);
+    const syncReleased = !fs.existsSync(lockFile) && r2 === 42;
+    // ③ 예외 경로도 해제되어야 한다 — 안 그러면 한 번 던진 뒤 그 스토어가 영구 잠긴다.
+    let threw = false;
+    try { _withLock(target, () => { throw new Error('x'); }); } catch { threw = true; }
+    const errReleased = threw && !fs.existsSync(lockFile);
+    // ④ 거부된 thenable 도 해제 + 사유 전파.
+    let rejThrew = false;
+    const badThenable = { then(onOk, onErr) { onErr(new Error('boom')); return 'rejected'; } };
+    try { _withLock(target, () => badThenable); } catch { rejThrew = true; }
+    const rejReleased = rejThrew && !fs.existsSync(lockFile);
+    return heldWhilePending === true && releasedAfterSettle && syncReleased && errReleased && rejReleased;
+  } catch { return false; }
+  finally { try { fs.rmSync(arena, { recursive: true, force: true }); } catch {} }
+}
 function _p0104ReminderOk() {
   const os2 = require('os');
   const cp2 = require('child_process');
@@ -9062,13 +9149,16 @@ function _runPreWakeAudit(root) {
   };
   return audit;
 }
+// 1.36.108 (T-0097): append 형 RMW — session close 와 pre-wake-audit 가 겹칠 수 있다.
 function _saveAndAppendPreWakeReport(root, audit) {
-  const state = _loadPreWakeReport(root);
-  state.reports.push(audit);
-  // 최근 10개만 유지
-  if (state.reports.length > 10) state.reports = state.reports.slice(-10);
-  _writePreWakeReport(root, state.reports);
-  return audit;
+  return _withLock(_preWakeReportPath(root), () => {
+    const state = _loadPreWakeReport(root);
+    state.reports.push(audit);
+    // 최근 10개만 유지
+    if (state.reports.length > 10) state.reports = state.reports.slice(-10);
+    _writePreWakeReport(root, state.reports);
+    return audit;
+  });
 }
 
 // 1.9.220: 비정상 종료 감지 + 자율 재개 (사용자 명시)
@@ -9226,14 +9316,18 @@ function _writeWakeupHistory(root, state) {
     return true;
   } catch { return false; }
 }
+// 1.36.108 (T-0097): append 형 RMW — 락 밖이면 동시 기록이 서로를 지운다.
+//   이 스토어는 자동(스케줄)과 사용자 트리거가 동시에 들어올 수 있어 겹칠 여지가 실제로 있다.
 function _recordWakeupFire(root, kind) {
   // kind: 'auto' (scheduled), 'user-trigger' (사용자 명시 다음라운드), 'wakeup-miss'
-  const state = _loadWakeupHistory(root);
-  state.fires.push({ at: new Date().toISOString(), kind: kind || 'auto' });
-  // 최근 50개만 유지
-  if (state.fires.length > 50) state.fires = state.fires.slice(-50);
-  _writeWakeupHistory(root, state);
-  return state;
+  return _withLock(_wakeupHistoryPath(root), () => {
+    const state = _loadWakeupHistory(root);
+    state.fires.push({ at: new Date().toISOString(), kind: kind || 'auto' });
+    // 최근 50개만 유지
+    if (state.fires.length > 50) state.fires = state.fires.slice(-50);
+    _writeWakeupHistory(root, state);
+    return state;
+  });
 }
 // 권장 interval 계산 (sec)
 //   user-trigger 빈도 + pre-wake critical + 최근 평균 gap 기반
@@ -9891,6 +9985,13 @@ function sessionResumeCmd(root) {
 //   add <id> --aliases ... --constraint "kind:detail" → 사용자 정의 플랫폼 추가
 function constraintsCmd(root, sub, ...rest) {
   root = absRoot(root);
+  // 1.36.108 (T-0097): 변경 하위명령은 읽기~쓰기 전체를 직렬화한다(clarify/referee 와 같은 재진입 패턴).
+  //   손상 거부(1.36.78)는 손상만 막고 **동시 쓰기 유실**은 못 막는다 — 두 제약을 동시에 추가하면 하나가 조용히 사라진다.
+  if (sub === 'add' && !_withLock.__inConstraints) {
+    _withLock.__inConstraints = true;
+    try { return _withLock(_platformConstraintsPath(root), () => constraintsCmd(root, sub, ...rest)); }
+    finally { _withLock.__inConstraints = false; }
+  }
   const isTty = process.stdout && process.stdout.isTTY;
   const cyan = s => isTty ? `\x1b[36m${s}\x1b[0m` : s;
   const grn = s => isTty ? `\x1b[32m${s}\x1b[0m` : s;
@@ -10135,9 +10236,12 @@ function wakeupIntervalCmd(root, sub, val) {
   if (sub === 'set') {
     const n = Number(val);
     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);
+    // 1.36.108 (T-0097): override 만 바꾸는데도 파일 전체를 다시 쓴다 — 락 밖이면 그 사이 기록된 fires 가 사라진다.
+    _withLock(_wakeupHistoryPath(root), () => {
+      const state = _loadWakeupHistory(root);
+      state.override = n;
+      _writeWakeupHistory(root, state);
+    });
     if (has('--json')) { log(JSON.stringify({ override: n }, null, 2)); return; }
     log(grn(`✓ wakeup-interval override 설정: ${n}s (${Math.round(n/60)}min)`));
     log(dim(`  해제: leerness wakeup-interval auto`));
@@ -10145,9 +10249,11 @@ function wakeupIntervalCmd(root, sub, val) {
   }
 
   if (sub === 'auto') {
-    const state = _loadWakeupHistory(root);
-    state.override = null;
-    _writeWakeupHistory(root, state);
+    _withLock(_wakeupHistoryPath(root), () => {
+      const state = _loadWakeupHistory(root);
+      state.override = null;
+      _writeWakeupHistory(root, state);
+    });
     const result = _computeAdaptiveInterval(root);
     if (has('--json')) { log(JSON.stringify({ override: null, current: result }, null, 2)); return; }
     log(grn(`✓ override 해제 — 자동 계산 모드`));
@@ -10864,21 +10970,25 @@ function _writeNextActionQueue(root, queue) {
   } catch { return false; }
 }
 // handoff 에서 제안된 next-action 들을 큐에 자동 저장 (중복 방지: 이미 있는 title 은 skip)
+// 1.36.108 (T-0097): 읽기~쓰기를 락으로 직렬화. 이 큐는 handoff 가 자동으로도 채우기 때문에
+//   사용자가 `next-action add` 하는 순간 handoff 가 겹칠 수 있다 — 실사용에서 가장 겹치기 쉬운 조합이다.
 function _enqueueNextActions(root, actions) {
   if (!Array.isArray(actions) || actions.length === 0) return 0;
-  const state = _loadNextActionQueue(root);
-  const existingTitles = new Set(state.queue.map(a => a.title));
-  let added = 0;
-  for (const a of actions) {
-    if (existingTitles.has(a.title)) continue;
-    state.queue.push({ ...a, addedAt: new Date().toISOString() });
-    existingTitles.add(a.title);
-    added++;
-  }
-  // 최근 20개만 유지
-  if (state.queue.length > 20) state.queue = state.queue.slice(-20);
-  if (added > 0) _writeNextActionQueue(root, state.queue);
-  return added;
+  return _withLock(_nextActionQueuePath(root), () => {
+    const state = _loadNextActionQueue(root);
+    const existingTitles = new Set(state.queue.map(a => a.title));
+    let added = 0;
+    for (const a of actions) {
+      if (existingTitles.has(a.title)) continue;
+      state.queue.push({ ...a, addedAt: new Date().toISOString() });
+      existingTitles.add(a.title);
+      added++;
+    }
+    // 최근 20개만 유지
+    if (state.queue.length > 20) state.queue = state.queue.slice(-20);
+    if (added > 0) _writeNextActionQueue(root, state.queue);
+    return added;
+  });
 }
 
 // 1.9.201: next-action CLI 명령 — handoff 가 저장한 queue 에서 take/list/clear
@@ -10916,8 +11026,14 @@ async function nextActionCmd(root, sub, ...rest) {
     try {
       const taskTitle = action.title.replace(/^[^\w가-힣]+/, '').slice(0, 100);
       // 큐에서 제거 → write
-      state.queue.splice(n, 1);
-      _writeNextActionQueue(root, state.queue);
+      // 1.36.108 (T-0097): 락 안에서 **다시 읽고** 제거한다. 함수 머리에서 읽은 state 로 지우면
+      //   그 사이에 handoff 가 큐에 넣은 항목이 통째로 사라진다(handoff 는 자동으로 이 큐를 채운다).
+      _withLock(_nextActionQueuePath(root), () => {
+        const fresh = _loadNextActionQueue(root);
+        const idx = fresh.queue.findIndex(a => a && a.title === action.title);
+        if (idx >= 0) fresh.queue.splice(idx, 1);
+        _writeNextActionQueue(root, fresh.queue);
+      });
       // leerness task add 호출
       const taskResult = cp.spawnSync(process.execPath, [__filename, 'task', 'add', taskTitle, '--path', root], { encoding: 'utf8', timeout: 8000, env: { ...process.env, LEERNESS_INTERNAL: '1' } });
       if (taskResult.status === 0) {
@@ -12423,7 +12539,7 @@ function debug(root) {
 
 const _audit = require('../lib/audit');
 // 1.9.421 (UR-0025/UR-0125 큰 핸들러 모듈화 6번째): audit → lib/audit.js (DI 위임, thin wrapper)
-function audit(root, opts = {}) { return _audit.audit(root, opts, { VERSION, arg, has, planPath, readProgressRows, currentStatePath, handoffPath, envDiff, _readFeatureGraph, _matchAPISkills, _listAPISkills, _collectSecretFindings, _integrityFindings }); }   // 1.36.79: integrity 신호 공유
+function audit(root, opts = {}) { return _audit.audit(root, opts, { VERSION, arg, has, planPath, readProgressRows, currentStatePath, handoffPath, envDiff, _readFeatureGraph, _matchAPISkills, _listAPISkills, _collectSecretFindings, _integrityFindings, _withLock }); }   // 1.36.79: integrity 신호 공유 · 1.36.108: 락 주입(T-0097)
 
 // 1.9.312 (UR-0050, 설치리뷰 3중수렴): secret 스캐너 현대 키 패턴 보강.
 //   배경: 기존 OpenAI 패턴 `sk-[A-Za-z0-9]{32,}` 은 하이픈에서 끊겨 sk-proj-/sk-svcacct- (modern 프로젝트/서비스 키)를 놓침.
@@ -13868,9 +13984,13 @@ function handoff(root) {
   } else {
     log(out);
   }
+  // 1.36.108 (T-0097): 날짜 스탬프도 read-modify-write 다 — 사용자가 쓴 본문 전체를 다시 쓴다.
+  //   락 밖이면 그 사이 session close 가 갱신한 Now/Next/Blockers 를 낡은 사본으로 되돌린다.
   if (exists(currentStatePath(root))) {
-    const cs = read(currentStatePath(root)).replace(/Updated: \d{4}-\d{2}-\d{2}/, `Updated: ${today()}`);
-    writeUtf8(currentStatePath(root), cs);
+    _withLock(currentStatePath(root), () => {
+      const cs = read(currentStatePath(root)).replace(/Updated: \d{4}-\d{2}-\d{2}/, `Updated: ${today()}`);
+      writeUtf8(currentStatePath(root), cs);
+    });
   }
   // 1.9.56: handoff에 lessons --auto 자동 통합 — 현재 in-progress task와 관련된 과거 실수/결정 자동 재상기
   // 매 세션 시작 시 AI가 과거에 같은 키워드로 실패한 사례를 잊지 않도록.
@@ -15074,7 +15194,12 @@ const _VC_EMPTY_SHELL_RE = new RegExp(
   ].join('|') + ')(?:\\s+as\\s+[A-Za-z0-9_$.<>\\[\\] ]+?)?\\s*;?$'           // 선택적 TS 캐스트(as any) + ;
 );
 function _vcImplIsEmpty(body) {
-  if (typeof body !== 'string' || !body) return false;
+  // 1.36.109 (완료게이트 사냥): 빈 문자열은 **가장 명백한 스텁**인데 `!body` 가 그걸 "스텁 아님" 으로 만들었다.
+  //   공백 3자짜리 파일은 stub-impl 로 막히는데 0바이트는 통과했다 — 같은 것이 더 비어 있을수록 통과하는 역전이다.
+  //   (`touch src/x.js` + evidence "src/x.js 구현 완료" → verify-claim 통과, 실측.)
+  //   읽기 실패는 호출부가 catch 로 걸러 여기 오지 않는다. 빈 본문은 곧 빈 구현이다.
+  if (typeof body !== 'string') return false;
+  if (body === '') return true;
   // 블록주석 제거 → 줄별 trim/주석줄 제거 → 인라인 // 주석 제거(따옴표 없는 줄만, 문자열 보호) → join.
   const codeLines = body.replace(/\/\*[\s\S]*?\*\//g, '').split('\n').map(l => {
     let t = l.trim();
@@ -15180,6 +15305,12 @@ function verifyClaimCmd(root, taskId, opts = {}) {
   for (const m of evidence.matchAll(FILE_RE)) {
     const prev = m.index > 0 ? evidence[m.index - 1] : '';
     if (prev === '\\' || prev === '/') continue;   // suffix-of-longer-path(UNC \\srv\..., C:\..., URL) → skip. ':' 는 "파일:src/x.js" 정상 케이스라 스킵 안 함
+    // 1.36.109 (codex 검수 P2, 재현됨): 구분자만 보던 가드에 두 구멍이 있었다 —
+    //   `https://…/docs#_anchor.js` 의 URL 조각과 `C:_anchor.js` 의 드라이브 상대 경로가 **루트 상대 파일 주장**이 됐다.
+    //   (밑줄 확장 전에도 같은 형태로 `anchor.js` 가 통과했다 — 내가 만든 클래스는 아니지만 여기서 닫는다.)
+    //   `:` 를 통째로 막으면 "파일:src/x.js" 같은 정상 표기가 죽으므로, **앞이 단일 영문자인 `:` 만** 드라이브로 본다.
+    if (prev === '#') continue;                                               // URL 조각
+    if (prev === ':' && /^[A-Za-z]$/.test(evidence[m.index - 2] || '')) continue;   // C:name (드라이브 상대)
     filePatterns.push(m[0].replace(/\\/g, '/'));
   }
   // 중복 제거 + "tests/test.js" 같은 결과를 유지 (이미 `..` 없으니 그대로)
@@ -15226,15 +15357,34 @@ function verifyClaimCmd(root, taskId, opts = {}) {
   // 1.17.3 (UR-0046 범용성 P1②): 빈껍데기(스텁) 구현 + 테스트-구현 연결 검사 — "주석뿐 구현 + assert(true) 테스트"가 verify-claim 을 exit 0 으로 통과하던 공격(5축 실증 Attack C) 차단.
   //   ① 스텁: 주장된 코드 파일(테스트 제외)의 비주석 코드줄이 0 이면 확정 스텁 — done 게이팅 FAIL(확실 신호만, 과탐 0).
   //   ② 연결: 주장에 구현+테스트가 모두 있는데 어떤 테스트도 구현 파일명(basename)을 참조하지 않으면 — 기본 advisory ⚠, --strict-claims 시 FAIL.
-  const _VC_CODE_EXT = /\.(js|mjs|cjs|jsx|ts|tsx|py|rb|go|rs|java|cs|php)$/i;
+  // 1.36.109 (codex 검수 P2): `pyi` 추가 — 여기에 없으면 위의 마커 예외가 **도달 불가**다(광고만 하고 안 도는 코드).
+  const _VC_CODE_EXT = /\.(js|mjs|cjs|jsx|ts|tsx|pyi|py|rb|go|rs|java|cs|php)$/i;
   const _VC_TEST_PAT = /(^|[\\/])(test_[^\\/]+\.[a-z]+|[^\\/]+[._-]test\.[a-z]+|[^\\/]+\.spec\.[a-z]+)$|(^|[\\/])tests?[\\/]/i;
   const stubFiles = [];
+  // 1.36.109 (codex 검수 P1, 재현됨): 관례상 비어 있는 **마커 파일**은 스텁으로 몰면 안 되지만,
+  //   그것만으로 "구현했다" 가 성립해서도 안 된다. 처음엔 무조건 예외로 뒀더니 빈 `pkg/__init__.py` **하나만**
+  //   인용한 done 이 exit 0 을 받았다(검수가 재현) — 내가 막겠다고 고친 바로 그 형태를 예외가 되살린 것이다.
+  //   그래서 예외는 "다른 실질 파일이 함께 인용됐을 때만" 적용한다. 판정은 루프 뒤로 미룬다.
+  const markerFiles = [];
+  const _isPkgMarker = (f) => /(^|[\\/])__init__\.pyi?$/.test(f);
   for (const c of fileChecks) {
     if (!c.exists || !_VC_CODE_EXT.test(c.file) || _VC_TEST_PAT.test(c.file)) continue;
     let body = ''; try { body = read(path.join(root, c.file)); } catch { continue; }
-    if (!body || body.length > 512 * 1024) continue;
+    // 1.36.109: `!body` 를 스킵 조건에 두면 0바이트 파일이 스텁 검사를 통째로 건너뛴다(가드 두 겹이 서로를 가림 —
+    //   여기와 `_vcImplIsEmpty` 양쪽에 같은 falsy 함정이 있었고 한 곳만 고치면 구멍이 남는다). 크기 상한만 남긴다.
+    if (body.length > 512 * 1024) continue;
     // 1.18.2: 코드 0줄(기존) + 빈 export 껍데기(위장 스텁) 통합 판정.
-    if (_vcImplIsEmpty(body)) stubFiles.push(c.file);
+    if (!_vcImplIsEmpty(body)) continue;
+    if (_isPkgMarker(c.file)) { markerFiles.push(c.file); continue; }   // 판정 보류 — 아래에서 결정
+    stubFiles.push(c.file);
+  }
+  // 빈 마커를 봐 주는 조건: 같이 인용된 **비어 있지 않은** 코드 파일이 하나라도 있어야 한다.
+  //   (파이썬 패키지 추가는 보통 `__init__.py` + 실제 모듈이 함께 온다 — 그 정직한 형태만 통과시킨다.)
+  if (markerFiles.length) {
+    const substantive = fileChecks.some(c =>
+      c.exists && _VC_CODE_EXT.test(c.file) && !_VC_TEST_PAT.test(c.file) && !_isPkgMarker(c.file)
+      && !stubFiles.includes(c.file));
+    if (!substantive) for (const f of markerFiles) stubFiles.push(f);
   }
   const _vcImpl = fileChecks.filter(c => c.exists && _VC_CODE_EXT.test(c.file) && !_VC_TEST_PAT.test(c.file)).map(c => c.file);
   const _vcTests = fileChecks.filter(c => c.exists && _VC_CODE_EXT.test(c.file) && _VC_TEST_PAT.test(c.file)).map(c => c.file);
@@ -16284,22 +16434,26 @@ function _loadAgentSlashCommands(root) {
 //   기존 사용자 override 가 있으면 보존(병합 결과 기록). force 시 빌트인으로 덮어쓰기.
 function _recordAgentSlashCommands(root, opts = {}) {
   const f = _agentSlashFile(root);
-  let agents;
-  if (opts.force || !exists(f)) {
-    agents = {};
-    for (const [id, def] of Object.entries(AGENT_SLASH_COMMANDS)) {
-      agents[id] = { label: def.label, asOf: def.asOf, invoke: def.invoke || 'slash', note: def.note || undefined, commands: def.commands.slice() };
-    }
-  } else {
-    const merged = _loadAgentSlashCommands(root);
-    agents = {};
-    for (const [id, def] of Object.entries(merged)) {
-      agents[id] = { label: def.label, asOf: def.asOf, invoke: def.invoke, note: def.note || undefined, commands: def.commands };
-    }
-  }
   mkdirp(path.dirname(f));
-  writeUtf8(f, JSON.stringify({ schemaVersion: 1, recordedAt: new Date().toISOString(), agents }, null, 2) + '\n');
-  return { file: f, agentCount: Object.keys(agents).length };
+  // 1.36.108 (T-0097): 비-force 경로는 기존 파일을 읽어 병합한 결과를 쓴다 = read-modify-write.
+  //   락 밖이면 그 사이 --refresh 가 probe 로 갱신한 agent 가 낡은 병합본에 덮인다(둘 다 이 파일을 쓴다).
+  return _withLock(f, () => {
+    let agents;
+    if (opts.force || !exists(f)) {
+      agents = {};
+      for (const [id, def] of Object.entries(AGENT_SLASH_COMMANDS)) {
+        agents[id] = { label: def.label, asOf: def.asOf, invoke: def.invoke || 'slash', note: def.note || undefined, commands: def.commands.slice() };
+      }
+    } else {
+      const merged = _loadAgentSlashCommands(root);
+      agents = {};
+      for (const [id, def] of Object.entries(merged)) {
+        agents[id] = { label: def.label, asOf: def.asOf, invoke: def.invoke, note: def.note || undefined, commands: def.commands };
+      }
+    }
+    writeUtf8(f, JSON.stringify({ schemaVersion: 1, recordedAt: new Date().toISOString(), agents }, null, 2) + '\n');
+    return { file: f, agentCount: Object.keys(agents).length };
+  });
 }
 // dispatch 참조용 — 특정 agent 의 슬래시 명령어 힌트 (서브에이전트 프롬프트에 주입할 1줄 요약 + 배열).
 //   2단계에서 agents multi/agent dispatch 가 이 헬퍼로 각 에이전트에 맞는 슬래시 명령을 안내.
@@ -16375,7 +16529,17 @@ function _refreshAgentSlashCommands(root, targets, opts = {}) {
   if (anyOk && !opts.dryRun) {
     file = _agentSlashFile(root);
     mkdirp(path.dirname(file));
-    writeUtf8(file, JSON.stringify({ schemaVersion: 1, recordedAt: new Date().toISOString(), refreshedAt: new Date().toISOString(), agents }, null, 2) + '\n');
+    // 1.36.108 (T-0097): probe 는 외부 CLI 를 띄우느라 오래 걸린다 — **락 밖에서** 돌리고 저장만 락 안에서 한다
+    //   (lib/referee.js 가 캘리브레이션에 세운 규칙과 같다: 긴 작업을 락 안에 넣으면 stale 30s 에 락을 뺏겨
+    //   오히려 남의 결과를 지운다). 락 안에서 파일을 **다시 읽어** 이번에 성공한 agent 만 덮어쓴다.
+    const probed = results.filter(r => r.ok).map(r => r.id);
+    _withLock(file, () => {
+      const fresh = _loadAgentSlashCommands(root);
+      const out = {};
+      for (const [id, d] of Object.entries(fresh)) out[id] = { label: d.label, asOf: d.asOf, invoke: d.invoke, note: d.note || undefined, commands: d.commands };
+      for (const id of probed) out[id] = agents[id];
+      writeUtf8(file, JSON.stringify({ schemaVersion: 1, recordedAt: new Date().toISOString(), refreshedAt: new Date().toISOString(), agents: out }, null, 2) + '\n');
+    });
   }
   return { results, file, anyOk };
 }
@@ -16532,6 +16696,14 @@ function _allProviders(root) {
 }
 function providerCmd(root, sub, ...args) {
   root = absRoot(root || process.cwd());
+  // 1.36.108 (T-0097): 변경 하위명령은 읽기~쓰기를 직렬화. 목록 RMW 라 동시 등록 시 한쪽이 조용히 사라진다(실측).
+  //   `sync` 는 **여기서 감싸지 않는다** — 최대 15초 네트워크 fetch 를 락 안에 두면 stale(30s) 창에 다가가고,
+  //   다른 프로세스가 락을 뺏어 둘 다 쓰게 된다(lib/referee.js 가 캘리브레이션에 세운 규칙). 저장만 아래에서 감싼다.
+  if (['add', 'remove'].includes(sub) && !providerCmd.__locked) {
+    providerCmd.__locked = true;
+    try { return _withLock(_providersFile(root), () => providerCmd(root, sub, ...args)); }
+    finally { providerCmd.__locked = false; }
+  }
   _loadEnvFile(root);
   if (!sub || sub === 'list') {
     const all = _allProviders(root);
@@ -16683,7 +16855,14 @@ function providerCmd(root, sub, ...args) {
           log(`  + ${e.id} (신규)`);
         }
       }
-      if (!dryRun) _writeUserProviders(root, userList);
+      // 1.36.108 (T-0097): 네트워크는 락 밖에서 끝났다. 저장만 락 안에서 하되 **다시 읽어** 병합한다 —
+      //   위의 userList 는 fetch 전 스냅샷이라, 그 사이 `provider add` 한 항목을 그대로 덮으면 지운다.
+      if (!dryRun) _withLock(_providersFile(root), () => {
+        const fresh = _readUserProviders(root);
+        const byId = new Map(fresh.map(u => [u.id, u]));
+        for (const u of userList) byId.set(u.id, u);      // 이번 sync 결과가 이긴다(그게 sync 의 의미다)
+        _writeUserProviders(root, [...byId.values()]);
+      });
       log('');
       log(`✓ sync 완료: 신규 ${added} · 갱신 ${updated} · 무시 ${skipped}${dryRun ? ' (--dry-run)' : ''}`);
       if (!dryRun) log(`   .env 에 LEERNESS_ENABLE_<X>=1 설정 후 \`leerness agents list\` 로 확인`);
@@ -17659,7 +17838,7 @@ function llmBenchRecordCmd(root) {
 
 const _sessionClose = require('../lib/session-close');
 // 1.9.425 (UR-0025/UR-0125 큰 핸들러 모듈화 10번째): sessionClose → lib/session-close.js (DI 위임)
-function sessionClose(root, opts = {}) { return _sessionClose.sessionClose(root, opts, { VERSION, STATUSES, MARK, has, arg, uiLang: _uiLang(root), harnessPath: __filename, readProgressRows, evidencePath, handoffPath, currentStatePath, taskLogPath, verifyRules, _autoRoadmap, _readUsageStats, readSessionCounter, writeSessionCounter, _retroAggregate, _retroOneLine, retroCmd, _loadDecisions, readRules, planPath, _loadLessons, _readFeatureGraph, _auditUserRequests, _detectDeliveredRequests, _computeRoundHistory, _computeMilestones, _computeRecentChanges, _collectPyFiles, _analyzePyFile, _collectRuntimeEnv, _scanShellScriptsEncoding, _listAPISkills, _matchAPISkills, _loadShellFailures, _shellEnvDrift, _runPreWakeAudit, _saveAndAppendPreWakeReport, _runIdempotencyAudit, _detectAbnormalShutdown, _updateUserRequest, _detectOptimism, _scanCodeForPatterns, _collectSecretFindings }); }  // 1.17.6 (UR-0049): 마감 정합 — done 낙관 재확인 + 시크릿 재확인
+function sessionClose(root, opts = {}) { return _sessionClose.sessionClose(root, opts, { VERSION, STATUSES, MARK, has, arg, uiLang: _uiLang(root), harnessPath: __filename, readProgressRows, evidencePath, handoffPath, currentStatePath, taskLogPath, verifyRules, _autoRoadmap, _readUsageStats, readSessionCounter, writeSessionCounter, _retroAggregate, _retroOneLine, retroCmd, _loadDecisions, readRules, planPath, _loadLessons, _readFeatureGraph, _auditUserRequests, _detectDeliveredRequests, _computeRoundHistory, _computeMilestones, _computeRecentChanges, _collectPyFiles, _analyzePyFile, _collectRuntimeEnv, _scanShellScriptsEncoding, _listAPISkills, _matchAPISkills, _loadShellFailures, _shellEnvDrift, _runPreWakeAudit, _saveAndAppendPreWakeReport, _runIdempotencyAudit, _detectAbnormalShutdown, _updateUserRequest, _detectOptimism, _scanCodeForPatterns, _collectSecretFindings, _withLock }); }  // 1.17.6 (UR-0049): 마감 정합 — done 낙관 재확인 + 시크릿 재확인 · 1.36.108: 락 주입(T-0097)
 
 function readmeCmd(root) { syncReadme(absRoot(root)); }
 function consistencyCheck(root) {
@@ -18991,28 +19170,48 @@ function ruleList(root) {
   for (const r of rules) log(`| ${r.id} | ${_cellSafe(r.trigger)} | ${_cellSafe(r.rule)} | ${r.status} | ${r.lastVerified} |`);  // 16th 버그헌트 F2: 파이프 칼럼 깨짐 차단(표시 _cellSafe)
 }
 
+// 1.36.108 (T-0097): rules.md 의 read-modify-write 병목. 종전엔 `rule add` **하나만** 락 안이었고
+//   remove/pause/resume/stop/resume-all 다섯이 락 밖이었다(런타임 계측으로 실측 — 같은 스토어, 진입점 6개, 보호 1개).
+//   진입점마다 거는 방식은 이렇게 샌다. 읽기와 쓰기를 한 함수에 묶어 그 안에서 직렬화한다.
+//   mutate 가 문자열을 돌려주면 그것을 실패 사유로 보고 쓰기를 건너뛴다(락 안에서 중단).
+function _updateRules(root, mutate) {
+  return _withLock(rulesPath(root), () => {
+    const rules = readRules(root);
+    const r = mutate(rules);
+    if (typeof r === 'string') return { error: r };
+    writeRules(root, rules);
+    return { ok: true, value: r };
+  });
+}
+
 function ruleRemove(root, id) {
   root = absRoot(root);
   if (!id) return fail('id required');
-  const rules = readRules(root);
-  const i = rules.findIndex(r => r.id === id);
-  if (i < 0) return failJson(has('--json'), 'rule_not_found', `rule not found: ${id}`);   // codex P2: --json 에러 구조화
-  const removed = rules.splice(i, 1)[0];
-  writeRules(root, rules);
-  const archive = exists(rulesArchivePath(root)) ? read(rulesArchivePath(root)) : '# Rules archive\n\n| ID | Trigger | Rule | Added | Status | Removed |\n|---|---|---|---|---|---|\n';
-  // 1.11.3 (14th 버그헌트 P2, UR-0179): 아카이브 셀도 _cellSafe — 기존엔 removed.rule/trigger 를 raw 기록해 파이프(|) 포함 룰이 아카이브 표를 깨뜨렸음(rules.md 는 이미 _cellSafe 적용).
-  writeUtf8(rulesArchivePath(root), archive + `| ${_cellSafe(removed.id)} | ${_cellSafe(removed.trigger)} | ${_cellSafe(removed.rule)} | ${_cellSafe(removed.added)} | removed | ${today()} |\n`);
+  let removed = null;
+  const res = _updateRules(root, (rules) => {
+    const i = rules.findIndex(r => r.id === id);
+    if (i < 0) return 'rule_not_found';
+    removed = rules.splice(i, 1)[0];
+    // 아카이브 추가도 같은 락 안에서 — 표 갱신과 아카이브가 갈라지면 룰이 양쪽 어디에도 없게 된다.
+    const archive = exists(rulesArchivePath(root)) ? read(rulesArchivePath(root)) : '# Rules archive\n\n| ID | Trigger | Rule | Added | Status | Removed |\n|---|---|---|---|---|---|\n';
+    // 1.11.3 (14th 버그헌트 P2, UR-0179): 아카이브 셀도 _cellSafe — 기존엔 removed.rule/trigger 를 raw 기록해 파이프(|) 포함 룰이 아카이브 표를 깨뜨렸음(rules.md 는 이미 _cellSafe 적용).
+    writeUtf8(rulesArchivePath(root), archive + `| ${_cellSafe(removed.id)} | ${_cellSafe(removed.trigger)} | ${_cellSafe(removed.rule)} | ${_cellSafe(removed.added)} | removed | ${today()} |\n`);
+    return removed;
+  });
+  if (res.error) return failJson(has('--json'), 'rule_not_found', `rule not found: ${id}`);   // codex P2: --json 에러 구조화
   ok(`rule removed: ${id} (보존: .harness/rules.archive.md)`);
 }
 
 function rulePause(root, id) {
   root = absRoot(root);
   if (!id) return fail('id required');
-  const rules = readRules(root);
-  const r = rules.find(x => x.id === id);
-  if (!r) return fail(`rule not found: ${id}`);
-  r.status = 'paused';
-  writeRules(root, rules);
+  const res = _updateRules(root, (rules) => {
+    const r = rules.find(x => x.id === id);
+    if (!r) return 'rule_not_found';
+    r.status = 'paused';
+    return r;
+  });
+  if (res.error) return fail(`rule not found: ${id}`);
   ok(`rule paused: ${id}`);
   _autoRoadmap(root, 'data-change');
 }
@@ -19020,31 +19219,35 @@ function rulePause(root, id) {
 function ruleResume(root, id) {
   root = absRoot(root);
   if (!id) return fail('id required');
-  const rules = readRules(root);
-  const r = rules.find(x => x.id === id);
-  if (!r) return fail(`rule not found: ${id}`);
-  r.status = 'active';
-  writeRules(root, rules);
+  const res = _updateRules(root, (rules) => {
+    const r = rules.find(x => x.id === id);
+    if (!r) return 'rule_not_found';
+    r.status = 'active';
+    return r;
+  });
+  if (res.error) return fail(`rule not found: ${id}`);
   ok(`rule resumed: ${id}`);
   _autoRoadmap(root, 'data-change');
 }
 
 function ruleStop(root) {
   root = absRoot(root);
-  const rules = readRules(root);
-  let n = 0;
-  for (const r of rules) if (r.status === 'active') { r.status = 'paused'; n++; }
-  writeRules(root, rules);
-  ok(`${n}개 룰 일시 정지 (rule resume <id> 또는 rule resume-all로 재개)`);
+  const res = _updateRules(root, (rules) => {
+    let n = 0;
+    for (const r of rules) if (r.status === 'active') { r.status = 'paused'; n++; }
+    return n;
+  });
+  ok(`${res.value}개 룰 일시 정지 (rule resume <id> 또는 rule resume-all로 재개)`);
 }
 
 function ruleResumeAll(root) {
   root = absRoot(root);
-  const rules = readRules(root);
-  let n = 0;
-  for (const r of rules) if (r.status === 'paused') { r.status = 'active'; n++; }
-  writeRules(root, rules);
-  ok(`${n}개 룰 재개`);
+  const res = _updateRules(root, (rules) => {
+    let n = 0;
+    for (const r of rules) if (r.status === 'paused') { r.status = 'active'; n++; }
+    return n;
+  });
+  ok(`${res.value}개 룰 재개`);
 }
 
 function captureProjectState(root) {
@@ -19980,8 +20183,17 @@ function _writeFeatureGraph(root, nodes) {
 //   _featureImpactBfs 는 pure-utils 로 이동(handoff/audit 공유). feature-graph I/O 헬퍼(_readFeatureGraph 등)는 공유라 harness 유지+주입.
 const _feature = require('../lib/feature');
 function _featureDeps() { return { _ensureFeatureGraph, _readFeatureGraph, _writeFeatureGraph, arg, has, _requireInit }; }  // 1.36.2: _requireInit 주입 — feature add 미초기화 dir scaffold 게이트
-function featureAddCmd(root, title) { return _feature.featureAddCmd(root, title, _featureDeps()); }
-function featureLinkCmd(root, fromId) { return _feature.featureLinkCmd(root, fromId, _featureDeps()); }
+// 1.36.108 (T-0097): feature add/link 는 읽기~쓰기 RMW 다(그래프 전체를 다시 렌더링해 저장).
+//   락을 여기서 감싼다 — lib/feature.js 는 I/O 를 주입받으므로 호출 경계가 가장 좁은 병목이다.
+//   단 **`.harness` 가 이미 있을 때만** 감싼다. `_withLock` 은 락 파일을 만들려고 디렉토리를 만드는데,
+//   미초기화 디렉토리에서 이 명령은 scaffold 게이트로 막혀야 하고 잔여 파일을 남기지 않아야 한다(1.36.2 계약).
+//   게이트에 걸릴 경우엔 아무것도 쓰지 않으므로 락도 필요 없다.
+function _featureLocked(root, fn) {
+  const r = absRoot(root);
+  return exists(path.join(r, '.harness')) ? _withLock(featureGraphPath(r), fn) : fn();
+}
+function featureAddCmd(root, title) { return _featureLocked(root, () => _feature.featureAddCmd(root, title, _featureDeps())); }
+function featureLinkCmd(root, fromId) { return _featureLocked(root, () => _feature.featureLinkCmd(root, fromId, _featureDeps())); }
 function featureImpactCmd(root, fromId) { return _feature.featureImpactCmd(root, fromId, _featureDeps()); }
 function featureListCmd(root) { return _feature.featureListCmd(root, _featureDeps()); }
 function featureShowCmd(root, fromId) { return _feature.featureShowCmd(root, fromId, _featureDeps()); }
@@ -25842,11 +26054,18 @@ async function main() {
         return;
       }
       const mf = _mChk.path;
-      // 1.36.107 (codex 검수, 재현됨): Object.assign 은 [[Set]] 을 쓰므로 `__proto__` 키에서 setter 가 걸려
-      //   그 필드를 **조용히 버린다**(실측: 주입 후 mode set → 파일에서 사라짐). 스프레드는 CreateDataProperty 라 보존한다.
-      //   병적인 입력이긴 하나 이 수정이 내건 계약이 "남은 필드를 전부 보존" 이므로, 예외를 두면 계약이 거짓이 된다.
-      const m = { ..._mChk.data };
-      m.mode = want; writeUtf8(mf, JSON.stringify(m, null, 2) + '\n');
+      // 1.36.108 (T-0097): 락 안에서 **다시 읽는다**. 1.36.107 은 손상 판정과 필드 보존을 넣었지만 그 사이 창은 남아 있었다 —
+      //   codex 검수가 rename 직전에 writer 를 주입해 그 writer 의 project/language/installedAt 이 전부 사라지는 것을 재현했다.
+      //   락 밖에서 읽은 _mChk.data 로 쓰면 "보존" 하는 것이 **낡은 스냅샷**이라 옆 프로세스의 변경을 지운다.
+      _withLock(mf, () => {
+        const fresh = _readManifestChecked(_mRoot);
+        if (fresh.corrupt) return;                       // 락 대기 중 손상됐다면 쓰지 않는다(fail-closed 유지)
+        // 1.36.107 (codex 검수, 재현됨): Object.assign 은 [[Set]] 을 쓰므로 `__proto__` 키에서 setter 가 걸려
+        //   그 필드를 **조용히 버린다**(실측: 주입 후 mode set → 파일에서 사라짐). 스프레드는 CreateDataProperty 라 보존한다.
+        //   병적인 입력이긴 하나 이 수정이 내건 계약이 "남은 필드를 전부 보존" 이므로, 예외를 두면 계약이 거짓이 된다.
+        const m = { ...fresh.data };
+        m.mode = want; writeUtf8(mf, JSON.stringify(m, null, 2) + '\n');
+      });
       // 지침 파일은 등급의 산출물이므로 즉시 재생성한다 — 안 그러면 mode 는 이름만 바뀌고 읽히는 양은 그대로다.
       let regenerated = 0;
       try {
@@ -26172,7 +26391,9 @@ async function main() {
   if (cmd === 'pulse')                              return pulseCmd(_resolveRoot(args[1]));
   if (cmd === 'enforce')                           return enforceCmd(arg('--path', null) || _taskPositionalPath(args, 2) || process.cwd(), args[1]);   // 1.36.43: 사용 강제 (git pre-commit)
   if (cmd === 'anchors')                           return anchorsCmd(arg('--path', null) || _taskPositionalPath(args, 1) || process.cwd(), args[1] && !args[1].startsWith('-') ? args[1] : null);   // 1.36.36: 정체성앵커 초안
-  if (cmd === 'toggle')                            return _tgl.toggleCmd(arg('--path', process.cwd()), args[1], args[2], args[3], { has, VERSION });   // 1.36.30: 기능 토글 (그래프 ⚙ 탭 연동)
+  // 1.36.108 (T-0097): _withLock 을 넘긴다 — lib 모듈이 락을 deps 로 받는 기존 관례(clarify·referee·routing·bugfix)에
+  //   toggles 만 빠져 있어 `toggle set` 이 락 밖 read-modify-write 였다(런타임 계측으로 실측).
+  if (cmd === 'toggle')                            return _tgl.toggleCmd(arg('--path', process.cwd()), args[1], args[2], args[3], { has, VERSION, _withLock });   // 1.36.30: 기능 토글 (그래프 ⚙ 탭 연동)
   // 1.36.53 (UR-0062): 기술 프로필 · 1.36.67 (F15): 변경 시 기존 leerness.html 동반 갱신(있을 때만)
   if (cmd === 'tech')                              return _tech.techCmd(arg('--path', null) || _taskPositionalPath(args, 1) || process.cwd(), _optSub(args), { has, regenGraph: (r) => { if (exists(path.join(r, 'leerness.html'))) _graph.graphHtmlCmd(r, { _roadmapData, _loadDecisions, _loadLessons, _parseFeatureGraph, _loadToggles: _tgl.loadToggles, _toggleRegistry: _tgl.TOGGLE_REGISTRY, _loadTechProfile: _tech.loadTechProfile, quiet: true }); } });
   // 1.36.98 (P-0013): 재사용 인벤토리 — 새 화면 조각을 만들기 전에 '이미 있는 것' 을 먼저 본다(reuse-map 의 UI 판).

package/lib/analyzers.js

@@ -40,16 +40,22 @@ function _shellGuardAnalyze(cmd, ctx) {
 //   실측으로 확인된 사각지대: 다단계 경로의 확장자 없는 파일(ops/containers/Dockerfile),
 //   선두 점 디렉토리(.github/workflows/ci.yml → github/… 로 잘림), 점파일(.gitignore),
 //   그리고 Dockerfile.dev 가 Dockerfile 로 잘려 "없는 파일" 이 되던 것.
-const _VC_FILE_EXTS = 'webmanifest|properties|tscn|tres|godot|json5|prisma|swift|java|jsx|tsx|yaml|html|scss|sass|less|gltf|conf|json|toml|lock|mdx|xml|css|svg|yml|cfg|ini|env|php|sql|mjs|cjs|vue|svelte|md|js|ts|gd|cs|py|rb|go|rs|kt|sh|cpp|c|h';
+// 1.36.109 (codex 검수 P2): `pyi` 추가 — 타입 스텁(PEP 561)은 실제 산출물인데 추출조차 안 돼
+//   `pkg/__init__.pyi` 만 인용한 정직한 주장이 "파일 0건" 으로 거부됐다. 길이 내림차순 규칙상 `py` 앞에 둔다.
+const _VC_FILE_EXTS = 'webmanifest|properties|tscn|tres|godot|json5|prisma|swift|java|jsx|tsx|yaml|html|scss|sass|less|gltf|conf|json|toml|lock|mdx|xml|css|svg|yml|cfg|ini|env|php|sql|mjs|cjs|vue|svelte|pyi|md|js|ts|gd|cs|py|rb|go|rs|kt|sh|cpp|c|h';
 // 확장자 없는 표준 파일명 — 임의의 대문자 단어가 아니라 정확한 철자만(대소문자 구분)으로 FP 억제.
 const _VC_BARE_FILES = 'Dockerfile|Containerfile|Makefile|Gemfile|Procfile|Rakefile|Jenkinsfile|Vagrantfile|Caddyfile|Brewfile|Justfile|CODEOWNERS|LICENCE|LICENSE|NOTICE';
 // 점파일 — 확장자 규칙으로는 잡히지 않지만 명백한 파일 참조.
 const _VC_DOTFILES = '\\.(?:gitignore|gitattributes|gitmodules|dockerignore|npmrc|npmignore|nvmrc|editorconfig|prettierrc|eslintrc|babelrc|browserslistrc)';
 // 경로 접두: 0개 이상 세그먼트(각 세그먼트는 선두 점 허용) — `ops/containers/`, `.github/workflows/` 모두 포함.
-const _VC_PREFIX = '(?:\\.?[A-Za-z0-9][A-Za-z0-9._-]*[\\/\\\\])*';
+// 1.36.109 (완료게이트 사냥): 첫 글자에 `_` 가 없어서 `src/_helpers.js` 가 `helpers.js` 로 **잘려서** 추출됐다 —
+//   "파일 없음" 이 아니라 **없는 파일을 찾아** files-missing 으로 정직한 주장을 거부했다(실측).
+//   흔한 이름들이 여기 걸린다: Next.js `pages/_app.tsx` · `_document.tsx` · 파이썬 `__init__.py` · `_private/…`.
+//   false-BLOCK 은 false-PASS 보다 나쁘다 — 사용자는 이유 없이 막히고 게이트를 끄게 된다.
+const _VC_PREFIX = '(?:\\.?[A-Za-z0-9_][A-Za-z0-9._-]*[\\/\\\\])*';
 // basename: (a) 확장자 파일 (b) 표준 bare 파일명(뒤에 .확장자가 오면 (a)에 양보) (c) 점파일
 //   bare 파일은 관례적 접미사를 허용한다(Dockerfile.dev / Makefile.local) — 없으면 그 주장이 "파일 0건"이 된다.
-const _VC_BASE = `(?:[A-Za-z0-9][\\w.-]*\\.(?:${_VC_FILE_EXTS})\\b|(?:${_VC_BARE_FILES})(?:\\.[A-Za-z0-9_-]+)?(?![\\w.-])|${_VC_DOTFILES}(?![\\w-]))`;
+const _VC_BASE = `(?:[A-Za-z0-9_][\\w.-]*\\.(?:${_VC_FILE_EXTS})\\b|(?:${_VC_BARE_FILES})(?:\\.[A-Za-z0-9_-]+)?(?![\\w.-])|${_VC_DOTFILES}(?![\\w-]))`;
 function _EVIDENCE_FILE_RE(flags = '') { return new RegExp(`${_VC_PREFIX}${_VC_BASE}`, flags); }
 
 function _evidenceQuality(evidence) {

package/lib/audit.js

@@ -8,6 +8,9 @@ const { log, ok, warn, fail, failJson, today, now, absRoot, exists, read, readBu
 const { SECRET_PATTERNS } = require('./catalogs');
 const { findCorruptedStateJson } = require('./state-integrity');  // 1.36.1 (클린룸 리뷰 FN): 상태 JSON 무결성
 const { _briefUnfilled, _planGoalUnfilled } = require('./pure-utils');  // 1.36.19: 전략 앵커(project-brief/plan Goal) 미작성 감지
+// 1.36.108 (T-0097): 락은 harness 가 주입한다(clarify/referee/routing 과 같은 관례) — lib 에 복제본을 두지 않는다.
+//   주입이 없으면 그냥 실행한다(하위호환). 주입 누락은 e2e 락 가드가 실행으로 잡는다.
+function _auditLock(deps, f, fn) { return (deps && typeof deps._withLock === 'function') ? deps._withLock(f, fn) : fn(); }
 
 function audit(root, opts = {}, deps = {}) {
   const { VERSION, arg, has, planPath, readProgressRows, currentStatePath, handoffPath, envDiff, _readFeatureGraph, _matchAPISkills, _listAPISkills, _collectSecretFindings } = deps;
@@ -111,8 +114,13 @@ function audit(root, opts = {}, deps = {}) {
     _finding('handoff_not_generated', 'warn', 'session-handoff.md never auto-generated');
     // 1.9.35 #5: --fix → session-handoff.md 자동 생성 마커 갱신
     if (fix) {
-      const stamped = handoff.replace(/Last generated: \((자동|auto)\)/, `Last generated: ${today()} (leerness audit --fix)`);   // 1.36.61: 양 언어 --fix
-      writeUtf8(handoffPath(root), stamped);
+      // 1.36.108 (T-0097): 락 안에서 **다시 읽고** 스탬프한다. 위에서 읽은 handoff 로 쓰면
+      //   그 사이 session close 가 새로 생성한 내용을 낡은 스냅샷으로 덮는다(둘 다 이 파일을 쓴다).
+      _auditLock(deps, handoffPath(root), () => {
+        const fresh = exists(handoffPath(root)) ? read(handoffPath(root)) : handoff;
+        const stamped = fresh.replace(/Last generated: \((자동|auto)\)/, `Last generated: ${today()} (leerness audit --fix)`);   // 1.36.61: 양 언어 --fix
+        writeUtf8(handoffPath(root), stamped);
+      });
       ok('  ↳ fixed: session-handoff.md timestamp 갱신');
       fixed++;
     }
@@ -131,8 +139,11 @@ function audit(root, opts = {}, deps = {}) {
       _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()}`);
-        writeUtf8(currentStatePath(root), stamped);
+        // 1.36.108 (T-0097): 락 안 재읽기 — 사용자 본문이 그 사이 바뀌었으면 낡은 사본으로 덮지 않는다.
+        _auditLock(deps, currentStatePath(root), () => {
+          const fresh = exists(currentStatePath(root)) ? read(currentStatePath(root)) : cur;
+          writeUtf8(currentStatePath(root), fresh.replace(/Updated: \d{4}-\d{2}-\d{2}/, `Updated: ${today()}`));
+        });
         ok('  ↳ fixed: current-state.md Updated 갱신');
         fixed++;
       }

package/lib/session-close.js

@@ -125,25 +125,37 @@ function sessionClose(root, opts = {}, deps = {}) {
     `- ${(buckets['in-progress'][0]?.nextAction) || (buckets['planned'][0]?.nextAction) || (buckets['requested'][0]?.nextAction) || '없음'}`,
     ``
   ].join('\n');
-  const cur = exists(handoffPath(root)) ? read(handoffPath(root)) : '';
-  // 1.9.316 (drift 마커 버그): 프론트매터는 파일이 '---' 로 시작할 때만 추출.
-  //   이전: 본문의 '---'(수평선/구분자)을 프론트매터 종료로 오인 → 구 블록(구 'Last generated')을 보존 →
-  //   session-handoff.md 에 'Last generated' 중복 누적 → drift 가 첫(=구) 매치를 읽어 'session close 누락' 영구 오발화.
-  let frontmatter = '';
-  if (/^---\r?\n/.test(cur)) {
-    const fmEnd = cur.indexOf('\n---\n', 4);
-    if (fmEnd > 0) frontmatter = cur.slice(0, fmEnd + 5) + MARK + '\n';
-  }
-  writeUtf8(handoffPath(root), frontmatter + block);
-
-  if (exists(currentStatePath(root))) {
-    let cs = read(currentStatePath(root));
+  // 1.36.108 (T-0097): 두 문서 모두 **읽어서 사용자 내용을 보존한 뒤 다시 쓰는** read-modify-write 다
+  //   (handoff 는 프론트매터를, current-state 는 사용자가 쓴 본문을 지킨다). 락 밖이면 그 보존이
+  //   낡은 스냅샷 기준이라 옆 프로세스(audit --fix / handoff)의 갱신을 덮는다.
+  //   **쓰기 구간만** 감싼다 — 명령 전체를 감싸면 session close 의 하위 감사가 길어져 stale(30s) 에 락을 뺏긴다
+  //   (lib/referee.js 가 같은 이유로 verify 를 락 밖에 둔다).
+  //   1.36.108 (codex 검수 P2, 재현됨): 처음엔 두 파일을 **하나의 락(session-handoff.md.lock)** 으로 감쌌다.
+  //   그건 보호가 아니다 — `audit --fix` 는 current-state.md 의 락을 잡으므로 둘이 서로를 배제하지 못하고,
+  //   검수가 audit 의 갱신이 session close 의 낡은 스냅샷에 덮이는 것을 재현했다(양쪽 다 '락 보유' 로 보인 채로).
+  //   락은 **지키는 파일의 이름으로** 잡아야 한다. 파일마다 따로, 중첩 없이(중첩이 없으니 교착도 없다).
+  const _lk = (typeof deps._withLock === 'function') ? deps._withLock : ((f, fn) => fn());
+  _lk(handoffPath(root), () => {
+    const cur = exists(handoffPath(root)) ? read(handoffPath(root)) : '';
+    // 1.9.316 (drift 마커 버그): 프론트매터는 파일이 '---' 로 시작할 때만 추출.
+    //   이전: 본문의 '---'(수평선/구분자)을 프론트매터 종료로 오인 → 구 블록(구 'Last generated')을 보존 →
+    //   session-handoff.md 에 'Last generated' 중복 누적 → drift 가 첫(=구) 매치를 읽어 'session close 누락' 영구 오발화.
+    let frontmatter = '';
+    if (/^---\r?\n/.test(cur)) {
+      const fmEnd = cur.indexOf('\n---\n', 4);
+      if (fmEnd > 0) frontmatter = cur.slice(0, fmEnd + 5) + MARK + '\n';
+    }
+    writeUtf8(handoffPath(root), frontmatter + block);
+  });
+  _lk(currentStatePath(root), () => {
+    if (!exists(currentStatePath(root))) return;
+    let cs = read(currentStatePath(root));   // 락 안에서 읽는다 — 밖에서 읽은 사본으로 쓰면 그 사이 갱신을 지운다
     cs = cs.replace(/Updated: \d{4}-\d{2}-\d{2}/, `Updated: ${today()}`);
     cs = _upsertAutoLines(cs, 'Now', [`- ${(buckets['in-progress'][0]?.request) || '대기 중'}`]);
     cs = _upsertAutoLines(cs, 'Next', [`- ${(buckets['planned'][0]?.request) || (buckets['requested'][0]?.request) || '계획된 작업 없음'}`]);
     cs = _upsertAutoLines(cs, 'Blockers', (buckets['blocked'] || []).length ? buckets['blocked'].map(b => `- ${b.id} ${b.request}`) : ['- (없음)']);
     writeUtf8(currentStatePath(root), cs);
-  }
+  });
 
   append(taskLogPath(root), `\n## ${today()} session-close\n- Generated session-handoff.md and refreshed current-state.md.\n`);
 

package/lib/toggles.js

@@ -95,6 +95,12 @@ function saveToggles(root, toggles) {
 function toggleCmd(root, sub, id, val, deps = {}) {
   const { has, VERSION } = deps;
   root = absRoot(root);
+  // 1.36.108 (T-0097): 변경 하위명령은 읽기~쓰기 전체를 락으로 직렬화한다 — clarify/referee/routing 과 같은 관례.
+  //   종전엔 이 모듈만 관례에서 빠져 있어 동시 `toggle set` 이 서로의 값을 덮었다(런타임 계측으로 실측: 락 X).
+  //   재진입 플래그(_locked)로 자기 재호출을 한 번만 감싼다.
+  if (sub === 'set' && typeof deps._withLock === 'function' && !deps._locked) {
+    return deps._withLock(_togglesPath(root), () => toggleCmd(root, sub, id, val, Object.assign({}, deps, { _locked: true })));
+  }
   const json = has && has('--json');
   const _chk = loadTogglesChecked(root);
   const cur = _chk.toggles;

package/package.json

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

package/scripts/e2e.js

@@ -10219,6 +10219,244 @@ total++;
   if (!ok) failed++;
 }
 
+// ── 1.36.108 블록 L (T-0097): 사용자 상태 쓰기는 **락 안에서** 일어난다.
+//   이 저장소는 스토어별로 락을 하나씩 달아 왔고, 그래서 같은 스토어 안에서도 진입점마다 갈렸다 —
+//   rules.md 는 `rule add` 만 보호되고 remove/pause/resume/stop/resume-all 다섯이 락 밖이었다(런타임 계측 실측).
+//   개별 수정은 다음 기능이 들어오면 또 샌다. 그래서 **불변식 자체를 실행으로 단언**한다.
+//
+//   왜 소스 검사가 아닌가: `_withLock(` 괄호 균형으로 판정하려 했더니 주석/정규식 리터럴에서 범위가 폭주해
+//   selftest 픽스처 수천 줄이 '보호됨' 으로 나왔다. 락은 파일별이 아니라 **구간별**이기도 하다
+//   (decisions.json 의 락을 쥔 채 decisions.md 를 쓴다). scripts/lock-probe.js 가 _withLock 을 미러링해 실행으로 관측한다.
+//
+//   유실은 가설이 아니라 재현이다: 읽기 직후를 4초 늘린 프로세스 A 와 그 창의 프로세스 B 를 붙이면
+//   락 있는 스토어는 B 가 2.4초 대기 후 둘 다 생존하고, 락 없던 user-requests.json 은 B 의 요청이 통째로 사라졌다.
+{
+  total++;
+  let ok = false; const dbg = {};
+  const sb = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-lock108-'));
+  try {
+    const ENV0 = Object.assign({}, process.env, { TMPDIR: sb, TEMP: sb, TMP: sb });
+    const PRELOAD = path.join(path.dirname(CLI), '..', 'scripts', 'lock-probe.js').replace(/\\/g, '/');
+    // 병합 대상이 없어 lost-update 가 성립하지 않는 쓰기 — **사유가 있어야 목록에 남는다**.
+    //   조용한 상한을 두지 않기 위해 여기 적힌 것 외에는 전부 실패로 본다.
+    const EXEMPT = {
+      'task-log.md': 'append 전용(appendFileSync = O_APPEND) — 동시 추가가 서로를 지우지 않는다',
+      'agent-permissions.json': '상수 프리셋 전체 쓰기 — 읽기가 없어 병합할 이전 값이 없다',
+    };
+    const DERIVED = /^(cache\/|last-handoff\.json|environment\.json|tech-profile\.json|update-cache\.json|provider-probe-cache\.json|leerness\.html)/;
+    // 스토어를 각각 건드리는 변경 명령들. seed 로 기존 항목을 만들어 **읽기가 실제로 일어나게** 한다.
+    const CASES = [
+      ['task add', ['task', 'add', '락프로브']],
+      ['decision add', ['decision', 'add', '락프로브', '--why', 'x']],
+      ['lesson save', ['lesson', 'save', '락프로브']],
+      ['rule add', ['rule', 'add', '락프로브', '--trigger', 'every-session']],
+      ['rule pause', ['rule', 'pause', 'R-0001'], ['rule', 'add', '씨앗룰', '--trigger', 'every-session']],
+      ['plan add', ['plan', 'add', '락프로브']],
+      ['preview add', ['preview', 'add', '락프로브', '--design', 'd', '--features', 'f']],
+      ['requests add', ['requests', 'add', '락프로브']],
+      ['next-action add', ['next-action', 'add', '락프로브']],
+      ['toggle set', ['toggle', 'set', 'bugfix-receipt', 'off']],
+      ['mode set', ['mode', 'set', 'minimal']],
+      ['feature add', ['feature', 'add', '락프로브기능']],
+      ['constraints add', ['constraints', 'add', 'probeapi', '--alias', 'probe', '--constraint', 'auth:token']],
+      ['provider add', ['provider', 'add', 'probeprov']],
+      ['wakeup-interval set', ['wakeup-interval', 'set', '900']],
+      ['slash-commands --record', ['slash-commands', '--record']],
+      ['session close', ['session', 'close', '.']],
+      // audit --fix 는 session close 와 **같은 두 문서**를 쓴다 — 둘을 함께 돌려야 락 키 불일치가 드러난다
+      //   (검수가 재현한 결함이 정확히 이 조합이었다: 한쪽은 handoff 락, 다른 쪽은 current-state 락).
+      //   ⚠ 신규 프로젝트에서는 current-state 가 신선해 audit --fix 가 그 파일을 **아예 쓰지 않는다** —
+      //   조건을 만들지 않으면 이 케이스는 조용히 아무것도 관측하지 못한다(변이 시험이 그걸 잡아냈다).
+      ['audit --fix', ['audit', '.', '--fix'], (d) => {
+        const cs = path.join(d, '.harness', 'current-state.md');
+        if (fs.existsSync(cs)) fs.writeFileSync(cs, fs.readFileSync(cs, 'utf8').replace(/Updated: \d{4}-\d{2}-\d{2}/, 'Updated: 2000-01-01'));
+        const sh = path.join(d, '.harness', 'session-handoff.md');
+        if (fs.existsSync(sh) && !/Last generated:/.test(fs.readFileSync(sh, 'utf8'))) fs.appendFileSync(sh, '\nLast generated: (자동)\n');
+      }],
+    ];
+    // codex 검수가 지적한 커버리지 구멍: `provider sync` 는 네트워크가 필요해 목록에 없었고,
+    //   바로 그 명령이 async 를 돌려줘 락이 조기 해제되고 있었다 — 가드가 통과하는 채로.
+    //   외부망은 쓰지 않는다(게이트가 불안정해진다). 로컬 루프백 서버를 **별도 프로세스**로 띄운다:
+    //   같은 프로세스에서 서빙하면 spawnSync 가 이벤트 루프를 막아 자식 요청이 영영 응답을 못 받는다.
+    const srvJs = path.join(sb, 'srv.js');
+    fs.writeFileSync(srvJs, [
+      "const http=require('http'),fs=require('fs');",
+      "const s=http.createServer((q,r)=>{r.writeHead(200,{'Content-Type':'text/plain'});r.end('probealpha|probealpha-cli|probe provider');});",
+      "s.listen(0,'127.0.0.1',()=>fs.writeFileSync(process.argv[2], String(s.address().port)));"
+    ].join('\n'));
+    const portFile = path.join(sb, 'port.txt');
+    const srv = cp.spawn(process.execPath, [srvJs, portFile], { stdio: 'ignore' });
+    let syncUrl = null;
+    for (let i = 0; i < 100 && !syncUrl; i++) {
+      try { const p = fs.readFileSync(portFile, 'utf8').trim(); if (p) syncUrl = `http://127.0.0.1:${p}/providers.txt`; } catch {}
+      if (!syncUrl) { try { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50); } catch {} }
+    }
+    // 서버가 떴을 때만 추가한다 — 못 띄웠으면 '통과' 가 아니라 커버리지 부족으로 아래에서 실패시킨다.
+    if (syncUrl) CASES.push(['provider sync', ['provider', 'sync', syncUrl]]);
+    dbg.syncCovered = !!syncUrl;
+    const offenders = [], failedCmds = [];
+    const keysByFile = {};   // 파일 → 그 파일을 쓸 때 쥐고 있던 락 키 집합(명령을 가로질러 모은다)
+    let lockedSeen = 0, rows = 0;
+    for (const [label, argv, seed] of CASES) {
+      const d = path.join(sb, label.replace(/[^a-z0-9]+/gi, '_'));
+      fs.mkdirSync(d, { recursive: true });
+      fs.writeFileSync(path.join(d, 'package.json'), '{"name":"p","version":"0.1.0"}');
+      cp.spawnSync(process.execPath, [CLI, 'init', d, '--yes'], { cwd: d, encoding: 'utf8', timeout: 300000, env: ENV0 });
+      if (typeof seed === 'function') seed(d);
+      else if (seed) cp.spawnSync(process.execPath, [CLI, ...seed, '--path', d], { cwd: d, encoding: 'utf8', timeout: 300000, env: ENV0 });
+      const out = path.join(d, 'lock.jsonl');
+      // e2e 는 맨 위에서 LEERNESS_OFFLINE=1 을 켠다(외부망 차단). provider sync 는 **루프백**이라
+      //   그 정책의 대상이 아니다 — 이 케이스만 명시적으로 해제한다(다른 케이스는 그대로 차단 유지).
+      const caseEnv = Object.assign({}, ENV0, { LOCKPROBE_OUT: out });
+      if (label === 'provider sync') caseEnv.LEERNESS_OFFLINE = '0';
+      const r = cp.spawnSync(process.execPath, ['--require', PRELOAD, CLI, ...argv, '--path', d],
+        { cwd: d, encoding: 'utf8', timeout: 600000, env: caseEnv });
+      // 실패한 명령은 아무것도 안 써서 자동으로 '안전' 처럼 보인다 — 안전이 아니라 판정 불가다.
+      if (r.status !== 0) { failedCmds.push(label + '(exit=' + r.status + ')'); continue; }
+      let lines = [];
+      try { lines = fs.readFileSync(out, 'utf8').split('\n').filter(Boolean).map(JSON.parse); } catch {}
+      const byFile = {};
+      for (const l of lines) {
+        byFile[l.file] = (l.file in byFile ? byFile[l.file] : true) && l.locked;
+        // 어느 락 키로 지켰는지 모은다 — 파일 자신의 락이 아니면 다른 명령과 서로 배제되지 않는다.
+        if (l.locked && !DERIVED.test(l.file) && !EXEMPT[l.file]) {
+          (keysByFile[l.file] = keysByFile[l.file] || new Set());
+          for (const k of (l.heldOn || [])) keysByFile[l.file].add(k);
+        }
+      }
+      for (const [f, lockedOk] of Object.entries(byFile)) {
+        if (DERIVED.test(f)) continue;
+        rows++;
+        if (lockedOk) { lockedSeen++; continue; }
+        if (EXEMPT[f]) continue;
+        offenders.push(label + ' → ' + f);
+      }
+    }
+    // codex 검수 P2(재현됨): "락을 하나라도 쥐었나" 는 너무 약하다. 상호배제는 **같은 키**를 쥘 때만 성립한다.
+    //   session close 는 session-handoff.md.lock 을 쥔 채 current-state.md 를 썼고 audit --fix 는
+    //   current-state.md.lock 을 쥐었다 — 둘 다 '락 보유' 인 채로 audit 의 갱신이 덮였다.
+    //   올바른 불변식은 "자기 이름의 락" 이 아니라 **"그 파일의 모든 쓰기가 같은 키를 쓴다"** 이다.
+    //   (decisions.md 를 decisions.json.lock 아래에서 쓰는 것은 정상 — 그 파일을 쓰는 유일한 경로가 거기뿐이면.)
+    const wrongKey = [];
+    for (const [f, keys] of Object.entries(keysByFile)) {
+      if (keys.size !== 1) wrongKey.push(f + ' ← 서로 다른 락 ' + [...keys].sort().join(' / '));
+    }
+    dbg.wrongKey = wrongKey;
+    dbg.offenders = offenders;
+    dbg.failedCmds = failedCmds;
+    dbg.lockedSeen = lockedSeen;
+    dbg.rows = rows;
+    // 판별력: 락을 쥔 쓰기가 하나도 안 잡히면 계측이 죽은 것 — 그 상태의 "위반 0" 은 아무 의미가 없다.
+    dbg.probeAlive = lockedSeen >= 10;
+    // 명령이 대량으로 실패하면 커버리지가 무너진 것 — 그것도 통과로 보지 않는다.
+    dbg.coverage = failedCmds.length === 0;
+    ok = dbg.probeAlive && dbg.coverage && dbg.syncCovered && offenders.length === 0 && wrongKey.length === 0;
+    try { srv.kill(); } catch {}
+  } catch (e) { dbg.err = String(e && e.message).slice(0, 200); } finally { try { fs.rmSync(sb, { recursive: true, force: true }); } catch {} }
+  console.log(ok ? `✓ L(1.36.108/T-0097) 사용자 상태 쓰기 ${dbg.rows}건 전부 락 안 + 파일당 락 키 일관 (락 관측 ${dbg.lockedSeen}건 = 계측 살아있음 · 명령 실패 0)`
+    : '✗ 1.36.108 락 불변식 위반 ' + JSON.stringify(dbg));
+  if (!ok) failed++;
+}
+
+// ── 1.36.109 블록 M: 완료 게이트 — "done 에는 증거가 필요하다" 는 제품의 이름값이다.
+//   적대 사냥에서 두 방향으로 뚫려 있었다(대조군 2/2 통과 상태에서 측정 — 전부 거부하는 고장난 게이트가 아니었다):
+//     · false-PASS: `touch src/x.js` 후 "src/x.js 구현 완료" 로 done 이 통과했다.
+//       공백 3자짜리 파일은 stub-impl 로 막히는데 **0바이트는 통과** — 더 비어 있을수록 쉽게 통과하는 역전이었다.
+//       원인은 `!body` 를 스킵 조건에 둔 것이고, 같은 falsy 함정이 호출부와 `_vcImplIsEmpty` **두 곳**에 있어
+//       한 곳만 고치면 구멍이 남았다(가드가 서로를 가리는 형태).
+//     · false-BLOCK: `src/_helpers.js` 를 인용하면 추출기가 `helpers.js` 로 **잘라서** 없는 파일을 찾았다.
+//       Next.js `pages/_app.tsx`, 파이썬 `__init__.py` 처럼 흔한 이름이 전부 여기 걸렸다. 이유 없이 막히면
+//       사용자는 게이트를 끈다 — false-BLOCK 이 false-PASS 보다 나쁘다.
+//   두 방향을 한 블록에서 함께 단언한다. 한쪽만 보면 "전부 거부" 나 "전부 통과" 로 도망갈 수 있다.
+{
+  total++;
+  let ok = false; const dbg = {};
+  const sb = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-claim109-'));
+  try {
+    const ENV = Object.assign({}, process.env, { TMPDIR: sb, TEMP: sb, TMP: sb });
+    let seq = 0;
+    const mk = (setup) => {
+      const d = path.join(sb, 'p' + (++seq));
+      fs.mkdirSync(d, { recursive: true });
+      fs.writeFileSync(path.join(d, 'package.json'), '{"name":"p","version":"0.1.0"}');
+      cp.spawnSync(process.execPath, [CLI, 'init', d, '--yes'], { cwd: d, encoding: 'utf8', timeout: 300000, env: ENV });
+      setup(d); return d;
+    };
+    const R = (d, a) => cp.spawnSync(process.execPath, [CLI, ...a, '--path', d], { cwd: d, encoding: 'utf8', timeout: 300000, env: ENV });
+    const verdict = (d, evidence) => {
+      const id = (String(R(d, ['task', 'add', '주장']).stdout || '').match(/T-\d{4,}/) || [])[0];
+      R(d, ['task', 'update', id, '--status', 'done', '--evidence', evidence]);
+      const r = R(d, ['verify-claim', id, '--json']);
+      let j = null; try { j = JSON.parse(String(r.stdout || '')); } catch {}
+      return { ok: j ? j.ok : null, reasons: j ? (j.reasons || []) : [] };
+    };
+    const W = (d, rel, body) => { const p = path.join(d, rel); fs.mkdirSync(path.dirname(p), { recursive: true }); fs.writeFileSync(p, body); };
+
+    // ① 0바이트 = 스텁 (그리고 공백만도 여전히 스텁 — 둘이 같은 판정이어야 한다)
+    const dEmpty = mk(d => W(d, 'src/empty.js', ''));
+    const vEmpty = verdict(dEmpty, 'src/empty.js 구현 완료');
+    const dBlank = mk(d => W(d, 'src/blank.js', '   \n\n '));
+    const vBlank = verdict(dBlank, 'src/blank.js 구현 완료');
+    dbg.emptyBlocked = vEmpty.ok === false && vEmpty.reasons.includes('stub-impl');
+    dbg.blankBlocked = vBlank.ok === false && vBlank.reasons.includes('stub-impl');
+
+    // ② 대조군 — 실제 구현은 계속 통과해야 한다(게이트가 전부 거부하면 이 블록은 무의미하다)
+    const dReal = mk(d => W(d, 'src/real.js', 'function f(){return 1;}\nmodule.exports={f};\n'));
+    dbg.realPasses = verdict(dReal, 'src/real.js 구현 완료').ok === true;
+
+    // ③ 밑줄 시작 파일명이 잘리지 않는다 — 실존하는데 files-missing 이 나면 정직한 주장의 오차단
+    const dUs = mk(d => W(d, 'src/_helpers.js', 'function h(){return 1;}\nmodule.exports={h};\n'));
+    const vUs = verdict(dUs, 'src/_helpers.js 구현 완료');
+    dbg.underscoreOk = vUs.ok === true && !vUs.reasons.includes('files-missing');
+    const dNext = mk(d => W(d, 'pages/_app.tsx', 'export default function App(){ return null; }\n'));
+    const vNext = verdict(dNext, 'pages/_app.tsx 수정 완료');
+    dbg.nextjsOk = vNext.ok === true && !vNext.reasons.includes('files-missing');
+    // 디렉토리 이름이 `_` 로 시작하는 경우도 같은 결함이다 — 경로 접두와 basename 은 별개 문자 클래스라
+    //   한쪽만 고치면 나머지가 남는다(변이 시험에서 basename 만 되돌렸을 때 이 케이스는 통과했다).
+    const dPriv = mk(d => W(d, '_private/util.ts', 'export function u(){ return 1; }\n'));
+    const vPriv = verdict(dPriv, '_private/util.ts 정리 완료');
+    dbg.privDirOk = vPriv.ok === true && !vPriv.reasons.includes('files-missing');
+
+    // ④ 관례상 빈 파일(__init__.py)은 스텁으로 막지 않는다 — 단, **다른 실질 파일과 함께일 때만**.
+    const dPy = mk(d => { W(d, 'pkg/__init__.py', ''); W(d, 'pkg/core.py', 'def f():\n    return 1\n'); });
+    const vPy = verdict(dPy, 'pkg/__init__.py, pkg/core.py 구현 완료');
+    dbg.initPyExempt = vPy.ok === true;
+    // ④-b codex 검수 P1(재현됨): 마커 **단독**은 구현 증거가 아니다. 처음 판에서는 무조건 예외라
+    //   빈 `__init__.py` 하나만 인용한 done 이 통과했고, 이 블록은 ④가 core.py 를 함께 인용한 탓에 못 잡았다.
+    //   가드가 놓친 이유가 "조건을 안 만들어서" 였다 — 조건을 만든다.
+    const dPyOnly = mk(d => W(d, 'pkg/__init__.py', ''));
+    const vPyOnly = verdict(dPyOnly, 'pkg/__init__.py 구현 완료');
+    dbg.markerOnlyBlocked = vPyOnly.ok === false && vPyOnly.reasons.includes('stub-impl');
+    // ④-c 타입 스텁(PEP 561)도 같은 규칙 — 인식되어야 예외가 도달한다(안 그러면 광고만 하는 코드).
+    const dPyi = mk(d => { W(d, 'pkg/__init__.pyi', ''); W(d, 'pkg/core.pyi', 'def f() -> int: ...\n'); });
+    const vPyi = verdict(dPyi, 'pkg/__init__.pyi, pkg/core.pyi 타입 스텁 추가');
+    dbg.pyiRecognized = vPyi.ok === true;
+    // ⑤-b URL 조각 / 드라이브 상대 경로는 루트 상대 파일 주장이 아니다 — 실존 파일이 있어도 세탁되면 안 된다.
+    const dFrag = mk(d => W(d, '_anchor.js', 'function a(){return 1;}\nmodule.exports={a};\n'));
+    const vFrag = verdict(dFrag, 'https://example.test/docs#_anchor.js 검토 완료');
+    dbg.urlFragBlocked = vFrag.ok === false;
+    const dDrive = mk(d => W(d, '_anchor.js', 'function a(){return 1;}\nmodule.exports={a};\n'));
+    const vDrive = verdict(dDrive, 'C:_anchor.js 검토 완료');
+    dbg.driveRelBlocked = vDrive.ok === false;
+    // 대조군 — 정상 표기 `파일:src/x.js` 는 계속 인식돼야 한다(`:` 를 통째로 막지 않았는지)
+    const dColon = mk(d => W(d, 'src/colon.js', 'function c(){return 1;}\nmodule.exports={c};\n'));
+    const vColon = verdict(dColon, '파일:src/colon.js 구현 완료');
+    dbg.colonFormOk = vColon.ok === true;
+
+    // ⑤ 없는 파일은 여전히 막힌다(추출기를 넓혔다고 존재 검사가 느슨해지지 않았는지)
+    const dGhost = mk(() => {});
+    const vGhost = verdict(dGhost, 'src/_ghost.js 구현 완료');
+    dbg.ghostStillBlocked = vGhost.ok === false && vGhost.reasons.includes('files-missing');
+
+    ok = dbg.emptyBlocked && dbg.blankBlocked && dbg.realPasses && dbg.underscoreOk
+      && dbg.nextjsOk && dbg.privDirOk && dbg.initPyExempt && dbg.ghostStillBlocked
+      && dbg.markerOnlyBlocked && dbg.pyiRecognized && dbg.urlFragBlocked && dbg.driveRelBlocked && dbg.colonFormOk;
+  } catch (e) { dbg.err = String(e && e.message).slice(0, 200); } finally { try { fs.rmSync(sb, { recursive: true, force: true }); } catch {} }
+  console.log(ok ? '✓ M(1.36.109) 완료 게이트: 0바이트=스텁(공백과 동일 판정) + 밑줄 파일명 무손실 추출 + __init__.py 예외 + 실구현/없는파일 대조군'
+    : '✗ 1.36.109 완료 게이트 실패 ' + JSON.stringify(dbg));
+  if (!ok) failed++;
+}
+
 console.log(`\nE2E result: ${total - failed}/${total} passed · ${((Date.now() - _e2eStart) / 1000).toFixed(0)}s`);
 if (failed > 0) process.exit(1);
 

package/scripts/lock-probe.js

@@ -0,0 +1,53 @@
+// scripts/lock-probe.js — 상태 스토어 쓰기가 **락 안에서** 일어나는지 실행으로 관측하는 계측 모듈.
+//
+// 왜 소스 검사가 아니라 계측인가: 정적으로 "이 writeUtf8 이 _withLock 안인가" 를 판정하려 했더니
+// 괄호 균형 스캐너가 주석/정규식 리터럴에서 폭주해 selftest 픽스처 수천 줄을 "락 안" 으로 분류했다.
+// 락은 **파일별이 아니라 구간별**이기도 하다 — leerness 는 decisions.json 의 락을 쥔 채 decisions.md 를 쓴다.
+// 그래서 _withLock 이 하는 것과 똑같이(O_EXCL 로 <target>.lock 생성 → 끝나면 unlink) 보유 집합을 미러링하고,
+// 쓰기 시점에 "이 프로세스가 락을 하나라도 쥐고 있었나" 를 기록한다.
+//
+// 사용: node --require scripts/lock-probe.js bin/leerness.js <명령> ...   (LOCKPROBE_OUT 에 jsonl 기록)
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+const OUT = process.env.LOCKPROBE_OUT;
+const rec = [];
+const held = new Set();
+const norm = p => { try { return path.resolve(String(p)); } catch { return String(p); } };
+// archive/ 는 백업 사본이라 경쟁 대상이 아니다. .lock 자체와 원자쓰기 임시파일도 제외(최종 경로는 rename 이 알려준다).
+const isState = p => /[\\/]\.harness[\\/]/.test(p) && !/[\\/]archive[\\/]/.test(p) && !/\.lock$/.test(p) && !/\.tmp-\d+-\d+$/.test(p);
+const relOf = p => (p.split(/[\\/]\.harness[\\/]/)[1] || p).replace(/\\/g, '/');
+
+const _open = fs.openSync.bind(fs);
+fs.openSync = function (p, flags, ...a) {
+  const r = _open(p, flags, ...a);
+  try { if (String(flags) === 'wx' && /\.lock$/.test(String(p))) held.add(norm(p)); } catch {}
+  return r;
+};
+const _unlink = fs.unlinkSync.bind(fs);
+fs.unlinkSync = function (p, ...a) {
+  try { if (/\.lock$/.test(String(p))) held.delete(norm(p)); } catch {}
+  return _unlink(p, ...a);
+};
+
+// 1.36.108 (codex 검수 P2, 재현됨): "락을 하나라도 쥐었나" 는 **너무 약한 질문**이다.
+//   session close 는 session-handoff.md 의 락을 쥔 채 current-state.md 를 썼고, audit --fix 는
+//   current-state.md 의 락을 쥔다 — 둘 다 '락 보유' 인데 서로를 배제하지 못해 갱신이 덮였다.
+//   그래서 **어느 락을 쥐었는지**(heldOn)를 함께 남긴다. 가드는 파일마다 락 키가 일관되는지까지 본다.
+const note = (target, how) => {
+  const t = norm(target);
+  if (!isState(t)) return;
+  rec.push({ file: relOf(t), how, locked: held.size > 0, heldOn: [...held].map(relOf).sort() });
+};
+const _w = fs.writeFileSync.bind(fs);
+fs.writeFileSync = function (p, ...a) { try { note(p, 'write'); } catch {} return _w(p, ...a); };
+const _r = fs.renameSync.bind(fs);
+fs.renameSync = function (from, to) { try { note(to, 'rename'); } catch {} return _r(from, to); };
+const _a = fs.appendFileSync.bind(fs);
+fs.appendFileSync = function (p, ...args) { try { note(p, 'append'); } catch {} return _a(p, ...args); };
+
+process.on('exit', () => {
+  if (!OUT) return;
+  try { fs.appendFileSync(OUT, rec.map(r => JSON.stringify(r)).join('\n') + (rec.length ? '\n' : ''), 'utf8'); } catch {}
+});