leerness 1.9.292 → 1.9.294

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## 1.9.294 — 2026-06-04 — UR-0025 (3단계): 역할/모델 카탈로그 → lib/role-catalog.js 모듈 분리
+
+**🧩 모놀리스 분리 3단계 — 역할/모델 레지스트리(4개 카탈로그)를 비파괴 데이터 모듈로 분리. 1.9.274(pure-utils)/1.9.291(agent-registry) 패턴 계승.**
+
+### 배경
+GPT-5.5 + Codex 두 리뷰 공통 지적인 단일 대형 `bin/harness.js`(#1 유지보수 이슈)를 점진 분리 중. 1단계(pure-utils 14함수)·2단계(agent-registry)에 이어 3단계로 역할/모델 데이터 카탈로그를 분리.
+
+### 구현 (UR-0025 3단계)
+1. **`lib/role-catalog.js` 신설** — 4개 순수 데이터 카탈로그 이동(96줄):
+   - `_PROVIDER_MODEL_CATALOG`(provider×모델 10종, REPL Tab cycle)
+   - `_AGENT_ROLE_PROMPTS`(planner/reviewer/actor 역할 프롬프트)
+   - `ROLE_CATALOG`(7종 역할: commander/reviewer/coder/architect/designer/debugger/dispatcher)
+   - `_ROLE_ALIASES`(한국어 별칭 21종)
+2. **비파괴 require-based 분리** — `_normalizeRole`/`_pickModel`/REPL 소비처는 동일 바인딩 사용. 런타임 변형 0(모두 읽기 전용 검증).
+3. **harness.js 21700→21606줄** (94줄 감소). 누적: pure-utils(163)+agent-registry(147)+role-catalog(103) 3 모듈.
+4. selftest 41→42 (4개 카탈로그 동일참조 단일출처 + 인라인 제거 검증) · e2e 238→239 (모듈 standalone + harness 인라인 제거 + `roles list` 동작 회귀).
+
+### 검증
+- **selftest 42/42 PASS** · **E2E 239/239 PASS** (회귀 0).
+- 기존 selftest(ROLE_CATALOG 7종 + _normalizeRole 한국어별칭 + _pickModel top/code/fast)가 추출 정합성 즉시 검증.
+- `roles list --json` 정상 동작 확인(모듈 분리 후 회귀 없음).
+
+## 1.9.293 — 2026-06-04 — idempotency auto-fix + progress-tracker 복제 버그 근본 수정 🐛
+
+**🔁 idempotency 위반(task/요청 중복)을 자동 회복하는 `--auto-fix` 신설 + 중복이 매 세션 누적되던 근본 버그(헤더 유실 시 전체 복제) 수정. 라이브 프로젝트 progress-tracker.md 69행→6행 복구.**
+
+### 배경 (자기 발견 — session-close가 보고한 멱등성 위반 4→11 증가 추적)
+세션마다 멱등성 위반이 증가(4→11)해 원인을 추적한 결과 **근본 버그** 발견: `progressHeader()`가 `|---|` 분리자를 못 찾으면(헤더 유실/손상) **파일 전체 텍스트를 헤더로 반환** → `writeProgressRows()`가 `header + rows` 로 기록하며 **기존 모든 행을 복제**. `taskAdd`/`upsertProgress`가 호출될 때마다 progress-tracker.md 가 배로 부풀며 중복 누적. 실제 라이브 파일은 헤더가 유실된 채 69행(고유 6행)까지 손상돼 있었음.
+
+### 구현
+1. **근본 버그 fix** — `progressHeader()` 가 분리자 부재 시 전체 텍스트 대신 **`_canonicalProgressHeader()` (frontmatter + 표 헤더 + 분리자 재구성)** 반환 → 다음 write 시 헤더 자동 복구, 복제 중단. `coreFiles` 템플릿도 동일 헬퍼로 DRY(단일 출처).
+2. **`leerness idempotency audit --auto-fix`** — (a) 완전 동일 행 제거(순수 중복), (b) active 동일텍스트는 `status=dropped` 로 보존(id/히스토리 유지, 삭제 X), (c) user-requests open 중복 정리. 멱등(2회=no-op) · git 회복 가능.
+3. **`drift check --auto-fix` 통합** — 기존 자동 회복 흐름(1.9.82/225/236 패턴)에 idempotency dedup 추가 → 자동 self-healing.
+4. **라이브 복구** — 손상된 progress-tracker.md 에 auto-fix 적용: 완전중복 63행 제거 + 헤더 재구성 → 69행→6행, 멱등성 위반 0.
+5. selftest 40→41 · e2e 237→238.
+
+### 검증
+- **selftest 41/41 PASS** · **E2E 238/238 PASS** (회귀 0).
+- e2e: 헤더 유실+중복 시뮬레이션 → auto-fix → 헤더 재구성 + 완전중복 3→1 + 재검사 clean 실측.
+- 라이브: `idempotency audit --path . --auto-fix` → "완전중복 63행 제거", 6개 실제 task(T-0001~0006) 보존, 헤더 정상 복원.
+- MCP `leerness_idempotency_audit` 는 read-only 유지(쓰기 경로는 CLI/drift 전용 — 정책 tier 일관성).
+
 ## 1.9.292 — 2026-06-03 — UR-0031: get_project_context — MCP 시맨틱 verb (에이전트 온보딩 1콜 집약)
 
 **🧭 GPT-5.5 "MCP-first 범용 하네스" 전략의 핵심 — 어떤 에이전트든 leerness 내부 명령을 몰라도 단 1콜로 "지금 무엇을 알아야 하는가"를 파악하는 집약 컨텍스트 verb 신설.**

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.292-green)]() [![tests](https://img.shields.io/badge/e2e-237%2F237-success)]() [![selftest](https://img.shields.io/badge/selftest-40-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-80-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.294-green)]() [![tests](https://img.shields.io/badge/e2e-239%2F239-success)]() [![selftest](https://img.shields.io/badge/selftest-42-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-80-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.292 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.9.294 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
 
 ### Core Commands
 
@@ -513,7 +513,7 @@ leerness memory restore decision <date|title>
 
 ### MCP server (외부 AI 통합)
 
-Leerness v1.9.292는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **80개 도구**를 노출:
+Leerness v1.9.294는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **80개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -534,7 +534,7 @@ Leerness v1.9.292는 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.292)** · 매 라운드 GitHub release/태그 생성 · _reports/는 비공개 보존.
+현재 누적: **70 라운드 (1.9.40 → 1.9.294)** · 매 라운드 GitHub release/태그 생성 · _reports/는 비공개 보존.
 
 ### 성능 가이드 (1.9.140 측정)
 
@@ -572,6 +572,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.292: 2026-06-03
+Last synced by Leerness v1.9.294: 2026-06-04
 <!-- leerness:project-readme:end -->
 

package/bin/harness.js

@@ -10,7 +10,7 @@ const readline = require('readline');
 const { _isSecretKey, compareVer, parseHarnessVersion, _classifyCJK, _riskLabel, _detectSystemLang, _parseSlashFromHelp,
   PERMISSION_TIERS, _tierRank, _requiredTier, _policyAllows, _resolveNpmTag, _mcpJsonContent, _newRunRecord } = require('../lib/pure-utils');
 
-const VERSION = '1.9.292';
+const VERSION = '1.9.294';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -431,7 +431,7 @@ function coreFiles(root, lang = 'ko', selectedSkills = [], opts = {}) {
     '.harness/skills-lock.json': skillLock(selectedSkills),
     '.harness/project-brief.md': fm('project-brief', ['프로젝트 목적 확인','신규 기능 판단','계획 수립'], ['프로젝트 목적 변경','사용자/범위 변경'], `# Project Brief\n\n## Project\n${project}\n\n## Purpose\n- 이 프로젝트의 목적을 실제 내용으로 업데이트하세요.\n\n## Users\n-\n\n## Success Criteria\n-\n`),
     '.harness/plan.md': fm('plan', ['작업 시작 전','새 요청 접수','범위 변경','신규 프로젝트 감지'], ['계획 추가/수정/드랍','milestone 변경','목표 변경'], `# Plan\n\n## Goal\n- 사용자 목적을 기준으로 전체 계획을 유지합니다.\n\n## Scope\n- 포함 범위를 기록합니다.\n\n## Out of Scope / Dropped\n| ID | Item | Reason | Date |\n|---|---|---|---|\n\n## Milestones\n\n### M-0001. 프로젝트 계획 정리\nStatus: planned\nProgress: 0%\n\nTasks:\n- [ ] project-brief.md를 실제 프로젝트 목적에 맞게 작성\n- [ ] context-map.md를 실제 파일 구조에 맞게 작성\n`),
-    '.harness/progress-tracker.md': fm('progress-tracker', ['세션 시작','세션 종료','사용자 요청 상태 확인'], ['작업 상태 변경','검증 결과 추가','사용자 요청 드랍'], `# Progress Tracker\n\nStatus values: requested, planned, in-progress, waiting, on-hold, blocked, incomplete, done, dropped\n\n| ID | Status | Request | Evidence | Next Action | Updated |\n|---|---|---|---|---|---|\n`),
+    '.harness/progress-tracker.md': _canonicalProgressHeader() + '\n',  // 1.9.293: _canonicalProgressHeader 단일 출처 (progressHeader 폴백과 동일)
     '.harness/guideline.md': fm('guideline', ['구현 전 품질 기준 확인','계획 이행 기준 확인'], ['개발 기준 변경','검증 루틴 변경'], `# Guideline\n\n## Operating Principle\n- plan.md의 목표와 범위를 기준으로 작업합니다.\n- progress-tracker.md의 요청 상태를 기준으로 완료/미완료를 판단합니다.\n- guideline.md에는 진행률 수치를 직접 기록하지 않습니다. 진행률은 plan.md/progress-tracker.md가 단일 출처입니다.\n\n## Quality Gate\n- 변경 전 관련 route를 확인합니다 (\`leerness route <task-type>\`).\n- 변경 후 \`leerness verify\`, \`leerness audit\`, \`leerness check\`을 실행합니다.\n- 완료 선언 전 \`leerness lazy detect\`을 실행합니다.\n- 세션 종료 시 \`leerness session close\`를 실행합니다.\n`),
     '.harness/plan-progress-boundary.md': fm('plan-progress-boundary', ['계획과 진행률이 중복될 때','작업 추적 구조 변경'], ['역할 분리 기준 변경'], `# Plan / Progress Boundary\n\n## plan.md\n- 전체 목표, milestone, 포함/제외 범위, 계획 변경 이력.\n\n## progress-tracker.md\n- 사용자 요청 단위의 상태, 증거, 다음 액션.\n- ID 규칙: T-0001부터 단조 증가. plan add 시 부여되는 ID는 plan/progress 양쪽에서 고유합니다.\n\n## guideline.md\n- plan/progress를 수행할 때 지켜야 할 실행 기준.\n`),
     '.harness/current-state.md': fm('current-state', ['세션 시작','작업 이어받기'], ['현재 상태 변경','다음 작업 변경'], `# Current State\n\nUpdated: ${today()}\n\n## Now\n-\n\n## Next\n-\n\n## Blockers\n-\n`),
@@ -2999,6 +2999,8 @@ function _selfTestCases() {
     { name: '_cliBootstrap: CLI 부작용 require.main 가드 격리 (Codex #4 UR-0037 1.9.290)', run: () => { if (typeof _cliBootstrap !== 'function' || typeof _ensureStdoutEncoding !== 'function') return false; const src = read(__filename); const guarded = /if \(require\.main === module\) _cliBootstrap\(\);/.test(src); const inFn = /function _cliBootstrap\(\)\s*\{[\s\S]*?removeAllListeners\('warning'\)[\s\S]*?NODE_OPTIONS[\s\S]*?_ensureStdoutEncoding\(\);[\s\S]*?\n\}/.test(src); const noTopIife = !/\}\)\(\);\s*\n\n\/\/ 1\.9\.184/.test(src); return guarded && inFn && noTopIife; } },
     { name: 'lib/agent-registry: EXTERNAL_AGENTS/AGENT_SLASH_COMMANDS 모듈 단일출처 분리 (UR-0025 1.9.291)', run: () => { const m = require('../lib/agent-registry'); return m.EXTERNAL_AGENTS === EXTERNAL_AGENTS && m.AGENT_SLASH_COMMANDS === AGENT_SLASH_COMMANDS && m.EXTERNAL_AGENTS.length === 10 && Object.keys(m.AGENT_SLASH_COMMANDS).length === 9 && !/const EXTERNAL_AGENTS = \[/.test(read(__filename)); } },
     { name: 'get_project_context: MCP 시맨틱 verb 등록 + CLI context 디스패치 (UR-0031 1.9.292)', run: () => { const src = read(__filename); const mcpDef = /name: 'leerness_get_project_context'/.test(src); const mcpCase = /case 'leerness_get_project_context':[\s\S]*?cliArgs = \['context'/.test(src); const cliDisp = /if \(cmd === 'context'\)\s+return contextCmd/.test(src); return typeof contextCmd === 'function' && mcpDef && mcpCase && cliDisp && _mcpToolCount() >= 80; } },
+    { name: '_canonicalProgressHeader + idempotency auto-fix (근본 복제버그 fix 1.9.293)', run: () => { const h = _canonicalProgressHeader(); const headerOk = /leernessRole: progress-tracker/.test(h) && /\| ID \| Status \| Request \|/.test(h) && /\|---\|/.test(h); const src = read(__filename); const fnOk = typeof _autoFixIdempotency === 'function'; const noWholeTextFallback = /if \(idx < 0\) return _canonicalProgressHeader\(\);/.test(src); const driftWired = /_autoFixIdempotency\(root\)/.test(src) && /idempotency 중복/.test(src); return headerOk && fnOk && noWholeTextFallback && driftWired; } },
+    { name: 'lib/role-catalog: ROLE/PROVIDER/ALIASES/PROMPTS 모듈 단일출처 분리 (UR-0025 1.9.294)', run: () => { const m = require('../lib/role-catalog'); return m.ROLE_CATALOG === ROLE_CATALOG && m._PROVIDER_MODEL_CATALOG === _PROVIDER_MODEL_CATALOG && m._ROLE_ALIASES === _ROLE_ALIASES && m._AGENT_ROLE_PROMPTS === _AGENT_ROLE_PROMPTS && Object.keys(m.ROLE_CATALOG).length === 7 && Object.keys(m._PROVIDER_MODEL_CATALOG).length === 10 && !/const ROLE_CATALOG = \{/.test(read(__filename)); } },
     { name: 'VERSION 형식 (x.y.z)', run: () => /^\d+\.\d+\.\d+$/.test(VERSION) }
   ];
 }
@@ -5435,6 +5437,62 @@ function _runIdempotencyAudit(root) {
   };
   return audit;
 }
+// 1.9.293: idempotency audit --auto-fix — task/user-request 중복 자동 회복.
+//   배경: 룰(1.9.212)/wakeup(1.9.205)은 dedup 보유하나 task/user-request 누적 중복은 탐지만 됐음(수동 drop 필요).
+//   안전: (1) 완전 동일 행만 제거(순수 중복), (2) active 동일-텍스트는 status=dropped 로 보존(id/히스토리 유지, 삭제 X),
+//         (3) git-tracked 파일이라 회복 가능, (4) 멱등(2회 실행 = no-op).
+function _autoFixIdempotency(root) {
+  const fixed = [];
+  // 1) progress-tracker.md task 중복
+  try {
+    const pt = path.join(root, '.harness', 'progress-tracker.md');
+    if (exists(pt)) {
+      const header = progressHeader(root);
+      const rows = readProgressRows(root);
+      const seenExact = new Set();
+      const seenActiveText = new Map();
+      const kept = [];
+      let removedExact = 0, droppedSameText = 0;
+      for (const r of rows) {
+        const exactKey = `${r.id}|${r.status}|${r.request}|${r.evidence}|${r.nextAction}|${r.updated}`;
+        if (seenExact.has(exactKey)) { removedExact++; continue; }  // 완전 동일 행 = 순수 중복 → 제거
+        seenExact.add(exactKey);
+        const isActive = !/^(done|dropped|blocked|completed|\[완료\]|\[드랍\]|\[보류\])/i.test(r.status || '');
+        if (isActive && r.request && r.request.length >= 5) {
+          if (seenActiveText.has(r.request)) {
+            r.status = 'dropped';
+            r.nextAction = `(auto-dedup 1.9.293 — ${seenActiveText.get(r.request)} 와 동일)`;
+            droppedSameText++;
+          } else {
+            seenActiveText.set(r.request, r.id);
+          }
+        }
+        kept.push(r);
+      }
+      if (removedExact > 0 || droppedSameText > 0) {
+        writeProgressRows(root, header, kept);
+        fixed.push({ kind: 'task-duplicate-request', action: 'deduped', removedExact, droppedSameText });
+      }
+    }
+  } catch (e) { fixed.push({ kind: 'task-duplicate-request', action: 'error', detail: String(e.message || e) }); }
+  // 2) user-requests.json open 중복 — 동일 텍스트 중 최초만 open 유지, 나머지 dropped(보존)
+  try {
+    const ur = _loadUserRequests(root);
+    const seen = new Map();
+    let droppedReq = 0;
+    for (const r of ur.requests) {
+      if (r.status !== 'open' && r.status !== 'in-progress') continue;
+      const k = (r.text || '').trim();
+      if (seen.has(k)) { r.status = 'dropped'; r.droppedReason = `auto-dedup-1.9.293 (== ${seen.get(k)})`; droppedReq++; }
+      else seen.set(k, r.id);
+    }
+    if (droppedReq > 0) {
+      _writeUserRequests(root, ur.requests);
+      fixed.push({ kind: 'user-request-duplicate', action: 'dropped', count: droppedReq });
+    }
+  } catch (e) { fixed.push({ kind: 'user-request-duplicate', action: 'error', detail: String(e.message || e) }); }
+  return fixed;
+}
 function idempotencyCmd(root, sub) {
   root = absRoot(root);
   const isTty = process.stdout && process.stdout.isTTY;
@@ -5447,15 +5505,21 @@ function idempotencyCmd(root, sub) {
   if (!sub || sub === 'help' || sub === '--help') {
     log(`# leerness idempotency (1.9.212) — 멱등성 위반 탐지`);
     log('');
-    log(`  audit     → 워크스페이스 멱등성 점검 (rules / tasks / user-requests / wakeups)  (--json 가능)`);
+    log(`  audit               → 워크스페이스 멱등성 점검 (rules / tasks / user-requests / wakeups)  (--json 가능)`);
+    log(`  audit --auto-fix    → task 완전중복 행 제거 + active 동일텍스트 dropped 처리 + user-request open 중복 정리 (1.9.293)`);
     log('');
     log(dim(`  dedup 적용 영역: ruleAdd / taskAdd (1.9.212) + _recordUserRequest (1.9.207) + _recordWakeup (1.9.205)`));
+    log(dim(`  --auto-fix 안전: 완전 동일 행만 제거 / 동일텍스트는 status=dropped 로 보존(id 유지) / git 회복 가능 / 멱등`));
+    log(dim(`  자동화: drift check --auto-fix 가 idempotency 중복도 자동 정리 (1.9.293)`));
     log(dim(`  opt-out: --force 플래그로 dedup 우회 가능`));
     return;
   }
 
   if (sub === 'audit') {
-    const audit = _runIdempotencyAudit(root);
+    const autoFix = has('--auto-fix');
+    const fixes = autoFix ? _autoFixIdempotency(root) : [];
+    const audit = _runIdempotencyAudit(root);  // auto-fix 후 상태 반영
+    if (autoFix) audit.autoFixed = fixes;
     if (has('--json')) { log(JSON.stringify(audit, null, 2)); return; }
     log(cyan(`# leerness idempotency audit (1.9.212)`));
     log(`  audited at: ${audit.auditedAt}`);
@@ -5482,6 +5546,19 @@ function idempotencyCmd(root, sub) {
         if (v.fix) log(dim(`     fix: ${v.fix}`));
       });
     }
+    if (autoFix) {
+      log('');
+      if (fixes.length) {
+        log(grn(`## 🔧 auto-fix 적용 (${fixes.length})`));
+        fixes.forEach(f => {
+          if (f.kind === 'task-duplicate-request') log(`  - [tasks] 완전중복 ${f.removedExact || 0}행 제거 · 동일텍스트 ${f.droppedSameText || 0}건 dropped 처리`);
+          else if (f.kind === 'user-request-duplicate') log(`  - [user-requests] open 중복 ${f.count || 0}건 dropped 처리`);
+          else log(dim(`  - [${f.kind}] ${f.action}${f.detail ? ' — ' + f.detail : ''}`));
+        });
+      } else {
+        log(dim('  🔧 auto-fix: 적용할 중복 없음 (이미 정합)'));
+      }
+    }
     return;
   }
 
@@ -5980,10 +6057,17 @@ function readProgressRows(root) {
   }
   return rows;
 }
+// 1.9.293: progress-tracker 정식 헤더 (frontmatter + 표 헤더 + 분리자). coreFiles 와 단일 출처.
+function _canonicalProgressHeader() {
+  return fm('progress-tracker', ['세션 시작', '세션 종료', '사용자 요청 상태 확인'], ['작업 상태 변경', '검증 결과 추가', '사용자 요청 드랍'],
+    `# Progress Tracker\n\nStatus values: requested, planned, in-progress, waiting, on-hold, blocked, incomplete, done, dropped\n\n| ID | Status | Request | Evidence | Next Action | Updated |\n|---|---|---|---|---|---|\n`).trimEnd();
+}
 function progressHeader(root) {
   const text = exists(progressPath(root)) ? read(progressPath(root)) : '';
   const idx = text.indexOf('|---|');
-  if (idx < 0) return text.trim();
+  // 1.9.293 (근본 버그 fix): 분리자 없음(손상/헤더유실) 시 전체 텍스트 반환은 writeProgressRows 가 행을 복제 →
+  //   세션마다 중복 누적의 원인이었음. 정식 헤더를 재구성해 반환 → 다음 write 시 자동 복구.
+  if (idx < 0) return _canonicalProgressHeader();
   return text.slice(0, text.indexOf('\n', idx)).trimEnd();
 }
 function writeProgressRows(root, header, rows) {
@@ -15493,6 +15577,20 @@ function driftCheckCmd(root, opts = {}) {
       log(`⚠ delivered auto-apply 오류 (1.9.225): ${e.message}`);
     }
   }
+  // 1.9.293: drift check --auto-fix 에 idempotency task/user-request 중복 자동 정리 통합
+  //   누적 중복 task/요청이 idempotency 위반(medium)을 가중 → drift/handoff 노이즈. 안전: 완전중복 행 제거 + 동일텍스트 dropped 보존(id 유지).
+  if (autoFix) {
+    try {
+      const idemFixes = _autoFixIdempotency(root);
+      const totalFixed = idemFixes.reduce((n, f) => n + (f.removedExact || 0) + (f.droppedSameText || 0) + (f.count || 0), 0);
+      if (totalFixed > 0) {
+        log('');
+        log(`🔁 --auto-fix 활성 (1.9.293) — idempotency 중복 ${totalFixed}건 자동 정리 (task/user-request dedup)`);
+      }
+    } catch (e) {
+      log(`⚠ idempotency auto-fix 오류 (1.9.293): ${e.message}`);
+    }
+  }
   // 1.9.236: drift check --auto-fix 에 release cleanup 통합 (1.9.235 회수)
   //   누적된 50개+ release/* branches → abnormal-shutdown release-branch-pending 신호 가중
   //   안전: keep 10 (최근 10개 유지), merged 만 삭제 (1.9.235 안전 가드)
@@ -17715,102 +17813,8 @@ function runsShowCmd(root, id) {
   if (!exists(fp)) return fail(`run 없음: ${id}`);
   log(read(fp));
 }
-// 1.9.155: provider 별 추천 모델 카탈로그 — REPL :models 명령에서 노출 (실제 가용성은 사용자 CLI 가 결정)
-// 1.9.170: provider × 실제 모델 catalog 확장 (Tab cycle 지원 — 사용자 명시 요청)
-//   각 provider 의 최신 실제 모델 ID 를 반영. Tab/Shift+Tab 키로 cycle.
-const _PROVIDER_MODEL_CATALOG = {
-  claude: [
-    { id: 'claude-opus-4-7', note: '최신 1M context (Anthropic Opus 4.7)' },
-    { id: 'claude-opus-4-5', note: '안정 Opus 4.5' },
-    { id: 'claude-sonnet-4-7', note: '균형형 — Sonnet 4.7 (속도/품질)' },
-    { id: 'claude-sonnet-4-5', note: 'Sonnet 4.5 안정' },
-    { id: 'claude-haiku-4-5', note: '빠름 — Haiku 4.5' }
-  ],
-  codex: [
-    { id: 'gpt-5.5', note: 'OpenAI 최신 추론 모델' },
-    { id: 'gpt-5.4', note: 'OpenAI 안정 (이전 세대)' },
-    { id: 'gpt-5', note: 'OpenAI gpt-5 (base)' },
-    { id: 'gpt-5-codex', note: '코드 특화 (Codex)' },
-    { id: 'o4-mini', note: '빠른 reasoning' }
-  ],
-  agy: [
-    { id: 'antigravity-pro', note: 'Antigravity 최고급 (1M+ context)' },
-    { id: 'antigravity-flash', note: '빠른 응답' },
-    { id: 'antigravity-experimental', note: '실험적 (사용 가능 시)' }
-  ],
-  grok: [
-    { id: 'grok-beta', note: 'xAI 최신 (1.9.268 provider 승격)' },
-    { id: 'grok-2', note: 'xAI Grok 2' },
-    { id: 'grok-2-mini', note: '빠른 응답' }
-  ],
-  // 1.9.277: 신규 provider 4종 모델 (provider-agnostic 인 도구는 default + 설정 안내)
-  opencode: [
-    { id: 'default', note: 'opencode 설정 모델 (opencode auth/models 로 provider별 지정)' },
-    { id: 'anthropic/claude-sonnet', note: 'Anthropic 경유' },
-    { id: 'openai/gpt-5', note: 'OpenAI 경유' }
-  ],
-  qwen: [
-    { id: 'qwen3-coder-plus', note: '코드 특화 최신' },
-    { id: 'qwen-max', note: '최고 성능' },
-    { id: 'qwen-plus', note: '균형' },
-    { id: 'qwen-turbo', note: '빠름' }
-  ],
-  aider: [
-    { id: 'sonnet', note: 'Anthropic Sonnet (aider --model)' },
-    { id: 'gpt-5', note: 'OpenAI' },
-    { id: 'deepseek', note: 'DeepSeek (가성비)' },
-    { id: 'o1-mini', note: '빠른 reasoning' }
-  ],
-  goose: [
-    { id: 'default', note: 'goose configure 로 설정한 provider/model' },
-    { id: 'claude-sonnet', note: 'Anthropic 경유' },
-    { id: 'gpt-5', note: 'OpenAI 경유' }
-  ],
-  copilot: [
-    { id: 'default', note: 'gh copilot 기본 (모델 선택 불가)' }
-  ],
-  ollama: [
-    { id: 'llama3', note: 'Meta — :models 로 실시간 조회 권장' },
-    { id: 'qwen2.5-coder', note: 'Alibaba — 코드 특화' },
-    { id: 'gpt-oss', note: 'OpenAI 오픈소스' },
-    { id: 'deepseek-coder-v2', note: 'DeepSeek 코드 모델' }
-  ]
-};
-
-// 1.9.170: provider cycle 순서 (Tab) — 빌트인 6종(1.9.268 grok 추가). user provider는 동적으로 뒤에 추가.
-const _PROVIDER_CYCLE_ORDER = ['ollama', 'claude', 'codex', 'agy', 'grok', 'opencode', 'qwen', 'aider', 'goose', 'copilot'];
-
-// 1.9.148: planner/reviewer/actor 역할 시스템 프롬프트 (Gemini 권고 — 자기-승인 편향 방지)
-const _AGENT_ROLE_PROMPTS = {
-  planner: '역할: planner. task를 step 3-6개로 분해, 각 step의 입출력/검증 방법 명시. 코드 작성 금지, 계획만.',
-  reviewer: '역할: reviewer. planner 의 계획 또는 actor 의 결과를 비판적으로 검토. 누락된 검증, 잠재 cascade, 오류 가능성 지적. 동의/수정 결론 명시.',
-  actor: '역할: actor. 계획에 따라 정확한 명령/코드만 실행. evidence(파일 경로 + 테스트 결과) 함께 기록. 새 계획 생성 금지.'
-};
-// ===== 1.9.270: Agent Roles — 모델별 역할 부여 (사용자 명시) =====
-//   여러 AI 에이전트 활성 시 역할(코딩/검수/지휘/디자인/디버그/설계/분배)을 provider+model 에 매핑.
-//   사용자 설정: .harness/agent-roles.json { schemaVersion, roles: { <role>: { provider, model, persona } } }
-//   dispatch --role <role> → 역할 기반 provider+model 라우팅. roles suggest → 활성 에이전트 기반 최적 배치 판단.
-//   방향성 판단(사용자 요청): 모델별 강점이 분명하고(추론/코드/멀티모달) 작업이 분해 가능할 때, 역할 특화는
-//   품질·정확도를 올림 — 강추론 모델의 독립 검수는 자기승인 편향을 차단, 코드 특화 모델은 구현 정확도↑.
-//   단 조율 오버헤드 < 이득이어야 하므로 opt-in + verify(비활성 provider 배정 경고)로 오설정을 방지.
-const ROLE_CATALOG = {
-  commander:  { ko: '지휘관', desc: '전체 계획 수립·작업 분해·최종 의사결정', prefer: ['claude', 'codex', 'grok'], modelKind: 'top',  why: '최강 추론 모델이 전체 맥락을 쥐고 분해/결정 → 일관성↑' },
-  reviewer:   { ko: '검수자', desc: '구현 결과 비판적 검수·버그/누락 적발',   prefer: ['claude', 'codex', 'grok'], modelKind: 'top',  why: '독립 강추론 모델의 적대적 검수가 자기승인 편향 차단 → 정확도↑' },
-  coder:      { ko: '코딩 담당', desc: '구현·패치·리팩터',                   prefer: ['codex', 'agy', 'claude', 'grok'], modelKind: 'code', why: '코드 특화 모델이 구현 정확도/속도↑' },
-  architect:  { ko: '설계 담당', desc: '아키텍처·데이터 모델·인터페이스 설계', prefer: ['codex', 'claude'],         modelKind: 'top',  why: '깊은 코드 추론 모델이 설계 트레이드오프 분석' },
-  designer:   { ko: '디자인 담당', desc: 'UI/UX·시각 디자인·레이아웃',        prefer: ['agy', 'claude', 'grok'],   modelKind: 'top',  why: '멀티모달/시각 역량 모델이 디자인 산출물↑' },
-  debugger:   { ko: '디버그 담당', desc: '버그 진단·근본원인·재현',          prefer: ['codex', 'claude', 'grok'], modelKind: 'top',  why: '깊은 추론 모델의 가설-검증이 디버깅 효율↑' },
-  dispatcher: { ko: '하위 분배 담당', desc: '서브에이전트 업무 분배·병렬 조율', prefer: ['claude', 'grok', 'codex'], modelKind: 'fast', why: '빠른 응답 모델이 분배 오버헤드↓' }
-};
-const _ROLE_ALIASES = {
-  '코딩': 'coder', '코더': 'coder', '코딩담당': 'coder',
-  '검수': 'reviewer', '검수자': 'reviewer', '리뷰': 'reviewer', '리뷰어': 'reviewer',
-  '지휘': 'commander', '지휘관': 'commander', '사령관': 'commander',
-  '디자인': 'designer', '디자인담당': 'designer',
-  '디버그': 'debugger', '디버거': 'debugger', '디버깅': 'debugger',
-  '설계': 'architect', '설계담당': 'architect', '아키텍트': 'architect',
-  '분배': 'dispatcher', '분배담당': 'dispatcher', '오케스트레이터': 'dispatcher'
-};
+// 1.9.294 (UR-0025 3단계): 역할/모델 카탈로그(_PROVIDER_MODEL_CATALOG + _AGENT_ROLE_PROMPTS + ROLE_CATALOG + _ROLE_ALIASES) 데이터 모듈 분리 (비파괴, require-based).
+const { _PROVIDER_MODEL_CATALOG, _AGENT_ROLE_PROMPTS, ROLE_CATALOG, _ROLE_ALIASES } = require('../lib/role-catalog');
 function _normalizeRole(name) {
   const raw = String(name || '').trim();
   if (_ROLE_ALIASES[raw]) return _ROLE_ALIASES[raw];

package/lib/role-catalog.js

@@ -0,0 +1,103 @@
+// lib/role-catalog.js — 역할/모델 레지스트리 (순수 데이터, 부작용 0)
+// 1.9.294 (UR-0025 3단계): bin/harness.js 에서 비파괴 분리. selftest(ROLE_CATALOG 7종 + _normalizeRole + _pickModel)가 동작 검증.
+// 런타임 변형 없음 — _normalizeRole/_pickModel/_AGENT_ROLE_PROMPTS 소비처 모두 읽기 전용.
+'use strict';
+
+// 1.9.155: provider 별 추천 모델 카탈로그 — REPL :models 명령에서 노출 (실제 가용성은 사용자 CLI 가 결정)
+// 1.9.170: provider × 실제 모델 catalog 확장 (Tab cycle 지원 — 사용자 명시 요청)
+//   각 provider 의 최신 실제 모델 ID 를 반영. Tab/Shift+Tab 키로 cycle.
+const _PROVIDER_MODEL_CATALOG = {
+  claude: [
+    { id: 'claude-opus-4-7', note: '최신 1M context (Anthropic Opus 4.7)' },
+    { id: 'claude-opus-4-5', note: '안정 Opus 4.5' },
+    { id: 'claude-sonnet-4-7', note: '균형형 — Sonnet 4.7 (속도/품질)' },
+    { id: 'claude-sonnet-4-5', note: 'Sonnet 4.5 안정' },
+    { id: 'claude-haiku-4-5', note: '빠름 — Haiku 4.5' }
+  ],
+  codex: [
+    { id: 'gpt-5.5', note: 'OpenAI 최신 추론 모델' },
+    { id: 'gpt-5.4', note: 'OpenAI 안정 (이전 세대)' },
+    { id: 'gpt-5', note: 'OpenAI gpt-5 (base)' },
+    { id: 'gpt-5-codex', note: '코드 특화 (Codex)' },
+    { id: 'o4-mini', note: '빠른 reasoning' }
+  ],
+  agy: [
+    { id: 'antigravity-pro', note: 'Antigravity 최고급 (1M+ context)' },
+    { id: 'antigravity-flash', note: '빠른 응답' },
+    { id: 'antigravity-experimental', note: '실험적 (사용 가능 시)' }
+  ],
+  grok: [
+    { id: 'grok-beta', note: 'xAI 최신 (1.9.268 provider 승격)' },
+    { id: 'grok-2', note: 'xAI Grok 2' },
+    { id: 'grok-2-mini', note: '빠른 응답' }
+  ],
+  // 1.9.277: 신규 provider 4종 모델 (provider-agnostic 인 도구는 default + 설정 안내)
+  opencode: [
+    { id: 'default', note: 'opencode 설정 모델 (opencode auth/models 로 provider별 지정)' },
+    { id: 'anthropic/claude-sonnet', note: 'Anthropic 경유' },
+    { id: 'openai/gpt-5', note: 'OpenAI 경유' }
+  ],
+  qwen: [
+    { id: 'qwen3-coder-plus', note: '코드 특화 최신' },
+    { id: 'qwen-max', note: '최고 성능' },
+    { id: 'qwen-plus', note: '균형' },
+    { id: 'qwen-turbo', note: '빠름' }
+  ],
+  aider: [
+    { id: 'sonnet', note: 'Anthropic Sonnet (aider --model)' },
+    { id: 'gpt-5', note: 'OpenAI' },
+    { id: 'deepseek', note: 'DeepSeek (가성비)' },
+    { id: 'o1-mini', note: '빠른 reasoning' }
+  ],
+  goose: [
+    { id: 'default', note: 'goose configure 로 설정한 provider/model' },
+    { id: 'claude-sonnet', note: 'Anthropic 경유' },
+    { id: 'gpt-5', note: 'OpenAI 경유' }
+  ],
+  copilot: [
+    { id: 'default', note: 'gh copilot 기본 (모델 선택 불가)' }
+  ],
+  ollama: [
+    { id: 'llama3', note: 'Meta — :models 로 실시간 조회 권장' },
+    { id: 'qwen2.5-coder', note: 'Alibaba — 코드 특화' },
+    { id: 'gpt-oss', note: 'OpenAI 오픈소스' },
+    { id: 'deepseek-coder-v2', note: 'DeepSeek 코드 모델' }
+  ]
+};
+
+// 1.9.170: provider cycle 순서 (Tab) — 빌트인 6종(1.9.268 grok 추가). user provider는 동적으로 뒤에 추가.
+const _PROVIDER_CYCLE_ORDER = ['ollama', 'claude', 'codex', 'agy', 'grok', 'opencode', 'qwen', 'aider', 'goose', 'copilot'];
+
+// 1.9.148: planner/reviewer/actor 역할 시스템 프롬프트 (Gemini 권고 — 자기-승인 편향 방지)
+const _AGENT_ROLE_PROMPTS = {
+  planner: '역할: planner. task를 step 3-6개로 분해, 각 step의 입출력/검증 방법 명시. 코드 작성 금지, 계획만.',
+  reviewer: '역할: reviewer. planner 의 계획 또는 actor 의 결과를 비판적으로 검토. 누락된 검증, 잠재 cascade, 오류 가능성 지적. 동의/수정 결론 명시.',
+  actor: '역할: actor. 계획에 따라 정확한 명령/코드만 실행. evidence(파일 경로 + 테스트 결과) 함께 기록. 새 계획 생성 금지.'
+};
+// ===== 1.9.270: Agent Roles — 모델별 역할 부여 (사용자 명시) =====
+//   여러 AI 에이전트 활성 시 역할(코딩/검수/지휘/디자인/디버그/설계/분배)을 provider+model 에 매핑.
+//   사용자 설정: .harness/agent-roles.json { schemaVersion, roles: { <role>: { provider, model, persona } } }
+//   dispatch --role <role> → 역할 기반 provider+model 라우팅. roles suggest → 활성 에이전트 기반 최적 배치 판단.
+//   방향성 판단(사용자 요청): 모델별 강점이 분명하고(추론/코드/멀티모달) 작업이 분해 가능할 때, 역할 특화는
+//   품질·정확도를 올림 — 강추론 모델의 독립 검수는 자기승인 편향을 차단, 코드 특화 모델은 구현 정확도↑.
+//   단 조율 오버헤드 < 이득이어야 하므로 opt-in + verify(비활성 provider 배정 경고)로 오설정을 방지.
+const ROLE_CATALOG = {
+  commander:  { ko: '지휘관', desc: '전체 계획 수립·작업 분해·최종 의사결정', prefer: ['claude', 'codex', 'grok'], modelKind: 'top',  why: '최강 추론 모델이 전체 맥락을 쥐고 분해/결정 → 일관성↑' },
+  reviewer:   { ko: '검수자', desc: '구현 결과 비판적 검수·버그/누락 적발',   prefer: ['claude', 'codex', 'grok'], modelKind: 'top',  why: '독립 강추론 모델의 적대적 검수가 자기승인 편향 차단 → 정확도↑' },
+  coder:      { ko: '코딩 담당', desc: '구현·패치·리팩터',                   prefer: ['codex', 'agy', 'claude', 'grok'], modelKind: 'code', why: '코드 특화 모델이 구현 정확도/속도↑' },
+  architect:  { ko: '설계 담당', desc: '아키텍처·데이터 모델·인터페이스 설계', prefer: ['codex', 'claude'],         modelKind: 'top',  why: '깊은 코드 추론 모델이 설계 트레이드오프 분석' },
+  designer:   { ko: '디자인 담당', desc: 'UI/UX·시각 디자인·레이아웃',        prefer: ['agy', 'claude', 'grok'],   modelKind: 'top',  why: '멀티모달/시각 역량 모델이 디자인 산출물↑' },
+  debugger:   { ko: '디버그 담당', desc: '버그 진단·근본원인·재현',          prefer: ['codex', 'claude', 'grok'], modelKind: 'top',  why: '깊은 추론 모델의 가설-검증이 디버깅 효율↑' },
+  dispatcher: { ko: '하위 분배 담당', desc: '서브에이전트 업무 분배·병렬 조율', prefer: ['claude', 'grok', 'codex'], modelKind: 'fast', why: '빠른 응답 모델이 분배 오버헤드↓' }
+};
+const _ROLE_ALIASES = {
+  '코딩': 'coder', '코더': 'coder', '코딩담당': 'coder',
+  '검수': 'reviewer', '검수자': 'reviewer', '리뷰': 'reviewer', '리뷰어': 'reviewer',
+  '지휘': 'commander', '지휘관': 'commander', '사령관': 'commander',
+  '디자인': 'designer', '디자인담당': 'designer',
+  '디버그': 'debugger', '디버거': 'debugger', '디버깅': 'debugger',
+  '설계': 'architect', '설계담당': 'architect', '아키텍트': 'architect',
+  '분배': 'dispatcher', '분배담당': 'dispatcher', '오케스트레이터': 'dispatcher'
+};
+
+module.exports = { _PROVIDER_MODEL_CATALOG, _AGENT_ROLE_PROMPTS, ROLE_CATALOG, _ROLE_ALIASES };

package/package.json

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

package/scripts/e2e.js

@@ -3154,5 +3154,53 @@ total++;
   if (!ok) failed++;
 }
 
+// 1.9.293 회귀: idempotency audit --auto-fix + progressHeader 복제버그 fix
+total++;
+{
+  let ok = false;
+  try {
+    const idemDir = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-idem-'));
+    cp.spawnSync(process.execPath, [CLI, 'init', idemDir, '--yes', '--language', 'ko', '--skills', 'recommended'], { encoding: 'utf8', timeout: 30000 });
+    const pt = path.join(idemDir, '.harness', 'progress-tracker.md');
+    // (1) 헤더 유실 + 완전중복 + 동일텍스트 중복 시뮬레이션 (과거 손상 패턴)
+    const dupRow = '| T-7001 | in-progress | 중복작업ABC | - | - | 2026-06-04 |';
+    const sameText = '| T-7002 | in-progress | 중복작업ABC | - | - | 2026-06-04 |';
+    fs.writeFileSync(pt, [dupRow, dupRow, dupRow, sameText].join('\n') + '\n', 'utf8');  // 헤더 없음(손상)
+    // (2) auto-fix
+    const r = cp.spawnSync(process.execPath, [CLI, 'idempotency', 'audit', '--path', idemDir, '--auto-fix'], { encoding: 'utf8', timeout: 20000 });
+    const after = fs.readFileSync(pt, 'utf8');
+    const headerRestored = /\|---\|/.test(after) && /leernessRole: progress-tracker/.test(after);  // 헤더 재구성
+    const exactCollapsed = (after.match(/\| T-7001 \|/g) || []).length === 1;  // 완전중복 3→1
+    // (3) 재검사 clean
+    const r2 = cp.spawnSync(process.execPath, [CLI, 'idempotency', 'audit', '--path', idemDir, '--json'], { encoding: 'utf8', timeout: 20000 });
+    const audit = JSON.parse(r2.stdout);
+    const taskDupGone = !audit.violations.some(v => v.kind === 'task-duplicate-request');
+    ok = r.status === 0 && headerRestored && exactCollapsed && taskDupGone;
+  } catch {}
+  console.log(ok ? '✓ B(1.9.293) idempotency --auto-fix: 헤더 재구성 + 완전중복 제거 + dedup clean (복제버그 fix)' : '✗ idempotency auto-fix 실패');
+  if (!ok) failed++;
+}
+
+// 1.9.294 회귀 (UR-0025 3단계): lib/role-catalog.js 모듈 분리 — 단일출처 + 부작용 0
+total++;
+{
+  let ok = false;
+  try {
+    const reg = require(path.resolve(__dirname, '..', 'lib', 'role-catalog.js'));
+    const dataOk = reg.ROLE_CATALOG && Object.keys(reg.ROLE_CATALOG).length === 7 &&
+      reg._PROVIDER_MODEL_CATALOG && Object.keys(reg._PROVIDER_MODEL_CATALOG).length === 10 &&
+      reg._ROLE_ALIASES && Object.keys(reg._ROLE_ALIASES).length >= 14 &&
+      reg._AGENT_ROLE_PROMPTS && reg._AGENT_ROLE_PROMPTS.actor;
+    const harnessSrc = fs.readFileSync(path.resolve(__dirname, '..', 'bin', 'harness.js'), 'utf8');
+    const movedOut = !/const ROLE_CATALOG = \{/.test(harnessSrc) && /require\('\.\.\/lib\/role-catalog'\)/.test(harnessSrc);
+    // roles 명령이 여전히 동작 (모듈 require 후) — 회귀 방지
+    const rr = cp.spawnSync(process.execPath, [CLI, 'roles', 'list', '--path', tmp, '--json'], { cwd: tmp, encoding: 'utf8', timeout: 20000 });
+    const rolesOk = rr.status === 0;
+    ok = dataOk && movedOut && rolesOk;
+  } catch {}
+  console.log(ok ? '✓ B(1.9.294) lib/role-catalog 모듈 분리: 단일출처 + 인라인 제거 + roles 동작 (UR-0025)' : '✗ role-catalog 모듈 분리 실패');
+  if (!ok) failed++;
+}
+
 console.log(`\nE2E result: ${total - failed}/${total} passed · ${((Date.now() - _e2eStart) / 1000).toFixed(0)}s`);
 if (failed > 0) process.exit(1);