leerness 1.9.302 → 1.9.304

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## 1.9.304 — 2026-06-04 — UR-0025 (6단계): 순수 분석/검증 함수 → lib/analyzers.js 모듈 분리
+
+**🧩 모놀리스 분리 계속 — 순수 분석/검증 함수 4종을 비파괴 분리. lib 6모듈 체제(630줄 외부화).**
+
+### 배경
+외부 리뷰 핵심(UR-0038~0043) 완료 후, 두 리뷰 공통 지적인 단일 대형 파일을 계속 점진 분리. 데이터 카탈로그(1~5단계) 다음으로 **순수 함수**(부작용 0, 입력→출력) 클러스터를 분리.
+
+### 구현 (UR-0025 6단계)
+1. **`lib/analyzers.js` 신설** — 순수 분석/검증 함수 4종(62줄):
+   - `_evidenceQuality`(evidence 완전성: 파일/테스트/로그 근거)
+   - `_parseEvidenceStats`(review-evidence pass/fail 집계)
+   - `_shellGuardAnalyze`(셸 호환성 6규칙 정적 분석)
+   - `_claimFileInGit`(verify-claim git 교차검증 매칭)
+2. **비파괴 require-based 분리** — verify-claim/shell-guard/review-evidence 소비처는 동일 바인딩. 모두 순수(내부 의존 0) 검증.
+3. **harness.js 21686→21630줄**. lib 6모듈: pure-utils+agent-registry+role-catalog+catalogs+mcp-tools+analyzers = 630줄 외부화.
+4. selftest 51→52 (4함수 동일참조 단일출처 + 인라인 제거) · e2e 248→249 (모듈 standalone + shell-guard 동작 회귀).
+
+### 검증
+- **selftest 52/52 PASS** · **E2E 249/249 PASS** (회귀 0).
+- 기존 selftest(_evidenceQuality/_parseEvidenceStats/_shellGuardAnalyze ×2/_claimFileInGit)가 추출 정합성 즉시 검증.
+- `shell-guard "a && b" --json` 정상 동작(모듈 분리 후 회귀 없음).
+
+## 1.9.303 — 2026-06-04 — UR-0043: 상태 파일 lost-update 락 (외부 AI 리뷰 — 멀티에이전트 안전 완성)
+
+**🔐 원자적 쓰기(UR-0038)가 막지 못한 동시 read-modify-write lost-update를 advisory 락으로 차단. Codex/Opus가 지적한 "상태 쓰기에 락 0건" 해소 — 멀티에이전트 동시 쓰기 안전성 완성.**
+
+### 배경 (Codex / Opus A-3)
+원자적 쓰기는 부분쓰기 손상은 막으나, 두 에이전트가 동시에 `task add`(또는 `state record`)를 호출하면: A 읽기 → B 읽기 → A 쓰기 → B 쓰기(A 변경 누락) = **lost-update**. 특히 `nextId`(다음 ID 계산)가 쓰기와 분리돼 **동일 ID 충돌**(둘 다 같은 T-XXXX → 덮어쓰기)까지 발생. grep 결과 `flock`/`O_EXCL` 0건(Opus).
+
+### 구현 (UR-0043)
+1. **`_withLock(targetPath, fn)`** — `O_EXCL`(wx) 원자적 lock 파일로 상호배제. 점증 backoff 재시도, stale(crash) 30s 초과 시 탈취, 타임아웃 5s 시 락 없이 진행(원자쓰기로 손상은 이미 방지). **프로세스 내 재진입**(`_heldLocks`)으로 중첩 호출 데드락 방지.
+2. **`_updateRun(root, id, mutator)`** — run 레코드 RMW를 락으로 캡슐화.
+3. **적용** — `upsertProgress`(task/plan write), `taskAdd`/`planAdd`(nextId+upsert를 **하나의 락**으로 → ID 충돌 차단), `state record/verify/handoff`(_updateRun). `_sleepSyncMs`(Atomics.wait) 헬퍼.
+4. selftest 50→51 · e2e 247→248.
+
+### 검증
+- **selftest 51/51 PASS** · **E2E 248/248 PASS** (회귀 0).
+- **실측: 6개 `task add` 병렬 실행 → 6개 모두 보존 + ID 충돌 0 + 구분자 1줄**. (락 전: 3/6 보존, ID 충돌 발생 — 동일 ID 덮어쓰기 확인 후 수정.)
+
+### 🎉 외부 AI 리뷰 신뢰성/보안 핵심 권고 완수
+- UR-0038 원자쓰기 · UR-0039 시크릿차단 · UR-0040 셸주입 · UR-0041 정책 메타데이터 · UR-0042 verify 시맨틱 · **UR-0043 lost-update 락** — 세 모델(Codex/Sonnet/Opus) 공통 high + 전략 항목 전부 코드화. 남은 UR-0044(handler 통합)는 low.
+
 ## 1.9.302 — 2026-06-04 — UR-0042: verify-claim git diff 시맨틱 교차검증 (외부 AI 리뷰 R3, Opus G-1)
 
 **🔍 Opus가 "가장 전략적 약점"으로 꼽은 거짓완료 검증의 실질화 — "파일 존재 + N passed" 문자열매칭에 git diff 교차검증 추가: 주장한 파일이 실제로 변경됐는가를 git working tree + 직전 커밋으로 대조.**

package/README.md

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

package/bin/harness.js

@@ -9,10 +9,12 @@ const readline = require('readline');
 // 1.9.274 (UR-0025 1단계): 순수 유틸 함수 모듈 분리 (require-based, 비파괴). selftest 7종이 동작 검증.
 const { _isSecretKey, compareVer, parseHarnessVersion, _classifyCJK, _riskLabel, _detectSystemLang, _parseSlashFromHelp,
   PERMISSION_TIERS, _tierRank, _requiredTier, _policyAllows, _resolveNpmTag, _mcpJsonContent, _newRunRecord } = require('../lib/pure-utils');
+// 1.9.304 (UR-0025): 순수 분석/검증 함수 모듈 분리.
+const { _evidenceQuality, _parseEvidenceStats, _shellGuardAnalyze, _claimFileInGit } = require('../lib/analyzers');
 // 1.9.295 (UR-0025 4단계): 정적 데이터 카탈로그 모듈 분리 (비파괴, require-based).
 const { CAPABILITY_SURFACE, POWERFUL_COMMANDS, ADAPTERS, REUSE_CATEGORIES, REUSE_CHECKLIST } = require('../lib/catalogs');
 
-const VERSION = '1.9.302';
+const VERSION = '1.9.304';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -189,6 +191,35 @@ function writeUtf8(p, s) {
   }
 }
 function append(p, s) { mkdirp(path.dirname(p)); fs.appendFileSync(p, s, 'utf8'); }
+// 1.9.303 (UR-0043, 외부리뷰): 동기 sleep (Atomics.wait, 실패 시 busy-wait 폴백).
+function _sleepSyncMs(ms) {
+  try { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.max(1, ms | 0)); }
+  catch { const end = Date.now() + ms; while (Date.now() < end) {} }
+}
+// 1.9.303 (UR-0043, 외부리뷰 Codex/Opus): read-modify-write lost-update 방지 advisory 락.
+//   O_EXCL(wx) 원자적 생성으로 상호배제. 다른 프로세스가 보유 중이면 짧게 대기 후 재시도.
+//   stale(보유 프로세스 crash) 은 staleMs 초과 시 탈취. 타임아웃(maxWaitMs) 시 락 없이 진행(원자쓰기로 손상은 이미 방지, lost-update 만 rare 노출).
+const _heldLocks = new Set();  // 프로세스 내 재진입 추적 (중첩 _withLock 데드락 방지)
+function _withLock(targetPath, fn, opts = {}) {
+  const lockPath = targetPath + '.lock';
+  if (_heldLocks.has(lockPath)) return fn();  // 이미 이 프로세스가 보유 → 재진입(중첩 호출 안전)
+  const maxWaitMs = opts.maxWaitMs || 5000;
+  const staleMs = opts.staleMs || 30000;
+  try { mkdirp(path.dirname(lockPath)); } catch {}
+  const start = Date.now();
+  let held = false;
+  while (Date.now() - start <= maxWaitMs) {
+    try { const fd = fs.openSync(lockPath, 'wx'); fs.closeSync(fd); held = true; break; }  // 원자적 배타 생성
+    catch (e) {
+      if (e.code !== 'EEXIST') break;  // 예기치 못한 오류 → 락 없이 진행
+      try { const st = fs.statSync(lockPath); if (Date.now() - st.mtimeMs > staleMs) { fs.unlinkSync(lockPath); continue; } } catch {}
+      _sleepSyncMs(15 + Math.floor((Date.now() - start) / 50));  // 점증 backoff
+    }
+  }
+  if (held) _heldLocks.add(lockPath);
+  try { return fn(); }
+  finally { if (held) { _heldLocks.delete(lockPath); try { fs.unlinkSync(lockPath); } catch {} } }
+}
 function rel(root, p) { return path.relative(root, p).replace(/\\/g, '/') || '.'; }
 function today() { return new Date().toISOString().slice(0, 10); }
 function now() { return new Date().toISOString(); }
@@ -3038,6 +3069,8 @@ function _selfTestCases() {
     { name: 'shell 주입 표면 제거: fetchNpmLatest execFile+pkg검증 + runCommandSafe argList 인용 (UR-0040 외부리뷰 1.9.300)', run: () => { const src = read(__filename); const npmFix = /cp\.execFile\('npm', \['view', pkg, 'version'\]/.test(src) && !/cp\.exec\(.npm view \$\{pkg\}/.test(src) && /패키지명 charset/.test(src); const argFix = /argList\.map\(_shellQuoteArg\)\.join/.test(src); return npmFix && argFix && typeof _shellQuoteArg === 'function'; } },
     { name: 'MCP requiredTier 메타데이터 + 정책 minTier 게이트 (UR-0041 외부리뷰 1.9.301)', run: () => { const T = require('../lib/mcp-tools'); const allValid = T.length >= 81 && T.every(t => PERMISSION_TIERS.includes(t.requiredTier)); const get = n => (T.find(t => t.name === n) || {}).requiredTier; const classOk = get('leerness_state_record') === 'safe-write' && get('leerness_provider_add') === 'safe-write' && get('leerness_web') === 'network' && get('leerness_handoff') === 'read-only' && get('leerness_audit') === 'read-only'; const src = read(__filename); const gateOk = /_tierRank\(minTier\) > _tierRank\(required\)/.test(src) && /_policyEnforce\(targetPath, cliArgs\.join\(' '\), _toolDef/.test(src); return allValid && classOk && gateOk; } },
     { name: 'verify-claim git diff 시맨틱 교차검증: _gitChangedFiles/_claimFileInGit + strict FAIL 통합 (UR-0042 외부리뷰 1.9.302)', run: () => { const fnOk = typeof _gitChangedFiles === 'function' && typeof _claimFileInGit === 'function'; const matchOk = _claimFileInGit('src/api.js', new Set(['src/api.js'])) === true && _claimFileInGit('./src/api.js', new Set(['src/api.js'])) === true && _claimFileInGit('other.js', new Set(['src/api.js'])) === false && _claimFileInGit('x', null) === null; const src = read(__filename); const wired = /git diff 교차검증/.test(src) && /\|\| !gitClaimOk/.test(src) && /_gitChangedFiles\(root\)/.test(src); return fnOk && matchOk && wired; } },
+    { name: '_withLock/_updateRun: lost-update 락(O_EXCL+재진입) + 적용 (UR-0043 외부리뷰 1.9.303)', run: () => { const src = read(__filename); const fnOk = typeof _withLock === 'function' && typeof _sleepSyncMs === 'function' && typeof _updateRun === 'function'; const reentrant = /if \(_heldLocks\.has\(lockPath\)\) return fn\(\)/.test(src); const excl = /fs\.openSync\(lockPath, 'wx'\)/.test(src); const applied = /const id = _withLock\(progressPath\(root\)/.test(src) && /_updateRun\(root, curId/.test(src); return fnOk && reentrant && excl && applied; } },
+    { name: 'lib/analyzers: 분석/검증 함수 4종 모듈 단일출처 분리 (UR-0025 1.9.304)', run: () => { const m = require('../lib/analyzers'); return m._evidenceQuality === _evidenceQuality && m._shellGuardAnalyze === _shellGuardAnalyze && m._parseEvidenceStats === _parseEvidenceStats && m._claimFileInGit === _claimFileInGit && !/function _evidenceQuality\(evidence\) \{/.test(read(__filename)) && !/function _shellGuardAnalyze\(cmd, ctx\) \{/.test(read(__filename)); } },
     { name: 'VERSION 형식 (x.y.z)', run: () => /^\d+\.\d+\.\d+$/.test(VERSION) }
   ];
 }
@@ -3081,38 +3114,7 @@ function selfTestCmd(opts = {}) {
 //   leerness 는 셸을 직접 가로챌 수 없으므로(0-dep Node CLI) → 실행 전 정적 분석 + 실패 기록/회수로 대응.
 //   ctx: { shell: 'powershell'|'cmd'|'bash'|'sh', psVersion: '5'|'7'|null }
 //   반환: { shell, psVersion, issues: [{ rule, severity, detail, suggestion }] } — 순수 함수 (단위 테스트 가능)
-function _shellGuardAnalyze(cmd, ctx) {
-  const c = String(cmd || '');
-  const shell = (ctx && ctx.shell) || 'unknown';
-  const psVer = ctx && ctx.psVersion != null ? parseInt(ctx.psVersion, 10) : null;
-  const issues = [];
-  const isWinPowerShell = shell === 'powershell' && psVer != null && psVer < 6;  // 5.1 = Windows PowerShell
-  // 규칙 1: PowerShell 5.1 에서 && / || 체이닝 미지원 (pwsh 7+ 부터 지원)
-  if (isWinPowerShell && /\s&&\s|\s\|\|\s/.test(c)) {
-    issues.push({ rule: 'ps5-chain', severity: 'error', detail: 'Windows PowerShell 5.1 은 && / || 연산자를 지원하지 않습니다 (PowerShell 7+ 부터 지원).', suggestion: 'A; if ($?) { B }  (조건부) 또는 A; B  (무조건) 로 분리. 또는 pwsh 7 설치.' });
-  }
-  // 규칙 2: PowerShell 에서 2>/dev/null → 2>$null
-  if (shell === 'powershell' && /2>\s*\/dev\/null/.test(c)) {
-    issues.push({ rule: 'ps-devnull', severity: 'error', detail: 'PowerShell 은 /dev/null 경로가 없습니다.', suggestion: '2>$null 사용 (PowerShell 리다이렉트).' });
-  }
-  // 규칙 3: PowerShell 에서 inline env (VAR=val cmd) 미지원
-  if (shell === 'powershell' && /^[A-Z_][A-Z0-9_]*=[^\s]+\s+\S/.test(c.trim())) {
-    issues.push({ rule: 'ps-inline-env', severity: 'error', detail: 'PowerShell 은 VAR=val cmd 형식의 inline 환경변수를 지원하지 않습니다.', suggestion: "$env:VAR='val'; cmd  로 분리." });
-  }
-  // 규칙 4: PowerShell 에서 Unix 전용 명령 (rm -rf / ls -la 등) — 별칭은 되나 플래그 오류 가능
-  if (shell === 'powershell' && /\brm\s+-rf\b/.test(c)) {
-    issues.push({ rule: 'ps-rm-rf', severity: 'warn', detail: 'PowerShell 에서 rm -rf 는 -rf 플래그 파싱 오류 가능 (rm 은 Remove-Item 별칭).', suggestion: 'Remove-Item -Recurse -Force <path> 사용.' });
-  }
-  // 규칙 5: CMD 에서 ; 는 명령 구분자가 아님 (한 줄로 실행됨)
-  if (shell === 'cmd' && /;/.test(c) && !/&&|\|\|/.test(c)) {
-    issues.push({ rule: 'cmd-semicolon', severity: 'warn', detail: 'CMD 는 ; 를 명령 구분자로 처리하지 않습니다 (인자로 전달됨).', suggestion: 'A && B  (조건부) 또는 A & B  (무조건) 사용.' });
-  }
-  // 규칙 6: PowerShell 에서 && 가 있으나 버전 미상 — 정보성
-  if (shell === 'powershell' && psVer == null && /\s&&\s/.test(c)) {
-    issues.push({ rule: 'ps-version-unknown', severity: 'info', detail: 'PowerShell 버전 미상 — 5.1 이면 && 미지원, 7+ 이면 지원.', suggestion: '$PSVersionTable.PSVersion 확인. 안전하게 A; if ($?) { B } 권장.' });
-  }
-  return { shell, psVersion: psVer, issues };
-}
+// _shellGuardAnalyze → lib/analyzers.js (1.9.304 UR-0025)
 function _shellFailuresPath(root) { return path.join(absRoot(root), '.harness', 'shell-failures.json'); }
 function _loadShellFailures(root) {
   try { const f = _shellFailuresPath(root); if (!exists(f)) return { failures: [] }; const j = JSON.parse(read(f)); return j && Array.isArray(j.failures) ? j : { failures: [] }; } catch { return { failures: [] }; }
@@ -6110,12 +6112,15 @@ function writeProgressRows(root, header, rows) {
   writeUtf8(progressPath(root), composed);
 }
 function upsertProgress(root, row) {
-  const header = progressHeader(root);
-  const rows = readProgressRows(root);
-  const i = rows.findIndex(r => r.id === row.id);
-  if (i >= 0) rows[i] = { ...rows[i], ...row, updated: today() };
-  else rows.push({ ...row, updated: today() });
-  writeProgressRows(root, header, rows);
+  // 1.9.303 (UR-0043): read-modify-write 전체를 락으로 직렬화 — 동시 task 쓰기 lost-update 방지.
+  return _withLock(progressPath(root), () => {
+    const header = progressHeader(root);
+    const rows = readProgressRows(root);
+    const i = rows.findIndex(r => r.id === row.id);
+    if (i >= 0) rows[i] = { ...rows[i], ...row, updated: today() };
+    else rows.push({ ...row, updated: today() });
+    writeProgressRows(root, header, rows);
+  });
 }
 
 function planShow(root) { const p = planPath(root); log(exists(p) ? read(p) : 'plan.md not found'); }
@@ -6176,11 +6181,15 @@ function planListCmd(root, opts = {}) {
 }
 
 function planAdd(root, text) {
-  const id = nextId(root, 'M');
-  const status = arg('--status','planned'), progress = arg('--progress','0');
-  append(planPath(root), `\n### ${id}. ${text}\nStatus: ${status}\nProgress: ${progress}%\n\nTasks:\n- [ ] ${text}\n`);
-  const tid = nextId(root, 'T');
-  upsertProgress(root, { id: tid, status, request: text, evidence: `plan:${id}`, nextAction: arg('--next', '다음 액션 작성') });
+  const status = arg('--status','planned'), progress = arg('--progress','0'), nextAction = arg('--next', '다음 액션 작성');
+  // 1.9.303 (UR-0043): M-id append + T-id upsert 를 하나의 락으로 — 동시 plan add ID 충돌 방지.
+  const { id, tid } = _withLock(progressPath(root), () => {
+    const id = nextId(root, 'M');
+    append(planPath(root), `\n### ${id}. ${text}\nStatus: ${status}\nProgress: ${progress}%\n\nTasks:\n- [ ] ${text}\n`);
+    const tid = nextId(root, 'T');
+    upsertProgress(root, { id: tid, status, request: text, evidence: `plan:${id}`, nextAction });
+    return { id, tid };
+  });
   ok(`plan added: ${id} → progress: ${tid}`);
   _autoRoadmap(absRoot(root), 'data-change');
 }
@@ -6302,8 +6311,12 @@ function taskAdd(root, text) {
       }
     } catch {}
   }
-  const id = nextId(root, 'T');
-  upsertProgress(root, { id, status: arg('--status','requested'), request: text, evidence: arg('--evidence','user-request'), nextAction: arg('--next','다음 액션 작성') });
+  // 1.9.303 (UR-0043): ID 할당 + write 를 하나의 락으로 — 동시 task add 의 ID 충돌(lost-update) 방지.
+  const id = _withLock(progressPath(root), () => {
+    const newId = nextId(root, 'T');
+    upsertProgress(root, { id: newId, status: arg('--status','requested'), request: text, evidence: arg('--evidence','user-request'), nextAction: arg('--next','다음 액션 작성') });
+    return newId;
+  });
   ok(`task added: ${id}`);
   _autoRoadmap(absRoot(root), 'data-change');
   // 1.9.177: task add 자동 review-request trigger (사용자 명시 1.9.176 자동화).
@@ -9394,17 +9407,7 @@ function reuseMapCmd(root) {
 // "src/foo.js + 5개 테스트 (54/54 통과)" 같은 주장을 파싱해 실제 파일/카운트 확인
 // 1.9.287 (Codex 리뷰 수렴): evidence 완전성 평가 — "테스트 통과만으로 done" 차단.
 //   done 주장은 (a) 수정 파일 경로 (b) 테스트명/개수 가 evidence 에 있어야 신뢰 가능. 순수 함수(selftest).
-function _evidenceQuality(evidence) {
-  const e = String(evidence || '');
-  const hasFile = /(?:[A-Za-z][\w-]*[\/\\])?[A-Za-z][\w./\\-]*\.(?:js|ts|tsx|jsx|mjs|cjs|py|go|rs|rb|kt|cs|gd|java|php|swift|c|cpp|h|html|css|scss|vue|svelte|json|yaml|yml|toml|md|sql|sh)\b/i.test(e);
-  const hasTest = /(\d+)\s*(?:\/\s*\d+\s*)?(?:통과|passed|passing|개\s*테스트)|\btests?\b\s*[:=]?\s*\d|Tests?:\s*\d|\b\d+\s*tests?\b/i.test(e);
-  const hasLog = /Exit\s*[:=]|exit\s*code|Command\s*[:=]|npm\s+(?:test|run)|pytest|cargo\s+test|go\s+test/i.test(e);
-  const missing = [];
-  if (!hasFile) missing.push('수정 파일 경로');
-  if (!hasTest) missing.push('테스트명/개수');
-  if (!hasLog) missing.push('실행 로그(Command/Exit)');
-  return { hasFile, hasTest, hasLog, ok: hasFile && hasTest, missing };
-}
+// _evidenceQuality → lib/analyzers.js (1.9.304 UR-0025)
 // 1.9.302 (UR-0042, 외부리뷰 Opus G-1): git 변경 파일 집합 — verify-claim 시맨틱 교차검증용.
 //   working tree(staged/unstaged/untracked) + 직전 커밋(HEAD~1..HEAD) 변경을 합쳐, "주장한 파일이 실제로 변경됐는가" 판정.
 //   git repo 아니거나 git 미설치면 null(검증 불가 → 페널티 X). 경로는 root-relative forward-slash.
@@ -9426,12 +9429,7 @@ function _gitChangedFiles(root) {
   } catch { return null; }
 }
 // 주장 파일이 git 변경 집합에 있는지(상대경로 prefix 차이 허용).
-function _claimFileInGit(claimed, gitSet) {
-  if (!gitSet) return null;
-  const c = String(claimed).replace(/\\/g, '/').replace(/^\.\//, '');
-  for (const g of gitSet) { if (g === c || g.endsWith('/' + c) || c.endsWith('/' + g)) return true; }
-  return false;
-}
+// _claimFileInGit → lib/analyzers.js (1.9.304 UR-0025)
 function verifyClaimCmd(root, taskId) {
   root = absRoot(root);
   if (!taskId) return fail('verify-claim <T-ID> 필요. 예: leerness verify-claim T-0008');
@@ -18117,6 +18115,16 @@ function _saveLeernessState(root, state) {
 function _runFile(root, id) { return path.join(_leernessStateDir(root), 'runs', `${id}.json`); }
 function _loadRun(root, id) { const f = _runFile(root, id); if (!exists(f)) return null; try { return JSON.parse(read(f)); } catch { return null; } }
 function _saveRun(root, rec) { const f = _runFile(root, rec.run_id); mkdirp(path.dirname(f)); writeUtf8(f, JSON.stringify(rec, null, 2) + '\n'); }
+// 1.9.303 (UR-0043): run 레코드 read-modify-write 를 락으로 직렬화 — 동시 state record/verify/handoff lost-update 방지.
+function _updateRun(root, id, mutator) {
+  return _withLock(_runFile(root, id), () => {
+    const rec = _loadRun(root, id);
+    if (!rec) return null;
+    mutator(rec);
+    _saveRun(root, rec);
+    return rec;
+  });
+}
 function _splitList(v) { return String(v || '').split(',').map(s => s.trim()).filter(Boolean); }
 
 // leerness state <show|start|record|verify|handoff>
@@ -18274,36 +18282,40 @@ function stateCmd(root, sub, ...args) {
   }
 
   if (sub === 'record') {
-    const rec = _loadRun(root, curId); if (!rec) return fail(`run 없음: ${curId}`);
-    for (const [flag, key] of [['--files-read', 'files_read'], ['--files-changed', 'files_changed'], ['--commands', 'commands_run'], ['--tests', 'tests_run'], ['--errors', 'errors'], ['--decision', 'decisions']]) {
-      const v = arg(flag, null); if (v) rec[key] = Array.from(new Set([...(rec[key] || []), ..._splitList(v)]));
-    }
-    _saveRun(root, rec);
+    const rec = _updateRun(root, curId, (rec) => {  // 1.9.303 (UR-0043): 락 직렬화 RMW
+      for (const [flag, key] of [['--files-read', 'files_read'], ['--files-changed', 'files_changed'], ['--commands', 'commands_run'], ['--tests', 'tests_run'], ['--errors', 'errors'], ['--decision', 'decisions']]) {
+        const v = arg(flag, null); if (v) rec[key] = Array.from(new Set([...(rec[key] || []), ..._splitList(v)]));
+      }
+    });
+    if (!rec) return fail(`run 없음: ${curId}`);
     if (json) { log(JSON.stringify({ recorded: curId, run: rec }, null, 2)); return; }
     ok(`기록: ${curId} (files_changed ${rec.files_changed.length} · commands ${rec.commands_run.length} · tests ${rec.tests_run.length} · decisions ${rec.decisions.length})`);
     return;
   }
 
   if (sub === 'verify') {
-    const rec = _loadRun(root, curId); if (!rec) return fail(`run 없음: ${curId}`);
     const result = (arg('--result', '') || (args.find(a => a && !a.startsWith('-')) || '')).toLowerCase();
     if (result !== 'pass' && result !== 'fail') return fail('--result pass|fail 필요');
-    rec.verification_result = result;
-    rec.status = result === 'pass' ? 'verified' : 'in-progress';
-    const note = arg('--note', null); if (note) rec.decisions = [...(rec.decisions || []), `verify(${result}): ${note}`];
-    _saveRun(root, rec);
+    const note = arg('--note', null);
+    const rec = _updateRun(root, curId, (rec) => {  // 1.9.303 (UR-0043): 락 직렬화 RMW
+      rec.verification_result = result;
+      rec.status = result === 'pass' ? 'verified' : 'in-progress';
+      if (note) rec.decisions = [...(rec.decisions || []), `verify(${result}): ${note}`];
+    });
+    if (!rec) return fail(`run 없음: ${curId}`);
     if (json) { log(JSON.stringify({ verified: curId, result, run: rec }, null, 2)); return; }
     (result === 'pass' ? ok : warn)(`검증 결과: ${curId} → ${result}`);
     return;
   }
 
   if (sub === 'handoff') {
-    const rec = _loadRun(root, curId); if (!rec) return fail(`run 없음: ${curId}`);
     const summary = (args.find(a => a && !a.startsWith('-')) || arg('--summary', '')).trim();
-    rec.handoff_summary = summary || rec.handoff_summary || '(요약 없음)';
-    rec.ended_at = new Date().toISOString();
-    rec.status = 'handed-off';
-    _saveRun(root, rec);
+    const rec = _updateRun(root, curId, (rec) => {  // 1.9.303 (UR-0043): 락 직렬화 RMW
+      rec.handoff_summary = summary || rec.handoff_summary || '(요약 없음)';
+      rec.ended_at = new Date().toISOString();
+      rec.status = 'handed-off';
+    });
+    if (!rec) return fail(`run 없음: ${curId}`);
     // 다음 에이전트가 읽을 latest handoff (json + md)
     const hdir = path.join(_leernessStateDir(root), 'handoff'); mkdirp(hdir);
     writeUtf8(path.join(hdir, 'latest.json'), JSON.stringify(rec, null, 2) + '\n');
@@ -18442,19 +18454,7 @@ function reuseCheckCmd(root, feature, opts = {}) {
 //   "설치한 스킬이 코딩 성능/정확도에 긍정 영향?" — 무거운 벤치 harness 가 아니라, 기존 데이터
 //   (skill 사용 빈도 + review-evidence 검증 통과율)를 상관(인과 아님)으로 advisory 제시. offline.
 // review-evidence.md 파싱 (순수) — 검증 항목 수 + pass/fail 추정 (Exit 0 / 'PASS' vs 'fail'/Exit !=0).
-function _parseEvidenceStats(text) {
-  const t = String(text || '');
-  const blocks = t.split(/\n(?=## )/).filter(b => /Command:|Exit:|verify|test/i.test(b));
-  let pass = 0, fail = 0;
-  for (const b of blocks) {
-    const exitM = b.match(/Exit:\s*(-?\d+)/i);
-    if (exitM) { (parseInt(exitM[1], 10) === 0 ? pass++ : fail++); continue; }
-    if (/\bPASS\b|통과|성공|✓/i.test(b)) pass++;
-    else if (/\bFAIL\b|실패|오류|error|✗/i.test(b)) fail++;
-  }
-  const entries = blocks.length;
-  return { entries, pass, fail, rate: (pass + fail) ? Math.round(pass / (pass + fail) * 100) : null };
-}
+// _parseEvidenceStats → lib/analyzers.js (1.9.304 UR-0025)
 function skillImpactCmd(root) {
   root = absRoot(root || process.cwd());
   const json = has('--json');

package/lib/analyzers.js

@@ -0,0 +1,68 @@
+// lib/analyzers.js — 순수 분석/검증 함수 (부작용 0, 입력→출력).
+// 1.9.304 (UR-0025): bin/harness.js 에서 비파괴 분리. selftest(evidenceQuality/parseEvidenceStats/shellGuardAnalyze/claimFileInGit)가 동작 검증.
+'use strict';
+
+function _shellGuardAnalyze(cmd, ctx) {
+  const c = String(cmd || '');
+  const shell = (ctx && ctx.shell) || 'unknown';
+  const psVer = ctx && ctx.psVersion != null ? parseInt(ctx.psVersion, 10) : null;
+  const issues = [];
+  const isWinPowerShell = shell === 'powershell' && psVer != null && psVer < 6;  // 5.1 = Windows PowerShell
+  // 규칙 1: PowerShell 5.1 에서 && / || 체이닝 미지원 (pwsh 7+ 부터 지원)
+  if (isWinPowerShell && /\s&&\s|\s\|\|\s/.test(c)) {
+    issues.push({ rule: 'ps5-chain', severity: 'error', detail: 'Windows PowerShell 5.1 은 && / || 연산자를 지원하지 않습니다 (PowerShell 7+ 부터 지원).', suggestion: 'A; if ($?) { B }  (조건부) 또는 A; B  (무조건) 로 분리. 또는 pwsh 7 설치.' });
+  }
+  // 규칙 2: PowerShell 에서 2>/dev/null → 2>$null
+  if (shell === 'powershell' && /2>\s*\/dev\/null/.test(c)) {
+    issues.push({ rule: 'ps-devnull', severity: 'error', detail: 'PowerShell 은 /dev/null 경로가 없습니다.', suggestion: '2>$null 사용 (PowerShell 리다이렉트).' });
+  }
+  // 규칙 3: PowerShell 에서 inline env (VAR=val cmd) 미지원
+  if (shell === 'powershell' && /^[A-Z_][A-Z0-9_]*=[^\s]+\s+\S/.test(c.trim())) {
+    issues.push({ rule: 'ps-inline-env', severity: 'error', detail: 'PowerShell 은 VAR=val cmd 형식의 inline 환경변수를 지원하지 않습니다.', suggestion: "$env:VAR='val'; cmd  로 분리." });
+  }
+  // 규칙 4: PowerShell 에서 Unix 전용 명령 (rm -rf / ls -la 등) — 별칭은 되나 플래그 오류 가능
+  if (shell === 'powershell' && /\brm\s+-rf\b/.test(c)) {
+    issues.push({ rule: 'ps-rm-rf', severity: 'warn', detail: 'PowerShell 에서 rm -rf 는 -rf 플래그 파싱 오류 가능 (rm 은 Remove-Item 별칭).', suggestion: 'Remove-Item -Recurse -Force <path> 사용.' });
+  }
+  // 규칙 5: CMD 에서 ; 는 명령 구분자가 아님 (한 줄로 실행됨)
+  if (shell === 'cmd' && /;/.test(c) && !/&&|\|\|/.test(c)) {
+    issues.push({ rule: 'cmd-semicolon', severity: 'warn', detail: 'CMD 는 ; 를 명령 구분자로 처리하지 않습니다 (인자로 전달됨).', suggestion: 'A && B  (조건부) 또는 A & B  (무조건) 사용.' });
+  }
+  // 규칙 6: PowerShell 에서 && 가 있으나 버전 미상 — 정보성
+  if (shell === 'powershell' && psVer == null && /\s&&\s/.test(c)) {
+    issues.push({ rule: 'ps-version-unknown', severity: 'info', detail: 'PowerShell 버전 미상 — 5.1 이면 && 미지원, 7+ 이면 지원.', suggestion: '$PSVersionTable.PSVersion 확인. 안전하게 A; if ($?) { B } 권장.' });
+  }
+  return { shell, psVersion: psVer, issues };
+}
+function _evidenceQuality(evidence) {
+  const e = String(evidence || '');
+  const hasFile = /(?:[A-Za-z][\w-]*[\/\\])?[A-Za-z][\w./\\-]*\.(?:js|ts|tsx|jsx|mjs|cjs|py|go|rs|rb|kt|cs|gd|java|php|swift|c|cpp|h|html|css|scss|vue|svelte|json|yaml|yml|toml|md|sql|sh)\b/i.test(e);
+  const hasTest = /(\d+)\s*(?:\/\s*\d+\s*)?(?:통과|passed|passing|개\s*테스트)|\btests?\b\s*[:=]?\s*\d|Tests?:\s*\d|\b\d+\s*tests?\b/i.test(e);
+  const hasLog = /Exit\s*[:=]|exit\s*code|Command\s*[:=]|npm\s+(?:test|run)|pytest|cargo\s+test|go\s+test/i.test(e);
+  const missing = [];
+  if (!hasFile) missing.push('수정 파일 경로');
+  if (!hasTest) missing.push('테스트명/개수');
+  if (!hasLog) missing.push('실행 로그(Command/Exit)');
+  return { hasFile, hasTest, hasLog, ok: hasFile && hasTest, missing };
+}
+function _claimFileInGit(claimed, gitSet) {
+  if (!gitSet) return null;
+  const c = String(claimed).replace(/\\/g, '/').replace(/^\.\//, '');
+  for (const g of gitSet) { if (g === c || g.endsWith('/' + c) || c.endsWith('/' + g)) return true; }
+  return false;
+}
+function _parseEvidenceStats(text) {
+  const t = String(text || '');
+  const blocks = t.split(/\n(?=## )/).filter(b => /Command:|Exit:|verify|test/i.test(b));
+  let pass = 0, fail = 0;
+  for (const b of blocks) {
+    const exitM = b.match(/Exit:\s*(-?\d+)/i);
+    if (exitM) { (parseInt(exitM[1], 10) === 0 ? pass++ : fail++); continue; }
+    if (/\bPASS\b|통과|성공|✓/i.test(b)) pass++;
+    else if (/\bFAIL\b|실패|오류|error|✗/i.test(b)) fail++;
+  }
+  const entries = blocks.length;
+  return { entries, pass, fail, rate: (pass + fail) ? Math.round(pass / (pass + fail) * 100) : null };
+}
+
+module.exports = { _evidenceQuality, _parseEvidenceStats, _shellGuardAnalyze, _claimFileInGit };

package/package.json

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

package/scripts/e2e.js

@@ -3402,5 +3402,57 @@ total++;
   if (!ok) failed++;
 }
 
+// 1.9.303 회귀 (UR-0043 외부리뷰): 동시 task add lost-update 락 — 6개 병렬 추가 시 모두 보존 + ID 충돌 0
+total++;
+{
+  let ok = false;
+  try {
+    const lDir = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-lock-'));
+    cp.spawnSync(process.execPath, [CLI, 'init', lDir, '--yes', '--language', 'ko', '--skills', 'recommended'], { encoding: 'utf8', timeout: 30000 });
+    const N = 6;
+    const procs = [];
+    for (let i = 0; i < N; i++) procs.push(cp.spawn(process.execPath, [CLI, 'task', 'add', 'LOCKTEST-' + i, '--path', lDir], { stdio: 'ignore' }));
+    const ptPath = path.join(lDir, '.harness', 'progress-tracker.md');
+    // 자식들이 OS 프로세스로 독립 진행 → 부모는 파일을 sync 폴링(원자쓰기라 부분읽기 없음)
+    const start = Date.now(); let found = 0;
+    while (Date.now() - start < 25000) {
+      try { const pt = fs.readFileSync(ptPath, 'utf8'); found = Array.from({ length: N }, (_, i) => i).filter(i => pt.includes('LOCKTEST-' + i)).length; if (found === N) break; } catch {}
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
+    }
+    try { procs.forEach(p => { try { p.kill(); } catch {} }); } catch {}
+    const pt = fs.readFileSync(ptPath, 'utf8');
+    const allFound = Array.from({ length: N }, (_, i) => i).every(i => pt.includes('LOCKTEST-' + i));
+    const ids = (pt.match(/^\| (T-\d{4}) \|/gm) || []).map(s => s.match(/T-\d{4}/)[0]);
+    const noDupId = ids.length === new Set(ids).size;  // ID 충돌 0
+    const oneSep = pt.split('\n').filter(l => /^\|---\|/.test(l)).length === 1;
+    ok = allFound && noDupId && oneSep;
+    fs.rmSync(lDir, { recursive: true, force: true });
+  } catch {}
+  console.log(ok ? '✓ B(1.9.303) 동시 task add lost-update 락: 6 병렬 모두 보존 + ID 충돌 0 (UR-0043)' : '✗ lost-update 락 실패');
+  if (!ok) failed++;
+}
+
+// 1.9.304 회귀 (UR-0025): lib/analyzers.js 모듈 분리 — 단일출처 + 부작용 0 + 소비 명령 회귀
+total++;
+{
+  let ok = false;
+  try {
+    const a = require(path.resolve(__dirname, '..', 'lib', 'analyzers.js'));
+    const dataOk = typeof a._evidenceQuality === 'function' && typeof a._parseEvidenceStats === 'function' &&
+      typeof a._shellGuardAnalyze === 'function' && typeof a._claimFileInGit === 'function' &&
+      a._evidenceQuality('src/api.js 수정, 12/12 통과 (Exit: 0)').ok === true &&
+      a._shellGuardAnalyze('a && b', { shell: 'powershell', psVersion: '5' }).issues.some(i => i.rule === 'ps5-chain') &&
+      a._claimFileInGit('src/api.js', new Set(['src/api.js'])) === true;
+    const harnessSrc = fs.readFileSync(path.resolve(__dirname, '..', 'bin', 'harness.js'), 'utf8');
+    const movedOut = !/function _evidenceQuality\(evidence\) \{/.test(harnessSrc) && !/function _shellGuardAnalyze\(cmd, ctx\) \{/.test(harnessSrc) && /require\('\.\.\/lib\/analyzers'\)/.test(harnessSrc);
+    // 소비 명령 회귀: shell-guard (_shellGuardAnalyze 사용)
+    const sg = cp.spawnSync(process.execPath, [CLI, 'shell-guard', 'a && b', '--json'], { cwd: tmp, encoding: 'utf8', timeout: 20000 });
+    const cmdOk = sg.status === 0 && /"shell"/.test(sg.stdout || '');
+    ok = dataOk && movedOut && cmdOk;
+  } catch {}
+  console.log(ok ? '✓ B(1.9.304) lib/analyzers 모듈 분리: 단일출처 + 인라인 제거 + shell-guard 동작 (UR-0025)' : '✗ analyzers 모듈 분리 실패');
+  if (!ok) failed++;
+}
+
 console.log(`\nE2E result: ${total - failed}/${total} passed · ${((Date.now() - _e2eStart) / 1000).toFixed(0)}s`);
 if (failed > 0) process.exit(1);