leerness 1.9.211 → 1.9.213

package/CHANGELOG.md

@@ -1,5 +1,120 @@
 # Changelog
 
+## 1.9.213 — 2026-05-22
+
+**🎯 intent inference + scope expansion 게이트 (사용자 명시) — 마지막 pending task 완성.**
+
+### 사용자 명시
+> *"사용자가 말한 내용만 수정해야하는 경우도 있지만, 관련있는것이나 보강하면 좋을 부분을 파악하여 진행 / 게임 개발에서 맵+캐릭터+기본기능 요청 시 의도 파악"*
+
+### 1. 3원칙 안전 설계
+1. **Always-Off, Opt-In** — 기본 비활성, 명시적 호출 (`leerness intent expand`) 또는 review-request 통합 시만 작동
+2. **Dry-run 기본** — 실제 task add **절대 X**, 모든 출력은 후보 보고만
+3. **명시 vs 추론 분리 라벨링** — `👤 사용자 명시` vs `🤖 AI 추론 확장` 항상 구분
+
+### 2. `_classifyIntent(text)` — 3단계 분류
+- **precise** ("정확히", "그것만", "그대로", "말한대로", "only") → AI 추론 확장 **비활성**
+- **broad** ("기본", "포괄적", "등등", "다양한", "전체", "필요한") → 확장 후보 N건 dry-run 제시
+- **default** (명시 없음) → 명시 우선, 확장 후보 검토용으로 표시
+
+### 3. `.harness/domain-catalog.json` — 5 default + user 편집 가능
+- **game** (10 컴포넌트): map, character, gameLoop, collision, camera, hud, audio, save, menu, input
+- **web** (8 컴포넌트): routing, state, auth, api, db, ui, test, deploy
+- **api** (7 컴포넌트): endpoint, auth, rate-limit, validation, error, logging, docs
+- **cli** (6 컴포넌트): argParser, help, config, output, error, completion
+- **data** (6 컴포넌트): ingest, transform, storage, query, validation, lineage
+
+### 4. `_inferScopeExpansion(text, root)` — 확장 후보 dry-run
+- 도메인 자동 탐지 (alias 매칭)
+- 사용자 명시 mention 추출
+- 나머지 → AI 추론 확장 후보
+- **mode: 'dry-run' 강제** (실행 X)
+
+### 5. `leerness intent <classify|expand|domains>` CLI
+- `classify "<req>"` — 의도 분류 + 신호
+- `expand "<req>"` — 도메인 탐지 + 확장 후보 dry-run
+- `domains` — catalog 출력
+- 모두 `--json` 지원
+
+### 6. 사용자 게임 예시 검증
+```
+$ leerness intent expand "맵과 캐릭터 + 기본 게임 기능 포괄적으로 만들어줘"
+🌐 intent: broad  📦 domain: game (matched: "게임")
+
+## 👤 사용자 명시 (2)
+  • character — 캐릭터/스프라이트 + 애니메이션 상태머신
+  • gameLoop — 게임 루프 (tick/render/update)
+
+## 🤖 AI 추론 확장 후보 (8, dry-run)
+  [1] map / [2] collision / [3] camera / [4] hud / [5] audio / [6] save / [7] menu / [8] input
+
+→ 진행 시 명시 승인 필요: leerness task add "<선택한 후보 요청>"
+→ 전부 무시하려면 추가 task add 없이 명시 요청만 진행
+```
+
+### 7. precise 의도 보호 검증
+```
+$ leerness intent expand "정확히 게임의 맵만 수정해줘 그것만"
+🛡 intent: precise — AI 추론 확장 비활성 (사용자 의도 보호)
+```
+
+### 8. 누적 회귀 (1.9.200~212) — 모두 유지
+
+### 9. stress-v158 — 19/19 PASS
+- 1.9.213 (10) + 성능 (2) + 누적 회귀 (7)
+- 게임 예시 broad → 8 확장 후보 / precise → 0 확장 (의도 보호) / web 도메인 탐지
+- 성능: --version cold start avg 388ms · MCP 54 도구 434ms
+
+### 10. 자동 release (75 라운드 main-push streak · 36 라운드 npm publish streak)
+
+### 11. 🎉 사용자 명시 task 백로그 **완전 소진** (#307까지 모두 completed)
+- 1.9.207~213 7 라운드 연속 사용자 명시 요청 처리:
+  - 207 user-requests audit / 208 platform constraints / 209 pre-wake audit
+  - 210 adaptive wakeup / 211 .harness→.leerness migration / 212 idempotency dedup
+  - 213 intent inference + scope expansion 게이트
+
+---
+
+## 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 참조 가이드 (사용자 명시).**

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.211-green)]() [![tests](https://img.shields.io/badge/e2e-217%2F217-success)]() [![stress](https://img.shields.io/badge/stress--v156-19%2F19-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-54-brightgreen)]() [![rounds](https://img.shields.io/badge/autonomous--rounds-141-blueviolet)]() [![main-push](https://img.shields.io/badge/release--main--push-73_rounds-success)]() [![goal-matrix](https://img.shields.io/badge/목적_매트릭스-98%2F100_(5축)-brightgreen)]() [![workspace](https://img.shields.io/badge/.harness→.leerness-opt--in_migration-success)]() [![perf](https://img.shields.io/badge/cold_start-452ms-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.213-green)]() [![tests](https://img.shields.io/badge/e2e-217%2F217-success)]() [![stress](https://img.shields.io/badge/stress--v158-19%2F19-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-54-brightgreen)]() [![rounds](https://img.shields.io/badge/autonomous--rounds-143-blueviolet)]() [![main-push](https://img.shields.io/badge/release--main--push-75_rounds-success)]() [![goal-matrix](https://img.shields.io/badge/목적_매트릭스-98%2F100_(5축)-brightgreen)]() [![intent](https://img.shields.io/badge/intent-inference_5도메인-success)]() [![perf](https://img.shields.io/badge/cold_start-388ms-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.211  AI Agent Reliability Harness + Sandbox            ║
+  ║  v1.9.213  AI Agent Reliability Harness + Sandbox            ║
   ║  verify · remember · orchestrate · audit · sandbox · drift   ║
-  ║  📂 .harness → .leerness opt-in 마이그레이션 (사용자 명시)           ║
+  ║  🎯 intent inference + scope expansion 5도메인 (사용자 명시)        ║
   ╚══════════════════════════════════════════════════════════════╝
 ```
 

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.211';
+const VERSION = '1.9.213';
 
 // 1.9.184: DEP0190 (child_process shell: true) deprecation warning 억제 (사용자 명시).
 //   leerness 는 cross-platform PATH resolution 을 위해 shell: true 를 의도적으로 사용 (claude.cmd / ollama.cmd 등 Windows .cmd 처리).
@@ -2526,6 +2526,175 @@ function _buildWorkspaceReferenceGuide(root, dirName) {
   return lines.join('\n');
 }
 
+// 1.9.213: intent inference + scope expansion 게이트 (사용자 명시)
+//   "사용자가 말한 내용만 수정해야하는 경우도 있지만, 관련있는것이나 보강하면 좋을 부분을 파악하여 진행"
+//   "게임 개발에서 맵+캐릭터+기본기능 요청 시 의도 파악"
+//   3원칙: (1) Always-Off Opt-In, (2) Dry-run 기본 (실행 X), (3) 명시 vs 추론 분리 라벨링
+//   .harness/domain-catalog.json 사용자 편집 가능 + default catalog 5종 (game/web/api/cli/data)
+function _domainCatalogPath(root) { return path.join(root, '.harness', 'domain-catalog.json'); }
+const _DEFAULT_DOMAIN_CATALOG = {
+  version: '1.9.213',
+  domains: {
+    game: {
+      aliases: ['게임', 'game', 'unity', 'unreal', 'godot', 'phaser', 'gamedev'],
+      components: [
+        { key: 'map', desc: '맵/타일 시스템 + 영역/스폰' },
+        { key: 'character', desc: '캐릭터/스프라이트 + 애니메이션 상태머신' },
+        { key: 'gameLoop', desc: '게임 루프 (tick/render/update)' },
+        { key: 'collision', desc: '충돌 감지 (AABB/SAT/grid)' },
+        { key: 'camera', desc: '카메라 follow + 영역 제한' },
+        { key: 'hud', desc: 'HUD/UI (HP/score/inventory)' },
+        { key: 'audio', desc: '사운드 매니저 (BGM/SFX)' },
+        { key: 'save', desc: '저장/로드 (slot 시스템)' },
+        { key: 'menu', desc: '메뉴 (메인/일시정지/설정)' },
+        { key: 'input', desc: '입력 핸들러 (키보드/패드/터치)' }
+      ]
+    },
+    web: {
+      aliases: ['웹', 'web', 'website', 'webapp', 'nextjs', 'react', 'vue', 'svelte', 'frontend'],
+      components: [
+        { key: 'routing', desc: '라우팅 (path/dynamic/nested)' },
+        { key: 'state', desc: '상태 관리 (context/redux/zustand)' },
+        { key: 'auth', desc: '인증 (OAuth/JWT/session)' },
+        { key: 'api', desc: 'API 클라이언트 (fetch/axios/tanstack-query)' },
+        { key: 'db', desc: 'DB 연동 (ORM/migration/seed)' },
+        { key: 'ui', desc: 'UI 컴포넌트 라이브러리' },
+        { key: 'test', desc: '테스트 (unit/e2e/visual)' },
+        { key: 'deploy', desc: '배포 (Vercel/Netlify/Cloudflare)' }
+      ]
+    },
+    api: {
+      aliases: ['api', 'rest', 'graphql', 'endpoint', 'backend', 'server'],
+      components: [
+        { key: 'endpoint', desc: '엔드포인트 라우팅 + HTTP method' },
+        { key: 'auth', desc: '인증/인가 (API key/OAuth/JWT)' },
+        { key: 'rate-limit', desc: 'rate limit (RPS/RPM/token bucket)' },
+        { key: 'validation', desc: '입력 검증 (zod/joi/yup)' },
+        { key: 'error', desc: '에러 핸들링 + 응답 형식' },
+        { key: 'logging', desc: '로깅 + 모니터링 (structured logs)' },
+        { key: 'docs', desc: 'API 문서 (OpenAPI/Swagger)' }
+      ]
+    },
+    cli: {
+      aliases: ['cli', 'command-line', 'tool', 'utility', 'shell'],
+      components: [
+        { key: 'argParser', desc: '인자 파싱 (yargs/commander/clipanion)' },
+        { key: 'help', desc: 'help / man / examples 텍스트' },
+        { key: 'config', desc: '설정 파일 + env 변수' },
+        { key: 'output', desc: '출력 (TTY 색상/JSON/quiet)' },
+        { key: 'error', desc: '에러 처리 + exit code 규약' },
+        { key: 'completion', desc: 'shell completion (bash/zsh/fish)' }
+      ]
+    },
+    data: {
+      aliases: ['data', 'pipeline', 'etl', 'analytics', 'ingest'],
+      components: [
+        { key: 'ingest', desc: '데이터 수집 (file/API/stream)' },
+        { key: 'transform', desc: '변환 (cleaning/normalization/joining)' },
+        { key: 'storage', desc: '저장소 (parquet/db/blob)' },
+        { key: 'query', desc: '쿼리/분석 (SQL/aggregations)' },
+        { key: 'validation', desc: '데이터 검증 (schema/contracts)' },
+        { key: 'lineage', desc: '데이터 lineage 추적' }
+      ]
+    }
+  }
+};
+function _loadDomainCatalog(root) {
+  try {
+    const fp = _domainCatalogPath(root);
+    if (!exists(fp)) return _DEFAULT_DOMAIN_CATALOG;
+    const j = JSON.parse(read(fp));
+    // user catalog merge — user override 우선
+    const merged = JSON.parse(JSON.stringify(_DEFAULT_DOMAIN_CATALOG));
+    if (j.domains) {
+      for (const k of Object.keys(j.domains)) merged.domains[k] = j.domains[k];
+    }
+    return merged;
+  } catch { return _DEFAULT_DOMAIN_CATALOG; }
+}
+function _writeDomainCatalog(root, catalog) {
+  try {
+    mkdirp(path.join(root, '.harness'));
+    writeUtf8(_domainCatalogPath(root), JSON.stringify({ ...catalog, updatedAt: new Date().toISOString() }, null, 2));
+    return true;
+  } catch { return false; }
+}
+// intent 분류: precise / broad / default
+function _classifyIntent(text) {
+  if (!text || typeof text !== 'string') return { intent: 'default', signals: [] };
+  const signals = [];
+  // precise 신호: "정확히 / 그것만 / 그대로 / only / just / 만"
+  const preciseKws = ['정확히', '그것만', '그대로', 'only', 'just only', '말한대로', '말한 그대로'];
+  for (const kw of preciseKws) {
+    if (text.toLowerCase().includes(kw.toLowerCase())) signals.push({ kind: 'precise', match: kw });
+  }
+  // broad 신호: "기본 / 포괄적 / 등등 / 다양한 / 전체 / 기본적인 / etc / overall"
+  const broadKws = ['기본', '포괄적', '등등', '다양한', '전체', '기본적인', 'etc', 'overall', '필요한', '관련', 'comprehensive', 'including'];
+  for (const kw of broadKws) {
+    if (text.toLowerCase().includes(kw.toLowerCase())) signals.push({ kind: 'broad', match: kw });
+  }
+  // 결정
+  const preciseCount = signals.filter(s => s.kind === 'precise').length;
+  const broadCount = signals.filter(s => s.kind === 'broad').length;
+  let intent;
+  if (preciseCount > broadCount && preciseCount >= 1) intent = 'precise';
+  else if (broadCount >= 1) intent = 'broad';
+  else intent = 'default';
+  return { intent, signals, preciseCount, broadCount };
+}
+function _detectDomain(text, root) {
+  if (!text) return { domain: null, alias: null };
+  const lower = text.toLowerCase();
+  const catalog = _loadDomainCatalog(root);
+  for (const [domain, info] of Object.entries(catalog.domains)) {
+    for (const a of info.aliases || []) {
+      if (lower.includes(a.toLowerCase())) {
+        return { domain, alias: a, components: info.components };
+      }
+    }
+  }
+  return { domain: null, alias: null };
+}
+function _inferScopeExpansion(text, root) {
+  const classify = _classifyIntent(text);
+  const det = _detectDomain(text, root);
+  const result = {
+    text,
+    intent: classify.intent,
+    intentSignals: classify.signals,
+    domain: det.domain,
+    matchedAlias: det.alias,
+    explicitMentions: [],
+    expansionCandidates: [],
+    mode: 'dry-run'  // 항상 dry-run — 실행 X
+  };
+  if (!det.domain || !det.components) {
+    result.note = '도메인 미탐지 — 명시 요청만 진행 (확장 후보 없음)';
+    return result;
+  }
+  // 사용자 텍스트에서 component key 직접 언급 추출
+  const lowerText = text.toLowerCase();
+  for (const c of det.components) {
+    const mentionPatterns = [c.key.toLowerCase(), ...(c.desc.split(/[\s/()]/).filter(w => w.length >= 2).map(w => w.toLowerCase()))];
+    const mentioned = mentionPatterns.some(p => lowerText.includes(p));
+    if (mentioned) {
+      result.explicitMentions.push({ key: c.key, desc: c.desc, source: 'user-explicit' });
+    } else {
+      result.expansionCandidates.push({ key: c.key, desc: c.desc, source: 'ai-inference' });
+    }
+  }
+  // intent === precise 면 expansion 비어있게 (의도 보호)
+  if (classify.intent === 'precise') {
+    result.expansionCandidates = [];
+    result.note = `intent: precise — 명시 요청만 진행, AI 추론 확장 비활성 (사용자 의도 보호)`;
+  } else if (classify.intent === 'broad') {
+    result.note = `intent: broad — ${result.expansionCandidates.length} 확장 후보 제시 (--expand-all 또는 --select N 으로 명시 승인 필요)`;
+  } else {
+    result.note = `intent: default — 명시 ${result.explicitMentions.length}건만 우선, 확장 후보 ${result.expansionCandidates.length}건 검토용`;
+  }
+  return result;
+}
+
 // 1.9.203: 자동 라운드 plan 정리 — 사용자 명시
 //   "백그라운드에 다음 작업이 시작가능한 예상 시간 + 일어났을때 해야하는 일을 정리"
 //   라운드 마무리 시 .harness/auto-resume-plan.json 자동 저장 → 다음 wakeup 시 즉시 실행 가능
@@ -3129,6 +3298,287 @@ function migrateWorkspaceDirCmd(root) {
   }
 }
 
+// 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.213: leerness intent <classify|expand|domains> CLI — intent inference + scope expansion (사용자 명시)
+function intentCmd(root, sub, ...rest) {
+  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 intent (1.9.213) — 사용자 의도 파악 + scope expansion 게이트`);
+    log('');
+    log(`  classify "<request>"      → intent 분류 (precise/broad/default) + 신호 (--json 가능)`);
+    log(`  expand "<request>"        → 도메인 탐지 + 확장 후보 dry-run (--json 가능)`);
+    log(`  domains                   → 등록된 도메인 catalog 출력 (game/web/api/cli/data)`);
+    log('');
+    log(dim(`  3원칙: (1) Always-Off Opt-In  (2) Dry-run 기본 (실행 X)  (3) 명시 vs 추론 분리 라벨링`));
+    log(dim(`  예: leerness intent expand "맵과 캐릭터 + 기본 게임 기능 만들어줘"`));
+    return;
+  }
+
+  if (sub === 'classify') {
+    const text = rest.filter(x => !x.startsWith('-')).join(' ');
+    if (!text) { console.error('Usage: leerness intent classify "<request text>"'); process.exit(1); }
+    const result = _classifyIntent(text);
+    if (has('--json')) { log(JSON.stringify({ text, ...result }, null, 2)); return; }
+    log(cyan(`# leerness intent classify (1.9.213)`));
+    log(`  text: ${text.slice(0, 100)}${text.length > 100 ? '…' : ''}`);
+    log('');
+    const icon = result.intent === 'precise' ? '🎯' : (result.intent === 'broad' ? '🌐' : '🔍');
+    log(`  ${icon} intent: ${grn(result.intent)} (precise=${result.preciseCount} / broad=${result.broadCount})`);
+    if (result.signals.length) {
+      log('');
+      log(`  📡 신호:`);
+      result.signals.forEach(s => log(dim(`     • [${s.kind}] "${s.match}"`)));
+    }
+    return;
+  }
+
+  if (sub === 'expand') {
+    const text = rest.filter(x => !x.startsWith('-')).join(' ');
+    if (!text) { console.error('Usage: leerness intent expand "<request text>"'); process.exit(1); }
+    const result = _inferScopeExpansion(text, root);
+    if (has('--json')) { log(JSON.stringify(result, null, 2)); return; }
+    log(cyan(`# leerness intent expand (1.9.213) [DRY-RUN]`));
+    log(`  text: ${text.slice(0, 100)}${text.length > 100 ? '…' : ''}`);
+    log('');
+    const iIcon = result.intent === 'precise' ? '🎯' : (result.intent === 'broad' ? '🌐' : '🔍');
+    log(`  ${iIcon} intent: ${grn(result.intent)}` + (result.domain ? `  📦 domain: ${grn(result.domain)}` + (result.matchedAlias ? dim(` (matched: "${result.matchedAlias}")`) : '') : `  ${dim('domain 미탐지')}`));
+    log('');
+    if (result.explicitMentions.length) {
+      log(grn(`## 👤 사용자 명시 (${result.explicitMentions.length})`));
+      result.explicitMentions.forEach(m => log(`  • ${m.key} — ${m.desc}`));
+      log('');
+    }
+    if (result.expansionCandidates.length) {
+      log(yel(`## 🤖 AI 추론 확장 후보 (${result.expansionCandidates.length}, dry-run)`));
+      result.expansionCandidates.forEach((c, i) => log(`  [${i + 1}] ${c.key} — ${c.desc}`));
+      log('');
+      log(dim(`  → 진행 시 명시 승인 필요: leerness task add "<선택한 후보 요청>"`));
+      log(dim(`  → 전부 무시하려면 추가 task add 없이 명시 요청만 진행`));
+    } else if (result.domain && result.intent === 'precise') {
+      log(red(`  🛡 intent: precise — AI 추론 확장 비활성 (사용자 의도 보호)`));
+    }
+    if (result.note) {
+      log('');
+      log(dim(`  ℹ ${result.note}`));
+    }
+    return;
+  }
+
+  if (sub === 'domains') {
+    const catalog = _loadDomainCatalog(root);
+    if (has('--json')) { log(JSON.stringify(catalog, null, 2)); return; }
+    log(cyan(`# leerness intent domains (1.9.213)`));
+    log(`  total domains: ${Object.keys(catalog.domains).length}`);
+    log('');
+    for (const [name, info] of Object.entries(catalog.domains)) {
+      log(grn(`  📦 ${name}`) + dim(`  aliases: ${(info.aliases || []).join(', ')}`));
+      for (const c of info.components || []) {
+        log(`     • ${c.key.padEnd(12)} ${dim(c.desc)}`);
+      }
+      log('');
+    }
+    return;
+  }
+
+  console.error(`Unknown subcommand: ${sub}`);
+  console.error(`Run: leerness intent 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.
@@ -3707,6 +4157,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}`);
@@ -10235,8 +10709,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}`);
@@ -16538,6 +17020,10 @@ async function main() {
   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]);
+  // 1.9.213: leerness intent <classify|expand|domains> — intent inference + scope expansion (사용자 명시)
+  if (cmd === 'intent')                             return intentCmd(arg('--path', process.cwd()), args[1], ...args.slice(2));
   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.211",
+  "version": "1.9.213",
   "description": "Leerness: 비파괴 마이그레이션, 자동 버전 감지·업데이트, 계획/진행/핸드오프 자동화, 게으름·시크릿·인코딩 자동 가드, Claude Code 슬래시 통합을 갖춘 한국어 우선 AI 개발 하네스.",
   "keywords": [
     "leerness",