leerness 1.9.210 → 1.9.212

package/CHANGELOG.md

@@ -1,5 +1,98 @@
 # Changelog
 
+## 1.9.212 — 2026-05-22
+
+**🔁 멱등성 감사 + ruleAdd/taskAdd dedup 보강 (사용자 명시).**
+
+### 사용자 명시
+> *"다양한 부분에서 멱등성이 필요한 부분이 고려되고있는지 확인해주고 올바른 방향인지 판단해줘"*
+
+### 1. ruleAdd dedup (line 10229+)
+- 같은 description + trigger + active 룰 이미 존재 시 skip
+- `--force` 플래그로 우회 가능
+- 출력: `rule exists (skip): R-XXXX [trigger] description (--force 로 덮어쓰기)`
+
+### 2. taskAdd dedup (line 3709+)
+- progress-tracker.md 의 markdown table 파싱 (`| T-XXXX | status | request | … |`)
+- 같은 request 텍스트 + 활성 상태(`requested`/`in-progress`) 이미 존재 시 skip
+- `--force` 플래그로 우회 가능
+
+### 3. `_runIdempotencyAudit(root)` — 4영역 점검
+- **rules**: 같은 description + trigger + active 중복 (severity: medium)
+- **tasks**: 같은 request 텍스트 + 활성 상태 중복 (severity: medium)
+- **user-requests**: 1.9.207 자체 dedup 검증 (severity: low)
+- **wakeups**: 1.9.205 동일 expectedFireAt 검증 (severity: high)
+
+### 4. `leerness idempotency audit` CLI
+- 위반 분류 (high/medium/low)
+- 영역별 verified / violations 보고
+- `--json` 옵션
+
+### 5. 누적 회귀 (1.9.200~211) — 모두 유지
+
+### 6. stress-v157 — 17/17 PASS
+- 1.9.212 (8) + 성능 (2) + 누적 회귀 (7)
+- 격리 tmp dir에서 ruleAdd 2회 → 1건만 등록 검증
+- `--force` 우회 검증
+- 수동 중복 rule 삽입 → audit이 정확히 1건 violation 탐지
+
+### 7. 자동 release (74 라운드 main-push streak · 35 라운드 npm publish streak)
+
+---
+
+## 1.9.211 — 2026-05-22
+
+**📂 `.harness` → `.leerness` opt-in 마이그레이션 + AI 참조 가이드 (사용자 명시).**
+
+### 사용자 명시
+> *"leerness설치시 생성되는 .harness를 .leerness으로 변경할 수 있을까 / 기존 버전에서도 마이그레이션시 AI가 참조할 수 있기도하면 어떨까"*
+
+### 1. workspace-dir 헬퍼 (default-safe opt-in)
+- `_workspaceDirName(root)` — env `LEERNESS_WORKSPACE_DIR` > `.leerness/MIGRATED_FROM_HARNESS` 마커 > default `.harness`
+- `_workspaceDirAbs(root)` — 절대 경로
+- 기본 동작: **`.harness` 유지** (226+ path reference 안정) — breaking change 0
+
+### 2. 마이그레이션 시스템
+- `_migrateWorkspaceDir(root, opts)` — `.harness` 전체 재귀 copy → `.leerness`
+  · `--dry-run` 지원
+  · `--force` (기존 dst 덮어쓰기)
+  · skip / errors / copiedFiles 분류 보고
+- 마이그레이션 결과물:
+  · `.leerness/MIGRATED_FROM_HARNESS` 마커
+  · `.leerness/WHERE_TO_FIND.md` AI 참조 가이드 (자동 생성)
+  · `.harness/MIGRATED_TO_LEERNESS.md` redirect 안내 (backward compat 유지)
+
+### 3. AI 참조 가이드 (`_buildWorkspaceReferenceGuide`)
+- 디렉토리 구조 시각화 (핵심 파일 25개)
+- "자주 묻는 위치" 매핑 표 (현재 task / 영구 룰 / pre-wake / 미답 요청 / 다음 라운드 plan / API 제약 / wakeup 권장)
+- 마이그레이션 안내 (3가지 상태 분기)
+- 1.9.207~210 신규 메타파일 위치 명시
+
+### 4. `leerness workspace-dir <get|guide>` CLI
+- `get` — 현재 디렉토리 + .harness/.leerness 존재 여부 + 마이그레이션 상태
+- `guide` — AI 참조 가이드 출력
+
+### 5. `leerness migrate-workspace-dir` CLI
+- `--dry-run` / `--force` 지원
+- copied / skipped / errors 분류
+- 자동 마커 + 가이드 + redirect 생성
+
+### 6. 누적 회귀 (1.9.200~210) — 모두 유지
+
+### 7. stress-v156 — 19/19 PASS
+- 1.9.211 (10) + 성능 (2) + 누적 회귀 (7)
+- 격리 tmp dir 전체 사이클 (default → dry-run → migrate → auto-detect → env override)
+- AI 가이드 키 섹션 검증
+- 성능: --version cold start avg 452ms · MCP 54 도구 445ms
+
+### 8. 자동 release (73 라운드 main-push streak · 34 라운드 npm publish streak)
+
+### 9. 후속 라운드 로드맵
+- 이번 라운드는 **opt-in 헬퍼 + CLI**만 추가 (breaking change 0)
+- 후속에서 226+ path reference 를 `_workspaceDirAbs(root)` 로 점진 전환
+
+---
+
 ## 1.9.210 — 2026-05-22
 
 **⚡ adaptive wakeup interval — 사용자 활동 기반 자동 조절 (사용자 명시).**

package/README.md

@@ -2,7 +2,7 @@
 
 > **AI 코딩 에이전트의 거짓 완료·중복·망각·충돌을 막아주는 검수·기억·협업 CLI 하네스.**
 
-[![npm](https://img.shields.io/badge/npm-leerness-blue)](https://www.npmjs.com/package/leerness) [![version](https://img.shields.io/badge/version-1.9.210-green)]() [![tests](https://img.shields.io/badge/e2e-217%2F217-success)]() [![stress](https://img.shields.io/badge/stress--v155-18%2F18-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-54-brightgreen)]() [![rounds](https://img.shields.io/badge/autonomous--rounds-140-blueviolet)]() [![main-push](https://img.shields.io/badge/release--main--push-72_rounds-success)]() [![goal-matrix](https://img.shields.io/badge/목적_매트릭스-98%2F100_(5축)-brightgreen)]() [![adaptive](https://img.shields.io/badge/wakeup-adaptive_10~45min-success)]() [![perf](https://img.shields.io/badge/cold_start-440ms-success)]() [![install](https://img.shields.io/badge/npm_i_leerness-즉시_사용_가능-success)]() [![sandbox](https://img.shields.io/badge/runCommandSafe-cwd_jail%2Benv_scrub-success)]() [![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.212-green)]() [![tests](https://img.shields.io/badge/e2e-217%2F217-success)]() [![stress](https://img.shields.io/badge/stress--v157-17%2F17-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-54-brightgreen)]() [![rounds](https://img.shields.io/badge/autonomous--rounds-142-blueviolet)]() [![main-push](https://img.shields.io/badge/release--main--push-74_rounds-success)]() [![goal-matrix](https://img.shields.io/badge/목적_매트릭스-98%2F100_(5축)-brightgreen)]() [![idempotency](https://img.shields.io/badge/idempotency-audit_4영역-success)]() [![perf](https://img.shields.io/badge/cold_start-395ms-success)]() [![install](https://img.shields.io/badge/npm_i_leerness-즉시_사용_가능-success)]() [![sandbox](https://img.shields.io/badge/runCommandSafe-cwd_jail%2Benv_scrub-success)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
 
 ```
   ╔══════════════════════════════════════════════════════════════╗
@@ -12,9 +12,9 @@
   ║  ██║     ██╔══╝  ██╔══╝  ██╔══██╗██║╚██╗██║██╔══╝  ╚════██║  ║
   ║  ███████╗███████╗███████╗██║  ██║██║ ╚████║███████╗███████║  ║
   ║  ╚══════╝╚══════╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝╚══════╝╚══════╝  ║
-  ║  v1.9.210  AI Agent Reliability Harness + Sandbox            ║
+  ║  v1.9.212  AI Agent Reliability Harness + Sandbox            ║
   ║  verify · remember · orchestrate · audit · sandbox · drift   ║
-  ║  ⚡ adaptive wakeup 10~45min (활동 기반 자동) (사용자 명시)          ║
+  ║  🔁 멱등성 감사 + ruleAdd/taskAdd dedup (사용자 명시)               ║
   ╚══════════════════════════════════════════════════════════════╝
 ```
 

package/bin/harness.js

@@ -7,7 +7,7 @@ const cp = require('child_process');
 const os = require('os');  // 1.9.178: _publishToNpm 에서 os.tmpdir() 사용 (전역 import)
 const readline = require('readline');
 
-const VERSION = '1.9.210';
+const VERSION = '1.9.212';
 
 // 1.9.184: DEP0190 (child_process shell: true) deprecation warning 억제 (사용자 명시).
 //   leerness 는 cross-platform PATH resolution 을 위해 shell: true 를 의도적으로 사용 (claude.cmd / ollama.cmd 등 Windows .cmd 처리).
@@ -2364,6 +2364,168 @@ function _computeAdaptiveInterval(root) {
   };
 }
 
+// 1.9.211: .harness → .leerness rename + migration + AI 참조 가이드 (사용자 명시)
+//   "leerness설치시 생성되는 .harness를 .leerness으로 변경할 수 있을까 / 기존 버전에서도 마이그레이션시 AI가 참조할 수 있기도하면 어떨까"
+//   접근 방식: opt-in 마이그레이션 (breaking change 최소화)
+//   - default: .harness 유지 (226+ path reference 안정)
+//   - LEERNESS_WORKSPACE_DIR env 또는 .leerness/MARKER 존재 시 .leerness 사용
+//   - leerness migrate-workspace-dir CLI: .harness → .leerness copy + AI reference guide 생성
+//   - AI 참조 가이드: WHERE_TO_FIND.md (디렉토리 구조 + 파일별 역할 + 마이그레이션 history)
+function _workspaceDirName(root) {
+  // 1) env override
+  if (process.env.LEERNESS_WORKSPACE_DIR) {
+    const v = process.env.LEERNESS_WORKSPACE_DIR.trim();
+    if (v) return v;
+  }
+  // 2) .leerness 마이그레이션 마커 존재 시 .leerness 우선
+  try {
+    if (root && exists(path.join(root, '.leerness', 'MIGRATED_FROM_HARNESS'))) {
+      return '.leerness';
+    }
+  } catch {}
+  // 3) default
+  return '.harness';
+}
+function _workspaceDirAbs(root) {
+  return path.join(root, _workspaceDirName(root));
+}
+// .harness → .leerness 마이그레이션 (copy + reference guide 생성)
+function _migrateWorkspaceDir(root, opts = {}) {
+  const dryRun = opts.dryRun === true;
+  const srcDir = path.join(root, '.harness');
+  const dstDir = path.join(root, '.leerness');
+  const report = {
+    at: new Date().toISOString(),
+    version: VERSION,
+    src: srcDir,
+    dst: dstDir,
+    srcExists: exists(srcDir),
+    dstExists: exists(dstDir),
+    copiedFiles: [],
+    skippedFiles: [],
+    errors: [],
+    dryRun
+  };
+  if (!report.srcExists) {
+    report.errors.push('source .harness not found');
+    return report;
+  }
+  if (!dryRun) {
+    mkdirp(dstDir);
+  }
+  // 재귀 copy 헬퍼
+  function copyRec(rel) {
+    const srcAbs = path.join(srcDir, rel);
+    const dstAbs = path.join(dstDir, rel);
+    let stat;
+    try { stat = fs.statSync(srcAbs); } catch (e) { report.errors.push(`stat ${rel}: ${e.message}`); return; }
+    if (stat.isDirectory()) {
+      if (!dryRun) mkdirp(dstAbs);
+      let entries;
+      try { entries = fs.readdirSync(srcAbs); } catch (e) { report.errors.push(`readdir ${rel}: ${e.message}`); return; }
+      for (const e of entries) copyRec(path.join(rel, e));
+    } else if (stat.isFile()) {
+      // 기존 dst 파일이 있고 우리가 force가 아니면 skip
+      if (exists(dstAbs) && !opts.force) {
+        report.skippedFiles.push(rel);
+        return;
+      }
+      if (!dryRun) {
+        try {
+          fs.copyFileSync(srcAbs, dstAbs);
+          report.copiedFiles.push(rel);
+        } catch (e) {
+          report.errors.push(`copy ${rel}: ${e.message}`);
+        }
+      } else {
+        report.copiedFiles.push(rel);
+      }
+    }
+  }
+  copyRec('');
+  // 마이그레이션 마커 + AI 참조 가이드 작성
+  if (!dryRun) {
+    const marker = `Migrated from .harness at ${report.at} by leerness ${VERSION}\n`;
+    try { writeUtf8(path.join(dstDir, 'MIGRATED_FROM_HARNESS'), marker); } catch (e) { report.errors.push(`marker: ${e.message}`); }
+    const guide = _buildWorkspaceReferenceGuide(root, '.leerness');
+    try { writeUtf8(path.join(dstDir, 'WHERE_TO_FIND.md'), guide); } catch (e) { report.errors.push(`guide: ${e.message}`); }
+    // .harness 에도 redirect 안내 추가 (AI가 .harness 먼저 봐도 .leerness 로 가게)
+    try {
+      const redirect = `# .harness → .leerness migration (${report.at})\n\n` +
+        `이 워크스페이스는 \`.harness\` → \`.leerness\` 로 마이그레이션되었습니다 (leerness ${VERSION}).\n\n` +
+        `**AI 에이전트는 ${'.leerness/'} 디렉토리를 우선 참조하십시오.**\n\n` +
+        `- 신규 메타파일 위치: \`.leerness/\`\n` +
+        `- 참조 가이드: \`.leerness/WHERE_TO_FIND.md\`\n` +
+        `- 마이그레이션 마커: \`.leerness/MIGRATED_FROM_HARNESS\`\n\n` +
+        `\`.harness/\` 는 backward compatibility 를 위해 보존됩니다 (read-only 권장).\n`;
+      writeUtf8(path.join(srcDir, 'MIGRATED_TO_LEERNESS.md'), redirect);
+    } catch (e) { report.errors.push(`redirect: ${e.message}`); }
+  }
+  return report;
+}
+// AI 참조 가이드 빌더 — 워크스페이스 디렉토리 구조 + 파일별 역할 매핑
+function _buildWorkspaceReferenceGuide(root, dirName) {
+  const lines = [];
+  lines.push(`# Leerness Workspace Reference Guide`);
+  lines.push('');
+  lines.push(`> AI 에이전트가 leerness 워크스페이스에서 어떤 파일을 어디서 찾는지 안내합니다 (1.9.211).`);
+  lines.push('');
+  lines.push(`Generated: ${new Date().toISOString()} by leerness ${VERSION}`);
+  lines.push(`Workspace dir: \`${dirName}/\``);
+  lines.push('');
+  lines.push(`## 📁 디렉토리 구조 (핵심)`);
+  lines.push('');
+  lines.push('```');
+  lines.push(`${dirName}/`);
+  lines.push(`├── plan.md                    ← 무엇을 할 것인가 (사용자 메모리)`);
+  lines.push(`├── progress-tracker.md        ← 무엇을 했는가 (증거 포함, 사용자 메모리)`);
+  lines.push(`├── decisions.md               ← 왜 그렇게 했는가 (사용자 메모리)`);
+  lines.push(`├── session-handoff.md         ← 다음 세션 인계 (사용자 메모리)`);
+  lines.push(`├── lessons.md                 ← 과거 교훈 (자동 fuzzy 회수)`);
+  lines.push(`├── rules.md                   ← 자연어 룰 (매 세션 자동 노출, R-XXXX)`);
+  lines.push(`├── task-log.md                ← in-progress / dropped task 이력`);
+  lines.push(`├── reuse-map.md               ← 워크스페이스 capability 매핑`);
+  lines.push(`├── skill-suggestions.md       ← skill rolling history`);
+  lines.push(`├── feature-graph.md           ← 기능 의존 그래프 (F-XXXX)`);
+  lines.push(`├── manifest.json              ← 워크스페이스 메타`);
+  lines.push(`├── leerness-config.json       ← 비시크릿 LEERNESS_* 설정 (1.9.187, AI 가시)`);
+  lines.push(`├── user-requests.json         ← 사용자 명시 요청 누적 (1.9.207)`);
+  lines.push(`├── active-wakeups.json        ← ScheduleWakeup 상태 (1.9.205)`);
+  lines.push(`├── pre-wake-report.json       ← sleep 전 sub-agent audit (1.9.209)`);
+  lines.push(`├── wakeup-history.json        ← adaptive wakeup 이력 (1.9.210)`);
+  lines.push(`├── platform-constraints.json  ← API 제약 catalog (1.9.208)`);
+  lines.push(`├── auto-resume-plan.json      ← 다음 라운드 plan (1.9.203)`);
+  lines.push(`├── next-action-queue.json     ← 다음 next-action 큐 (1.9.201)`);
+  lines.push(`├── last-handoff.json          ← 마지막 handoff timestamp`);
+  lines.push(`├── environment.json           ← 환경 변동 추적 (1.9.145)`);
+  lines.push(`├── skills/                    ← 설치된 skill 디렉토리`);
+  lines.push(`└── templates/                 ← 워크스페이스 템플릿`);
+  lines.push('```');
+  lines.push('');
+  lines.push(`## 🧭 자주 묻는 위치`);
+  lines.push('');
+  lines.push(`| 찾는 것 | 위치 |`);
+  lines.push(`|---|---|`);
+  lines.push(`| 현재 진행 중인 task | \`${dirName}/progress-tracker.md\` (status: in-progress) |`);
+  lines.push(`| 사용자가 명시한 영구 룰 | \`${dirName}/rules.md\` (active R-XXXX) |`);
+  lines.push(`| 직전 sleep 전 audit 결과 | \`${dirName}/pre-wake-report.json\` (1.9.209) |`);
+  lines.push(`| 미답 사용자 요청 | \`${dirName}/user-requests.json\` (status: open) |`);
+  lines.push(`| 다음 라운드 권장 단계 | \`${dirName}/auto-resume-plan.json\` (1.9.203) |`);
+  lines.push(`| API 제약 catalog | \`${dirName}/platform-constraints.json\` (1.9.208) |`);
+  lines.push(`| 자동 wakeup 권장 간격 | \`${dirName}/wakeup-history.json\` (1.9.210) |`);
+  lines.push('');
+  lines.push(`## 🔄 마이그레이션 안내`);
+  lines.push('');
+  lines.push(`이 워크스페이스는 \`.harness\` → \`.leerness\` 로 마이그레이션되었을 수 있습니다.`);
+  lines.push(`- \`.leerness/MIGRATED_FROM_HARNESS\` 존재 → 마이그레이션 완료, \`.leerness\` 우선 사용`);
+  lines.push(`- \`.harness/MIGRATED_TO_LEERNESS.md\` 존재 → \`.leerness/\` 로 가야 함`);
+  lines.push(`- 양쪽 모두 없음 → 기본 \`.harness\` 사용 중`);
+  lines.push('');
+  lines.push(`AI 에이전트는 \`leerness handoff .\` 결과를 신뢰하십시오 — 자동으로 올바른 디렉토리를 사용합니다.`);
+  lines.push('');
+  return lines.join('\n');
+}
+
 // 1.9.203: 자동 라운드 plan 정리 — 사용자 명시
 //   "백그라운드에 다음 작업이 시작가능한 예상 시간 + 일어났을때 해야하는 일을 정리"
 //   라운드 마무리 시 .harness/auto-resume-plan.json 자동 저장 → 다음 wakeup 시 즉시 실행 가능
@@ -2875,6 +3037,286 @@ function wakeupIntervalCmd(root, sub, val) {
   process.exit(1);
 }
 
+// 1.9.211: leerness workspace-dir <get|guide> — 워크스페이스 디렉토리 정보 + AI 참조 가이드 (사용자 명시)
+function workspaceDirCmd(root, sub) {
+  root = absRoot(root);
+  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;
+  const dim = s => isTty ? `\x1b[2m${s}\x1b[0m` : s;
+
+  if (!sub || sub === 'get') {
+    const dirName = _workspaceDirName(root);
+    const dirAbs = _workspaceDirAbs(root);
+    const hasHarness = exists(path.join(root, '.harness'));
+    const hasLeerness = exists(path.join(root, '.leerness'));
+    const migrated = exists(path.join(root, '.leerness', 'MIGRATED_FROM_HARNESS'));
+    const result = { current: dirName, abs: dirAbs, hasHarness, hasLeerness, migrated };
+    if (has('--json')) { log(JSON.stringify(result, null, 2)); return; }
+    log(cyan(`# leerness workspace-dir (1.9.211)`));
+    log(`  현재 디렉토리: ${grn(dirName + '/')}`);
+    log(`  abs: ${dirAbs}`);
+    log(`  .harness 존재: ${hasHarness ? '✓' : '✗'}`);
+    log(`  .leerness 존재: ${hasLeerness ? '✓' : '✗'}`);
+    log(`  마이그레이션 완료: ${migrated ? '✓' : '✗'}`);
+    log('');
+    if (hasHarness && !hasLeerness) {
+      log(dim(`  → 마이그레이션: leerness migrate-workspace-dir`));
+    } else if (migrated) {
+      log(dim(`  → AI 참조 가이드: leerness workspace-dir guide`));
+    }
+    return;
+  }
+
+  if (sub === 'guide') {
+    const dirName = _workspaceDirName(root);
+    const guide = _buildWorkspaceReferenceGuide(root, dirName);
+    if (has('--json')) { log(JSON.stringify({ workspaceDir: dirName, guide }, null, 2)); return; }
+    log(guide);
+    return;
+  }
+
+  console.error(`Usage: leerness workspace-dir [get|guide]`);
+  process.exit(1);
+}
+
+// 1.9.211: leerness migrate-workspace-dir — .harness → .leerness 마이그레이션 (사용자 명시)
+function migrateWorkspaceDirCmd(root) {
+  root = absRoot(root);
+  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;
+  const yel = s => isTty ? `\x1b[33m${s}\x1b[0m` : s;
+  const red = s => isTty ? `\x1b[31m${s}\x1b[0m` : s;
+  const dim = s => isTty ? `\x1b[2m${s}\x1b[0m` : s;
+
+  const dryRun = has('--dry-run');
+  const force = has('--force');
+  const report = _migrateWorkspaceDir(root, { dryRun, force });
+
+  if (has('--json')) { log(JSON.stringify(report, null, 2)); return; }
+  log(cyan(`# leerness migrate-workspace-dir (1.9.211)${dryRun ? ' [DRY-RUN]' : ''}`));
+  log(`  src: ${report.src}  ${report.srcExists ? '✓' : red('✗ 없음')}`);
+  log(`  dst: ${report.dst}  ${report.dstExists ? yel('⚠ 이미 존재') : '(생성)'}`);
+  log('');
+  log(`  📊 copied: ${grn(report.copiedFiles.length)}, skipped: ${report.skippedFiles.length}, errors: ${report.errors.length}`);
+  if (report.copiedFiles.length > 0 && report.copiedFiles.length <= 30) {
+    log('');
+    log(`  복사된 파일:`);
+    report.copiedFiles.slice(0, 20).forEach(f => log(dim(`    + ${f}`)));
+    if (report.copiedFiles.length > 20) log(dim(`    ... +${report.copiedFiles.length - 20}건`));
+  } else if (report.copiedFiles.length > 30) {
+    log(dim(`    (${report.copiedFiles.length}개 — 상세는 --json)`));
+  }
+  if (report.skippedFiles.length > 0) {
+    log('');
+    log(yel(`  스킵된 파일 (이미 존재, --force 로 덮어쓰기 가능):`));
+    report.skippedFiles.slice(0, 5).forEach(f => log(dim(`    - ${f}`)));
+    if (report.skippedFiles.length > 5) log(dim(`    ... +${report.skippedFiles.length - 5}건`));
+  }
+  if (report.errors.length > 0) {
+    log('');
+    log(red(`  ⚠ 에러:`));
+    report.errors.forEach(e => log(red(`    - ${e}`)));
+  }
+  log('');
+  if (!dryRun && report.copiedFiles.length > 0) {
+    log(grn(`✓ 마이그레이션 완료 — .leerness/WHERE_TO_FIND.md + MIGRATED_FROM_HARNESS 마커 생성`));
+    log(dim(`  → 다음 handoff부터 .leerness 우선 사용`));
+    log(dim(`  → .harness/MIGRATED_TO_LEERNESS.md 안내 추가됨 (backward compat 보존)`));
+  } else if (dryRun) {
+    log(yel(`  (dry-run — 실제 변경 없음. 실행: leerness migrate-workspace-dir)`));
+  }
+}
+
+// 1.9.212: leerness idempotency <audit> — 멱등성 위반 탐지 + 권장 fix (사용자 명시)
+//   "다양한 부분에서 멱등성이 필요한 부분이 고려되고있는지 확인해주고 올바른 방향인지 판단"
+//   탐지 영역:
+//     1. rules.md — 같은 description + trigger + active 중복
+//     2. progress-tracker.md — 같은 request 텍스트 중복 (활성 상태)
+//     3. user-requests.json — 동일 텍스트 + open (1.9.207 자체 dedup 검증)
+//     4. active-wakeups.json — 동일 expectedFireAt 중복 (1.9.205 dedup 검증)
+//     5. next-action-queue.json — 동일 title 중복 (1.9.201 dedup 검증)
+function _runIdempotencyAudit(root) {
+  const audit = {
+    auditedAt: new Date().toISOString(),
+    auditVersion: VERSION,
+    violations: [],
+    verified: []
+  };
+  // 1) rules.md dup 검사
+  try {
+    const rules = readRules(root);
+    const active = rules.filter(r => r.status === 'active');
+    const seen = new Map();
+    for (const r of active) {
+      const key = `${r.trigger}::${r.rule}`;
+      if (seen.has(key)) {
+        audit.violations.push({
+          kind: 'rule-duplicate',
+          location: '.harness/rules.md',
+          detail: `중복 룰: ${r.id} == ${seen.get(key)} (${r.trigger}: ${r.rule.slice(0, 60)})`,
+          severity: 'medium',
+          fix: `leerness rule remove ${r.id}`
+        });
+      } else {
+        seen.set(key, r.id);
+      }
+    }
+    if (audit.violations.filter(v => v.kind === 'rule-duplicate').length === 0) {
+      audit.verified.push({ kind: 'rules', detail: `${active.length} active rules, 중복 0건` });
+    }
+  } catch (e) { audit.violations.push({ kind: 'audit-error', area: 'rules', detail: String(e.message || e), severity: 'low' }); }
+
+  // 2) progress-tracker.md 중복 request 검사
+  //    포맷: | T-XXXX | status | request | evidence | nextAction | date |
+  try {
+    const pt = path.join(root, '.harness', 'progress-tracker.md');
+    if (exists(pt)) {
+      const content = read(pt);
+      const lines = content.split(/\r?\n/);
+      const requests = new Map(); // text → { id, status, line }
+      for (let i = 0; i < lines.length; i++) {
+        if (!/^\|\s*T-\d{4,}\s*\|/.test(lines[i])) continue;
+        const cells = lines[i].split('|').slice(1, -1).map(s => s.trim());
+        if (cells.length < 3) continue;
+        const id = cells[0];
+        const status = (cells[1] || '').toLowerCase();
+        const text = cells[2];
+        if (text.length < 5) continue;
+        const isActive = !/^(done|dropped|blocked|completed)$/i.test(status);
+        if (!isActive) continue;
+        if (requests.has(text)) {
+          const prev = requests.get(text);
+          audit.violations.push({
+            kind: 'task-duplicate-request',
+            location: '.harness/progress-tracker.md',
+            detail: `중복 request: "${text.slice(0, 50)}…" (${prev.id} & ${id})`,
+            severity: 'medium',
+            fix: `중복 task 중 하나를 leerness task drop <id> 처리`
+          });
+        } else {
+          requests.set(text, { id, status, line: i + 1 });
+        }
+      }
+      if (audit.violations.filter(v => v.kind === 'task-duplicate-request').length === 0) {
+        audit.verified.push({ kind: 'tasks', detail: `${requests.size} active tasks, request 중복 0건` });
+      }
+    }
+  } catch (e) { audit.violations.push({ kind: 'audit-error', area: 'tasks', detail: String(e.message || e), severity: 'low' }); }
+
+  // 3) user-requests.json 자체 dedup 검증 (1.9.207)
+  try {
+    const ur = _loadUserRequests(root);
+    const seen = new Map();
+    for (const r of ur.requests) {
+      if (r.status !== 'open' && r.status !== 'in-progress') continue;
+      const k = r.text.trim();
+      if (seen.has(k)) {
+        audit.violations.push({
+          kind: 'user-request-duplicate',
+          location: '.harness/user-requests.json',
+          detail: `중복 open 요청: ${r.id} == ${seen.get(k)} ("${k.slice(0, 50)}…")`,
+          severity: 'low',
+          fix: `leerness requests drop ${r.id}`
+        });
+      } else {
+        seen.set(k, r.id);
+      }
+    }
+    if (audit.violations.filter(v => v.kind === 'user-request-duplicate').length === 0) {
+      audit.verified.push({ kind: 'user-requests', detail: `${seen.size} open requests, 중복 0건 (1.9.207 dedup OK)` });
+    }
+  } catch (e) { audit.violations.push({ kind: 'audit-error', area: 'user-requests', detail: String(e.message || e), severity: 'low' }); }
+
+  // 4) active-wakeups.json 검증 (1.9.205)
+  try {
+    const wk = _loadActiveWakeups(root);
+    const pending = wk.wakeups.filter(w => w.status === 'pending');
+    const seenT = new Map();
+    for (const w of pending) {
+      if (seenT.has(w.expectedFireAt)) {
+        audit.violations.push({
+          kind: 'wakeup-duplicate',
+          location: '.harness/active-wakeups.json',
+          detail: `동일 expectedFireAt 중복: ${w.expectedFireAt}`,
+          severity: 'high',
+          fix: `leerness 자동 _recordWakeup filter dedup 검토 필요`
+        });
+      } else {
+        seenT.set(w.expectedFireAt, true);
+      }
+    }
+    if (audit.violations.filter(v => v.kind === 'wakeup-duplicate').length === 0) {
+      audit.verified.push({ kind: 'wakeups', detail: `${pending.length} pending wakeups, 중복 0건 (1.9.205 dedup OK)` });
+    }
+  } catch {}
+
+  audit.summary = {
+    totalViolations: audit.violations.length,
+    highSeverity: audit.violations.filter(v => v.severity === 'high').length,
+    mediumSeverity: audit.violations.filter(v => v.severity === 'medium').length,
+    lowSeverity: audit.violations.filter(v => v.severity === 'low').length,
+    verifiedAreas: audit.verified.length,
+    overall: audit.violations.length === 0 ? 'clean' : 'violations-found'
+  };
+  return audit;
+}
+function idempotencyCmd(root, sub) {
+  root = absRoot(root);
+  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;
+  const yel = s => isTty ? `\x1b[33m${s}\x1b[0m` : s;
+  const red = s => isTty ? `\x1b[31m${s}\x1b[0m` : s;
+  const dim = s => isTty ? `\x1b[2m${s}\x1b[0m` : s;
+
+  if (!sub || sub === 'help' || sub === '--help') {
+    log(`# leerness idempotency (1.9.212) — 멱등성 위반 탐지`);
+    log('');
+    log(`  audit     → 워크스페이스 멱등성 점검 (rules / tasks / user-requests / wakeups)  (--json 가능)`);
+    log('');
+    log(dim(`  dedup 적용 영역: ruleAdd / taskAdd (1.9.212) + _recordUserRequest (1.9.207) + _recordWakeup (1.9.205)`));
+    log(dim(`  opt-out: --force 플래그로 dedup 우회 가능`));
+    return;
+  }
+
+  if (sub === 'audit') {
+    const audit = _runIdempotencyAudit(root);
+    if (has('--json')) { log(JSON.stringify(audit, null, 2)); return; }
+    log(cyan(`# leerness idempotency audit (1.9.212)`));
+    log(`  audited at: ${audit.auditedAt}`);
+    log('');
+    const s = audit.summary;
+    if (s.overall === 'clean') {
+      log(grn(`  ✓ 멱등성 위반 없음 — verified ${s.verifiedAreas} 영역`));
+    } else {
+      log(red(`  ⚠ ${s.totalViolations} 위반 발견 (high: ${s.highSeverity}, medium: ${s.mediumSeverity}, low: ${s.lowSeverity})`));
+    }
+    log('');
+    if (audit.verified.length) {
+      log(grn(`## ✅ verified (${audit.verified.length})`));
+      audit.verified.forEach(v => log(dim(`  - [${v.kind}] ${v.detail}`)));
+      log('');
+    }
+    if (audit.violations.length) {
+      log(red(`## ⚠ violations (${audit.violations.length})`));
+      audit.violations.forEach(v => {
+        const icon = v.severity === 'high' ? '🚨' : (v.severity === 'medium' ? '⚠' : 'ℹ');
+        log(`  ${icon} [${v.kind}] (${v.severity})`);
+        log(dim(`     ${v.location}`));
+        log(`     ${v.detail}`);
+        if (v.fix) log(dim(`     fix: ${v.fix}`));
+      });
+    }
+    return;
+  }
+
+  console.error(`Unknown subcommand: ${sub}`);
+  console.error(`Run: leerness idempotency help`);
+  process.exit(1);
+}
+
 // 1.9.199: wakeup miss 자동 회복 강화 — last-handoff timestamp 기록 + 25min 기대 interval 정밀 측정
 //   사용자 명시 (1.9.198 후속): "22:01에 라운드에 자동진입되지않았어"
 //   1.9.196 task-log mtime 기반 detector 는 task-log 가 자주 안 업데이트되면 false positive.
@@ -3453,6 +3895,30 @@ function taskList(root) {
   for (const r of filtered) log(`| ${r.id} | ${r.status} | ${r.request} | ${r.evidence} | ${r.nextAction} | ${r.updated} |`);
 }
 function taskAdd(root, text) {
+  // 1.9.212: 멱등성 — 같은 request 텍스트 + 활성 상태 (requested/in-progress) 이미 존재 시 skip (사용자 명시)
+  // progress-tracker.md 포맷: | T-XXXX | status | request | evidence | nextAction | date |
+  if (!has('--force') && text && text.trim()) {
+    try {
+      const pt = path.join(absRoot(root), '.harness', 'progress-tracker.md');
+      if (exists(pt)) {
+        const content = read(pt);
+        const norm = text.trim();
+        const lines = content.split(/\r?\n/);
+        for (const line of lines) {
+          if (!/^\|\s*T-\d{4,}\s*\|/.test(line)) continue;
+          const cells = line.split('|').slice(1, -1).map(s => s.trim());
+          if (cells.length < 3) continue;
+          const id = cells[0];
+          const status = (cells[1] || '').toLowerCase();
+          const request = cells[2];
+          if (request === norm && !/^(done|dropped|blocked|completed)$/i.test(status)) {
+            ok(`task exists (skip): ${id} request="${norm.slice(0, 60)}…"  (--force 로 덮어쓰기)`);
+            return;
+          }
+        }
+      }
+    } catch {}
+  }
   const id = nextId(root, 'T');
   upsertProgress(root, { id, status: arg('--status','requested'), request: text, evidence: arg('--evidence','user-request'), nextAction: arg('--next','다음 액션 작성') });
   ok(`task added: ${id}`);
@@ -9981,8 +10447,16 @@ function ruleAdd(root, description) {
   if (!validTriggers.has(trigger)) {
     warn(`unknown trigger "${trigger}" — 사용 가능: ${[...validTriggers].join(', ')}. 그대로 등록합니다.`);
   }
-  const id = nextRuleId(root);
   const rules = readRules(root);
+  // 1.9.212: 멱등성 보장 — 같은 description + trigger + active 상태 이미 존재 시 skip (사용자 명시)
+  if (!has('--force')) {
+    const dup = rules.find(r => r.rule === description && r.trigger === trigger && r.status === 'active');
+    if (dup) {
+      ok(`rule exists (skip): ${dup.id} [${dup.trigger}] ${description}  (--force 로 덮어쓰기)`);
+      return;
+    }
+  }
+  const id = nextRuleId(root);
   rules.push({ id, trigger, rule: description, added: today(), status: 'active', lastVerified: '-' });
   writeRules(root, rules);
   ok(`rule added: ${id} [${trigger}] ${description}`);
@@ -16280,6 +16754,12 @@ async function main() {
   if (cmd === 'pre-wake-audit')                     return preWakeAuditCmd(arg('--path', process.cwd()), args[1]);
   // 1.9.210: leerness wakeup-interval <get|set|auto|history|record> — adaptive interval (사용자 명시)
   if (cmd === 'wakeup-interval')                    return wakeupIntervalCmd(arg('--path', process.cwd()), args[1], args[2]);
+  // 1.9.211: leerness workspace-dir <get|guide> — 현재 워크스페이스 디렉토리 / AI 참조 가이드 (사용자 명시)
+  if (cmd === 'workspace-dir')                      return workspaceDirCmd(arg('--path', process.cwd()), args[1]);
+  // 1.9.211: leerness migrate-workspace-dir — .harness → .leerness 마이그레이션 (사용자 명시)
+  if (cmd === 'migrate-workspace-dir')              return migrateWorkspaceDirCmd(arg('--path', process.cwd()));
+  // 1.9.212: leerness idempotency audit — 멱등성 위반 탐지 (사용자 명시)
+  if (cmd === 'idempotency')                        return idempotencyCmd(arg('--path', process.cwd()), args[1]);
   if (cmd === 'rule' && args[1] === 'add')          return ruleAdd(arg('--path', process.cwd()), args.slice(2).filter(x => !x.startsWith('-')).join(' '));
   if (cmd === 'rule' && args[1] === 'list')         return ruleList(arg('--path', process.cwd()));
   if (cmd === 'rule' && args[1] === 'remove')       return ruleRemove(arg('--path', process.cwd()), args[2]);

package/package.json

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