leerness 1.9.40 → 1.9.43

package/CHANGELOG.md

@@ -1,5 +1,117 @@
 # Changelog
 
+## 1.9.43 — 2026-05-19
+
+**MCP 서버 + skill 일괄 export + _reports 비공개 + GitHub 배포 준비**.
+
+[agentskills.io 분석](https://agentskills.io)에서 도출한 발전 로드맵의 Phase 1 즉시 후보 3건을 통합. leerness 도구를 **MCP 서버로 노출**하여 Claude Code · Hermes · Cursor 등 30+ 도구가 직접 호출 가능.
+
+### Added — MCP Server (sub-agent로서 leerness)
+
+- **`leerness mcp serve`** 신규 명령 — stdio JSON-RPC로 leerness 도구 10종 노출:
+  - `leerness_handoff` · `leerness_drift_check` · `leerness_audit` (--fix 지원)
+  - `leerness_verify_claim` (--run-tests, --strict-claims)
+  - `leerness_contract_verify` (사양 ↔ 구현)
+  - `leerness_agents_list` · `leerness_reuse_map` · `leerness_whats_new`
+  - `leerness_usage_stats` · `leerness_session_close`
+  - 표준 MCP 프로토콜 (2024-11-05) — initialize / tools/list / tools/call
+- 이제 Claude Code · Hermes · Cursor 등이 `.mcp.json`에 leerness를 등록하면 메인 에이전트가 leerness 검수를 sub-tool로 호출 가능
+
+### Added — skill 표준 export·discover
+
+- **`leerness skill export-all [--out <dir>]`** — 모든 자체 skill(9개)을 agentskills.io 표준 `SKILL.md`로 일괄 export. 다른 도구가 `skill install <path>`로 즉시 import.
+
+### Added — 내부 보고서 비공개
+
+- **`_reports/` 디렉토리 자동 비공개**:
+  - root `.gitignore`에 `_reports/`, `**/_reports/`, `*.private.md`, `*.private.json` 추가
+  - `leerness-pkg/.gitignore`에 동일 추가
+  - 신규 `leerness-pkg/.npmignore` — npm publish 시 명시적 제외
+  - `package.json#files` 화이트리스트와 이중 안전
+- 내부 검수 보고서 (`LEERNESS_VS_HERMES_AND_AGENTSKILLS.md`, `SESSION_LEERNESS_USAGE_AUDIT.md` 등)는 사용자 확인 전용이며 npm/GitHub 배포에 포함되지 않음
+
+### Verified
+- e2e: **195/195 PASS** (1.9.42 190 + 신규 5)
+- MCP server initialize/tools/list 정상 JSON-RPC 응답
+- skill export-all → 9개 SKILL.md 일괄 생성
+- .gitignore/.npmignore에 _reports/ 차단 확인
+
+### 정책
+- ✅ MCP server는 명시 호출 (`leerness mcp serve`) 시에만 작동 — 자동 시작 안 함
+- ✅ MCP 도구 호출 시 LEERNESS_NO_BANNER/NO_PROMPT/NO_DRIFT_CHECK 자동 설정 (호스트 환경 깔끔)
+- ✅ _reports 비공개 — 다중 채널 (gitignore + npmignore + files 화이트리스트)
+
+## 1.9.42 — 2026-05-19
+
+**agentskills.io 공개 표준 호환 — 30+ AI 도구와 스킬 즉시 공유**.
+
+[agentskills.io](https://agentskills.io)는 Anthropic이 만든 Agent Skills 개방 표준으로 Claude Code · Cursor · GitHub Copilot · OpenAI Codex · Gemini CLI · Hermes Agent · OpenHands · Goose 등 30+ 도구가 채택. 1.9.42부터 leerness가 이 표준의 `SKILL.md` 포맷을 import/export 가능.
+
+### Added
+
+- **`leerness skill install <url-or-path>`** 신규 명령 — `SKILL.md` 다운로드/import:
+  - URL (https://...) 또는 로컬 파일/디렉토리 모두 지원
+  - frontmatter (`name`, `description`) 파싱 → `.harness/skills/<id>/SKILL.md` 자동 배치
+  - 자체 `skill.json` 도 함께 생성 (자체 catalog 호환, `_source: 'agentskills.io'` 추적)
+- **`leerness skill discover [--query <q>] [--source <url>]`** 신규 명령 — 공개 스킬 카탈로그에서 매칭 추천:
+  - **opt-in**: `LEERNESS_SKILL_DISCOVER_URL` 환경변수 또는 `--source` 명시 필요 (자동 외부 fetch 금지 정책 유지)
+  - `--query` 키워드 매칭 + 마크다운 링크/SKILL.md URL 자동 추출
+  - `--json` 출력 지원
+- **`leerness skill export <id> [--out <dir>]`** 신규 명령 — 기존 자체 skill을 agentskills.io 표준 `SKILL.md` 포맷으로 export → 다른 도구가 `skill install`로 import 가능
+- **`.env.example`에 2개 신규 환경변수** (opt-in, 기본 OFF):
+  - `LEERNESS_SKILL_DISCOVER_URL=` — 공개 카탈로그 URL
+  - `LEERNESS_SKILL_AUTO_DISCOVER=0` — 사용자 요청 분석 시 자동 매칭 추천
+- **`_httpFetch()` 내장 HTTPS 호출자** — Node 18+ globalThis.fetch, fallback https module. 사용자 동의 명령에서만 호출.
+
+### Reports
+- `_reports/LEERNESS_VS_HERMES_AND_AGENTSKILLS.md` 작성 — 10 섹션 상세 분석:
+  - agentskills.io 표준 + Progressive Disclosure 메커니즘
+  - Hermes Agent (NousResearch, 157k ⭐, MIT) 분석
+  - leerness 4 고유 우위 (거짓 완료 검증, drift 자동 감지, 워크스페이스 가시성, 마이그레이션 인지 갭)
+  - 1.9.42 → 2.0 발전 로드맵 3 Phase
+
+### 정책
+- ❌ leerness는 외부 URL 자동 fetch 절대 금지 — opt-in (env 또는 `--source` 명시) 필수
+- ✅ `_httpFetch`는 사용자 명령 (`skill install URL` / `skill discover`)에서만 호출
+- ✅ 기존 자체 skillCatalog와 양립 — `_source: 'agentskills.io'`로 출처 추적
+
+### e2e: 190/190 PASS (1.9.41 186 + 신규 4)
+
+## 1.9.41 — 2026-05-19
+
+**디스크 마이그레이션 ↔ AI 컨텍스트 인지 갭 차단 — 맞춤형 차분 마이그레이션**.
+
+사용자 통찰: 같은 채팅 세션에서 leerness를 latest로 migrate해도, AI 에이전트는 이전 청크의 마인드셋으로 계속 작업하여 신규 도구(release pack, drift check 등)를 자동으로 호출하지 않는 패턴 발견. migrate는 파일만 업데이트, AI에겐 "새 도구가 들어왔다"는 신호 전달 부재.
+
+### Added
+
+- **`leerness whats-new [--from V] [--to V] [--json]`** 신규 명령 — CHANGELOG.md를 자동 파싱하여 두 버전 사이의 차분 추출:
+  - 신규 명령 (`leerness X` 패턴), 신규 플래그 (`--xxx`), 신규 파일 (`.harness/*.md`) 자동 분류
+  - 각 버전의 헤드라인 (`**...**` 또는 첫 라인) 추출
+  - AI 가독 권장 행동 자동 출력
+- **`migrate` 후 stdout에 AI must re-read 차분 자동 출력** — migrate 직전 이전 버전을 캡처 (`_previousVersion`) → CHANGELOG 차분 추출 → 신규 명령/파일을 stdout에 즉시 표시:
+  - "이전 청크의 기억 무효 — 새 도구 우선 시도" 명시
+  - 같은 세션 내 AI 인-컨텍스트에 신규 도구 인지 주입
+- **`migration-report.md`에 "🤖 AI must re-read" 섹션 영구 기록** — 신규 명령/플래그/파일 + 버전별 헤드라인 + 권장 행동
+- **`handoff`가 fresh migration-report (24h 내) 시 자동 알림** — "🆕 최근 N시간 전 migrate 차분" 블록 자동 표시. 같은 세션 내 매 handoff 호출이 AI에게 신규 도구 재안내.
+
+### 발견된 시스템 결함 (이번 라운드 해결)
+- ❌ **before 1.9.41**: migrate가 파일만 업데이트, AI 마인드셋 stale 유지 → 신규 도구 자동 호출 X
+- ✅ **1.9.41 이후**: migrate 직후 stdout + migration-report.md + handoff 모두 신규 도구를 AI 가독 포맷으로 노출 → "잊을 수 없는" 차분 안내
+
+### 자기 검증
+- 의도적으로 root를 1.9.37로 되돌림 → `leerness migrate .` 호출 → **AI must re-read 차분 자동 stdout 출력**:
+  - `📌 신규 명령: leerness release pack`
+  - 1.9.38/1.9.39/1.9.40 버전별 헤드라인 자동 추출
+  - 권장 행동 4단계 (--help, 신규 파일 재독, 인스트럭션 재독, whats-new --json)
+
+### e2e: 186/186 PASS (1.9.40 182 + 신규 4)
+
+### 정책
+- ✅ 차분 안내는 **AI 가독 포맷** (`**📌**`, `` `leerness X` `` 등 마크다운)
+- ✅ 같은 세션 내 다양한 채널 (stdout + report + handoff)로 *반복 노출* → 청크 stale 방지
+- ✅ 추출은 CHANGELOG.md 파싱 — 새 라운드 마다 자동 갱신
+
 ## 1.9.40 — 2026-05-19
 
 **dogfooding gap 차단 — `leerness release pack` 통합 명령 + audit README mismatch 자동 감지**.

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.40-green)]() [![tests](https://img.shields.io/badge/e2e-138%2F138-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.43-green)]() [![tests](https://img.shields.io/badge/e2e-195%2F195-success)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
 
 ```
   ╔══════════════════════════════════════════════════════════════╗
@@ -12,7 +12,7 @@
   ║  ██║     ██╔══╝  ██╔══╝  ██╔══██╗██║╚██╗██║██╔══╝  ╚════██║  ║
   ║  ███████╗███████╗███████╗██║  ██║██║ ╚████║███████╗███████║  ║
   ║  ╚══════╝╚══════╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝╚══════╝╚══════╝  ║
-  ║  v1.9.40   AI Agent Reliability Harness                      ║
+  ║  v1.9.43   AI Agent Reliability Harness                      ║
   ║  verify · remember · orchestrate · audit · prevent drift     ║
   ╚══════════════════════════════════════════════════════════════╝
 ```
@@ -204,6 +204,45 @@ leerness persona list / show <id> / add <id>
 leerness review <file> --persona security,performance,ux
 ```
 
+### Agent Skills 표준 (1.9.42, agentskills.io 호환)
+
+```bash
+# Claude Code/Cursor/Copilot/Codex/Gemini CLI/Hermes Agent 등 30+ 도구와 스킬 공유
+leerness skill install <url-or-path>             # SKILL.md 다운로드/import
+leerness skill discover --query "<task>"         # 매칭 추천 (opt-in)
+leerness skill export <id> [--out <dir>]         # 자체 skill → 표준 SKILL.md 변환
+leerness skill export-all [--out <dir>]          # 1.9.43 9개 자체 skill 일괄 SKILL.md export
+```
+
+### MCP Server — leerness 도구를 메인 에이전트의 sub-tool로 (1.9.43)
+
+```bash
+leerness mcp serve   # stdio JSON-RPC로 leerness 도구 10종 노출
+```
+
+Claude Code · Hermes · Cursor 등이 `.mcp.json`에 등록하면 메인 에이전트가 leerness 검수를 sub-tool로 호출 가능:
+
+```json
+{
+  "mcpServers": {
+    "leerness": {
+      "command": "npx",
+      "args": ["leerness", "mcp", "serve"]
+    }
+  }
+}
+```
+
+노출 도구 10종: `leerness_handoff` · `leerness_drift_check` · `leerness_audit` · `leerness_verify_claim` · `leerness_contract_verify` · `leerness_agents_list` · `leerness_reuse_map` · `leerness_whats_new` · `leerness_usage_stats` · `leerness_session_close`
+
+opt-in 설정 (`.env`):
+```bash
+LEERNESS_SKILL_DISCOVER_URL=https://agentskills.io/llms.txt  # 또는 자체 카탈로그 URL
+LEERNESS_SKILL_AUTO_DISCOVER=0                                 # 1=요청 자동 추천
+```
+
+> ❌ leerness는 외부 URL을 자동 fetch하지 않습니다. `LEERNESS_SKILL_DISCOVER_URL` 설정 또는 `--source` 명시 후에만 호출.
+
 ### 보안·인코딩
 
 ```bash
@@ -394,6 +433,9 @@ npm test     # = node ./scripts/e2e.js
 
 ## 변경 이력 (최근)
 
+- **1.9.43** — MCP 서버로 leerness 도구 10종 노출 (`leerness mcp serve`, Claude Code/Hermes/Cursor 등이 직접 호출 가능) · `skill export-all` (9개 일괄 SKILL.md export) · 내부 보고서 자동 비공개 (`_reports/` gitignore + npmignore).
+- **1.9.42** — [agentskills.io](https://agentskills.io) 공개 표준 호환 (Claude Code · Cursor · Copilot · Codex · Gemini CLI · Hermes Agent 등 30+ 도구와 스킬 공유): `skill install <url>` · `skill discover` (opt-in) · `skill export` (SKILL.md frontmatter) · `LEERNESS_SKILL_DISCOVER_URL` .env opt-in.
+- **1.9.41** — 디스크↔AI 컨텍스트 인지 갭 차단: `leerness whats-new` 명령 (CHANGELOG 자동 차분 추출) · `migrate` 후 stdout에 AI must re-read 차분 자동 출력 · `migration-report.md`에 신규 명령/파일 영구 기록 · `handoff`가 fresh migrate(24h 내) 시 자동 알림.
 - **1.9.40** — dogfooding gap 차단: `leerness release pack` 통합 명령 (라운드 마감 자동화 — npm pack + parent migrate + task add + close + readme sync) · `audit`에 README ↔ package.json version mismatch 자동 감지 + `--fix`로 자동 갱신.
 - **1.9.39** — AI 하네스 엔지니어링 6단계 워크플로 자동 유도 (`session-workflow.md` + handoff 끝 가이드 + AGENTS/CLAUDE 인스트럭션 통합) · `drift check --auto-fix` · `handoff --auto-recover` (critical 시 session close 자동 실행).
 - **1.9.38** — drift 자동 reminder (`agent-reminders.md`) · `usage stats` 명령 · `task sync --from <todo.json>` · drift 임계 학습 (skip ≥5 → 임계 완화).

package/bin/harness.js

@@ -6,7 +6,7 @@ const path = require('path');
 const cp = require('child_process');
 const readline = require('readline');
 
-const VERSION = '1.9.40';
+const VERSION = '1.9.43';
 const MARK = '<!-- leerness:managed -->';
 const README_START = '<!-- leerness:project-readme:start -->';
 const README_END = '<!-- leerness:project-readme:end -->';
@@ -411,10 +411,43 @@ function mergeLinesFile(p, lines) {
   writeUtf8(p, next);
 }
 
-function writeMigrationReport(root, backup, actions) {
+function writeMigrationReport(root, backup, actions, opts = {}) {
   const p = path.join(root, '.harness/migration-report.md');
   const rows = actions.map(a => `| ${a.file} | ${a.action} |`).join('\n');
-  writeUtf8(p, `# Leerness Migration Report\n\nVersion: ${VERSION}\nDate: ${now()}\nBackup: ${rel(root, backup.archiveDir)}\n\n## Policy\n\n- Existing harness, skill, and instruction files are backed up before migration.\n- Project memory files are preserved by default.\n- Managed instruction files are merged with previous content instead of being blindly overwritten.\n- .env.example/.gitignore are line-merged only.\n\n## Backed Up Candidates\n\n${backup.candidates.map(x => '- ' + x).join('\n')}\n\n## File Actions\n\n| File | Action |\n|---|---|\n${rows}\n`);
+  // 1.9.41: AI must re-read 섹션 — migrate가 추가/변경한 파일을 AI 가독 포맷으로 추출
+  // fromV가 명시되면 CHANGELOG 차분 포함
+  let aiReadBlock = '';
+  try {
+    const fromV = opts.fromV || (backup && backup.previousVersion) || null;
+    if (fromV && fromV !== VERSION) {
+      const changelogPath = path.join(__dirname, '..', 'CHANGELOG.md');
+      const cl = exists(changelogPath) ? read(changelogPath) : (exists(path.join(root, 'CHANGELOG.md')) ? read(path.join(root, 'CHANGELOG.md')) : '');
+      if (cl) {
+        const diff = _parseChangelogBetween(cl, fromV, VERSION);
+        const allCommands = new Set(), allFlags = new Set(), allFiles = new Set();
+        for (const v of diff) {
+          v.newCommands.forEach(c => allCommands.add(c));
+          v.newFlags.forEach(f => allFlags.add(f));
+          v.newFiles.forEach(f => allFiles.add(f));
+        }
+        if (diff.length) {
+          aiReadBlock = `\n## 🤖 AI must re-read (1.9.41 차분 안내)\n\n`;
+          aiReadBlock += `이 migrate는 ${fromV} → ${VERSION} 점프입니다. 메인 AI 에이전트는 다음을 인지하고 우선 활용:\n\n`;
+          if (allCommands.size) aiReadBlock += `**📌 신규 명령** (이전엔 없던 것):\n${[...allCommands].map(c => `- \`leerness ${c}\``).join('\n')}\n\n`;
+          if (allFlags.size)    aiReadBlock += `**🚩 신규 플래그**:\n${[...allFlags].map(f => `- \`${f}\``).join('\n')}\n\n`;
+          if (allFiles.size)    aiReadBlock += `**📄 신규/변경 파일** (반드시 재독):\n${[...allFiles].map(f => `- \`${f}\``).join('\n')}\n\n`;
+          aiReadBlock += `**버전별 헤드라인**:\n`;
+          for (const v of diff) {
+            const firstLine = (v.body.match(/^\*\*([^*]+)\*\*/) || [])[1]
+                           || (v.body.split('\n').find(l => l.trim() && !l.startsWith('##')) || '').trim().slice(0, 120);
+            aiReadBlock += `- ${v.version} — ${firstLine || '(no headline)'}\n`;
+          }
+          aiReadBlock += `\n**권장 행동**:\n1. 위 신규 명령을 \`--help\`로 확인\n2. \`AGENTS.md\` / \`CLAUDE.md\` / \`.harness/session-workflow.md\` 재독 (다음 \`leerness handoff\` 호출 시 자동 안내)\n3. 이전 청크의 기억 무효 — 새 도구 우선 시도\n4. 상세: \`leerness whats-new --from ${fromV}\`\n`;
+        }
+      }
+    }
+  } catch {}
+  writeUtf8(p, `# Leerness Migration Report\n\nVersion: ${VERSION}\nDate: ${now()}\nBackup: ${rel(root, backup.archiveDir)}\n${opts.fromV ? `Previous: ${opts.fromV}\n` : ''}${aiReadBlock}\n## Policy\n\n- Existing harness, skill, and instruction files are backed up before migration.\n- Project memory files are preserved by default.\n- Managed instruction files are merged with previous content instead of being blindly overwritten.\n- .env.example/.gitignore are line-merged only.\n\n## Backed Up Candidates\n\n${backup.candidates.map(x => '- ' + x).join('\n')}\n\n## File Actions\n\n| File | Action |\n|---|---|\n${rows}\n`);
 }
 
 function syncReadme(root) {
@@ -517,6 +550,14 @@ async function resolveInstallOptions(root, opts = {}) {
 
 async function install(root, opts = {}) {
   root = absRoot(root); mkdirp(root);
+  // 1.9.41: migrate 직전 이전 버전 캡처 — 차분 안내에 사용
+  try {
+    const hv = path.join(root, '.harness', 'HARNESS_VERSION');
+    if (exists(hv) && !opts._previousVersion) {
+      const parsed = parseHarnessVersion(read(hv));
+      opts._previousVersion = parsed.base || parsed.plus || null;
+    }
+  } catch {}
   // 1.9.32: init 시 ASCII 배너 + 빠른 시작 가이드 (migrate는 quiet)
   if (!opts.migration && !has('--no-banner')) _banner({ quickStart: !opts.dry });
   // 1.9.33: npx 캐시로 옛 버전이 실행될 때 경고 (migrate/--no-stale-check 시 스킵)
@@ -581,14 +622,35 @@ async function install(root, opts = {}) {
       'LEERNESS_ENABLE_CLAUDE=1',
       'LEERNESS_ENABLE_CODEX=0',
       'LEERNESS_ENABLE_GEMINI=0',
-      'LEERNESS_ENABLE_COPILOT=0'
+      'LEERNESS_ENABLE_COPILOT=0',
+      '# 1.9.42 — agentskills.io 공개 표준 스킬 자동 탐색 (opt-in). URL 설정 시 `leerness skill discover` 사용 가능.',
+      '#   예: LEERNESS_SKILL_DISCOVER_URL=https://agentskills.io/llms.txt',
+      'LEERNESS_SKILL_DISCOVER_URL=',
+      '# (선택) 사용자 요청 분석 시 자동 매칭 스킬 추천. 1=활성, 0/미설정=비활성.',
+      'LEERNESS_SKILL_AUTO_DISCOVER=0'
     ]);
     mergeLinesFile(path.join(root, '.gitattributes'), [
       '* text=auto eol=lf','*.bat text eol=crlf','*.ps1 text eol=crlf'
     ]);
     syncReadme(root);
     installSkills(root, skills);
-    writeMigrationReport(root, backup, actions);
+    // 1.9.41: migrate 시 이전 버전을 미리 캡처해 차분 안내에 사용
+    writeMigrationReport(root, backup, actions, { fromV: opts._previousVersion || null });
+    // 1.9.41: migrate 후 (= 점프인 경우) 차분 안내를 stdout에 즉시 출력 — AI 컨텍스트에 새 도구 주입
+    if (opts.migration && opts._previousVersion && opts._previousVersion !== VERSION) {
+      try {
+        const reportPath = path.join(root, '.harness', 'migration-report.md');
+        if (exists(reportPath)) {
+          const rep = read(reportPath);
+          const aiBlock = rep.match(/## 🤖 AI must re-read[\s\S]*?(?=\n## )/);
+          if (aiBlock) {
+            log('');
+            log(aiBlock[0].trim());
+            log('');
+          }
+        }
+      } catch {}
+    }
     // 1.9.1 P7: 디폴트 M-0001이 plan에 있고 progress에 row가 없으면 자동 추가
     try {
       const planText = exists(planPath(root)) ? read(planPath(root)) : '';
@@ -797,6 +859,177 @@ function skillConsolidate(root) {
   for (const c of candidates) log(`| ${c.a} | ${c.b} | ${c.score.toFixed(2)} | \`leerness skill learn <new> --capability ...\` 후 \`leerness skill remove <old>\` |`);
 }
 
+// 1.9.42: agentskills.io 표준 호환 — SKILL.md (frontmatter + 본문) + scripts/ + references/ + assets/
+// 정책: 사용자 동의 (opt-in) 후에만 외부 fetch. 기본 OFF.
+
+// SKILL.md frontmatter 파싱 (---name: ... description: ... --- 본문)
+function _parseSkillMd(text) {
+  const m = text.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+  if (!m) return { meta: {}, body: text };
+  const meta = {};
+  for (const line of m[1].split('\n')) {
+    const km = line.match(/^([a-zA-Z_-]+):\s*(.+)$/);
+    if (km) meta[km[1].trim()] = km[2].trim().replace(/^["']|["']$/g, '');
+  }
+  return { meta, body: m[2] };
+}
+
+// HTTPS fetch — Node 18+ globalThis.fetch 사용. 미지원 시 https module.
+async function _httpFetch(urlStr, opts = {}) {
+  const timeout = opts.timeout || 15000;
+  if (typeof fetch === 'function') {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+      const r = await fetch(urlStr, { signal: controller.signal });
+      clearTimeout(timer);
+      return { status: r.status, body: await r.text() };
+    } catch (e) {
+      clearTimeout(timer);
+      return { status: 0, body: '', error: e.message };
+    }
+  }
+  // fallback: https module
+  return new Promise((resolve) => {
+    const u = new URL(urlStr);
+    const lib = u.protocol === 'http:' ? require('http') : require('https');
+    const req = lib.get(urlStr, (res) => {
+      // redirect handling
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return _httpFetch(res.headers.location, opts).then(resolve);
+      }
+      let chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => resolve({ status: res.statusCode, body: Buffer.concat(chunks).toString('utf8') }));
+    });
+    req.on('error', (e) => resolve({ status: 0, body: '', error: e.message }));
+    req.setTimeout(timeout, () => { req.destroy(); resolve({ status: 0, body: '', error: 'timeout' }); });
+  });
+}
+
+// skill install <url-or-path> — SKILL.md 다운로드 + .harness/skills/<id>/에 설치
+async function skillInstallCmd(root, source) {
+  if (!source) { fail('사용법: leerness skill install <SKILL.md URL 또는 로컬 디렉토리>'); return process.exit(1); }
+  let body = '';
+  if (/^https?:\/\//.test(source)) {
+    log(`# leerness skill install (1.9.42)`);
+    log(`다운로드 중: ${source}`);
+    const r = await _httpFetch(source);
+    if (r.status !== 200) {
+      fail(`다운로드 실패 (HTTP ${r.status}${r.error ? `, ${r.error}` : ''})`);
+      return process.exit(1);
+    }
+    body = r.body;
+  } else if (exists(source)) {
+    const localPath = exists(path.join(source, 'SKILL.md')) ? path.join(source, 'SKILL.md') : source;
+    body = read(localPath);
+    log(`# leerness skill install (1.9.42)`);
+    log(`로컬 로드: ${localPath}`);
+  } else {
+    fail(`source 없음 (URL 또는 디렉토리 경로): ${source}`);
+    return process.exit(1);
+  }
+  const parsed = _parseSkillMd(body);
+  const name = parsed.meta.name || parsed.meta.id;
+  const description = parsed.meta.description || '';
+  if (!name) { fail('SKILL.md frontmatter에 `name` 필수'); return process.exit(1); }
+  // .harness/skills/<id>/SKILL.md 저장
+  const skillId = String(name).toLowerCase().replace(/[^a-z0-9._-]+/g, '-');
+  const dir = path.join(root, '.harness', 'skills', skillId);
+  mkdirp(dir);
+  writeUtf8(path.join(dir, 'SKILL.md'), body);
+  // skill.json도 함께 (자체 catalog 호환)
+  writeUtf8(path.join(dir, 'skill.json'), JSON.stringify({
+    name: skillId, displayNameKo: name, description,
+    capabilities: [], _source: 'agentskills.io',
+    verification: { status: 'unverified', method: 'agentskills.io-import' }
+  }, null, 2) + '\n');
+  log(`✓ skill installed: ${skillId}`);
+  log(`  name: ${name}`);
+  log(`  description: ${description.slice(0, 100)}`);
+  log(`  saved: ${rel(root, dir)}/`);
+  log('');
+  log(`💡 다음: leerness skill info ${skillId}`);
+}
+
+// skill discover — agentskills.io 또는 사용자 지정 URL의 카탈로그 인덱스에서 매칭 추천
+async function skillDiscoverCmd(root) {
+  const url = arg('--source', null) || process.env.LEERNESS_SKILL_DISCOVER_URL || null;
+  const query = arg('--query', null);
+  if (!url) {
+    fail([
+      'LEERNESS_SKILL_DISCOVER_URL 환경변수 또는 --source URL 필요.',
+      '예: leerness skill discover --source https://agentskills.io/llms.txt',
+      '또는 .env에 LEERNESS_SKILL_DISCOVER_URL=...',
+      '',
+      '(정책: leerness는 사용자 동의 없이 외부 URL을 fetch하지 않음 — 1.9.42 opt-in)'
+    ].join('\n'));
+    return process.exit(1);
+  }
+  log(`# leerness skill discover (1.9.42)`);
+  log(`source: ${url}`);
+  if (query) log(`query: ${query}`);
+  log(`fetching...`);
+  const r = await _httpFetch(url);
+  if (r.status !== 200) {
+    fail(`fetch 실패 (HTTP ${r.status}${r.error ? `, ${r.error}` : ''})`);
+    return process.exit(1);
+  }
+  // 카탈로그 인덱스 파싱 — agentskills.io는 llms.txt 형식 또는 raw 마크다운
+  const body = r.body;
+  // 간이 추출: SKILL.md 링크 + name + description 패턴
+  // - URL: https://.../SKILL.md
+  // - 마크다운 링크: [name](url) — description
+  const entries = [];
+  for (const m of body.matchAll(/^\s*-\s*\[([^\]]+)\]\(([^)]+)\)\s*[-—:]\s*(.+)$/gm)) {
+    entries.push({ name: m[1], url: m[2], description: m[3].trim() });
+  }
+  // URL only (개별 SKILL.md 파일)
+  if (!entries.length) {
+    for (const m of body.matchAll(/(https?:\/\/[^\s)]+SKILL\.md)/g)) {
+      entries.push({ name: m[1].split('/').slice(-2)[0], url: m[1], description: '' });
+    }
+  }
+  if (has('--json')) { log(JSON.stringify({ source: url, query, entries }, null, 2)); return; }
+  if (!entries.length) {
+    log('  (스킬 항목을 찾지 못함 — URL 형식 확인)');
+    return;
+  }
+  // 쿼리 매칭 (description 단순 포함)
+  let matched = entries;
+  if (query) {
+    const q = query.toLowerCase();
+    matched = entries.filter(e => e.name.toLowerCase().includes(q) || (e.description || '').toLowerCase().includes(q));
+    log(`매칭 ${matched.length}/${entries.length}건`);
+  } else {
+    log(`전체 ${entries.length}건 (매칭 없음 — --query로 필터링)`);
+  }
+  log('');
+  log('| name | description | url |');
+  log('|---|---|---|');
+  for (const e of matched.slice(0, 30)) {
+    log(`| ${e.name} | ${e.description.slice(0, 60)} | ${e.url} |`);
+  }
+  log('');
+  log(`💡 설치: leerness skill install <url>`);
+}
+
+// skill export <id> — 기존 자체 skill을 agentskills.io 표준 SKILL.md로 export
+function skillExportCmd(root, id) {
+  if (!id) { fail('사용법: leerness skill export <id>'); return process.exit(1); }
+  const data = loadUserSkill(root, id) || (skillCatalog[id] ? { ...skillCatalog[id], name: id } : null);
+  if (!data) { fail(`skill 없음: ${id}`); return process.exit(1); }
+  const description = data.displayNameKo || data.description || (data.capabilities && data.capabilities[0]) || id;
+  const body = `---\nname: ${id}\ndescription: ${description.slice(0, 200)}\n---\n\n# ${data.displayNameKo || id}\n\n## Capabilities\n${(data.capabilities || []).map(c => '- ' + c).join('\n') || '-'}\n\n## Sources\n${(data.sources || []).map(s => '- ' + (s.url || s)).join('\n') || '-'}\n\n## Patterns\n${(data.patterns || []).map(p => `- \`${p.command}\` — ${p.note || ''}`).join('\n') || '-'}\n`;
+  const outDir = arg('--out', path.join(root, '.harness', 'skills-export', id));
+  mkdirp(outDir);
+  const outPath = path.join(outDir, 'SKILL.md');
+  writeUtf8(outPath, body);
+  log(`✓ exported to ${rel(root, outPath)}`);
+  log('');
+  log(`💡 공유 가능 — 다른 도구가 \`leerness skill install ${outPath}\` 또는 URL로 import`);
+}
+
 const planPath = root => path.join(root, '.harness/plan.md');
 const progressPath = root => path.join(root, '.harness/progress-tracker.md');
 const taskLogPath = root => path.join(root, '.harness/task-log.md');
@@ -1425,6 +1658,29 @@ function handoff(root) {
     const cs = read(currentStatePath(root)).replace(/Updated: \d{4}-\d{2}-\d{2}/, `Updated: ${today()}`);
     writeUtf8(currentStatePath(root), cs);
   }
+  // 1.9.41: 최근 migrate 차분 알림 — migration-report.md가 24h 내면 "AI must re-read" 블록 자동 표시
+  // 같은 채팅 세션의 AI 청크가 이전 버전 마인드셋이어도 새 도구를 즉시 인지하도록.
+  if (!has('--no-workflow-guide') && !has('--compact')) {
+    try {
+      const reportPath = path.join(root, '.harness', 'migration-report.md');
+      if (exists(reportPath)) {
+        const stat = fs.statSync(reportPath);
+        const ageHr = (Date.now() - stat.mtimeMs) / 3600000;
+        if (ageHr < 24) {
+          const rep = read(reportPath);
+          const aiBlock = rep.match(/## 🤖 AI must re-read[\s\S]*?(?=\n## )/);
+          if (aiBlock) {
+            const isTty = process.stdout && process.stdout.isTTY;
+            const yel = s => isTty ? `\x1b[33m${s}\x1b[0m` : s;
+            log('');
+            log(yel(`## 🆕 최근 ${ageHr.toFixed(1)}시간 전 migrate 차분 — AI 에이전트는 신규 도구 우선 시도`));
+            log(aiBlock[0].trim());
+            log('');
+          }
+        }
+      }
+    } catch {}
+  }
   // 1.9.39: handoff 출력 끝에 6단계 워크플로 가이드 자동 표시 (메인 에이전트가 매 세션 인지)
   if (!has('--no-workflow-guide') && !has('--compact') && process.env.LEERNESS_NO_WORKFLOW_GUIDE !== '1') {
     const isTty = process.stdout && process.stdout.isTTY;
@@ -5698,6 +5954,228 @@ function _bumpUsage(root, cmdName) {
   } catch {}
 }
 
+// 1.9.41: CHANGELOG.md를 파싱하여 from → to 사이 버전 차분 추출
+// 반환: [{ version, date, body, newCommands, newFlags, newFiles }]
+function _parseChangelogBetween(changelogText, fromV, toV) {
+  // ## 1.9.X — YYYY-MM-DD 헤더 사이의 텍스트 추출
+  const sections = [];
+  const re = /^## (\d+\.\d+\.\d+)(?:\s+—\s+(\d{4}-\d{2}-\d{2}))?\s*\n([\s\S]*?)(?=^## \d+\.\d+\.\d+|$)/gm;
+  let m;
+  while ((m = re.exec(changelogText)) !== null) {
+    sections.push({ version: m[1], date: m[2] || null, body: m[3].trim() });
+  }
+  // from < V <= to 만 (fromV 자체는 이미 적용된 버전이므로 제외)
+  const ranged = sections.filter(s => {
+    const cmp = (v1, v2) => {
+      const a = v1.split('.').map(Number), b = v2.split('.').map(Number);
+      for (let i = 0; i < 3; i++) { if (a[i] !== b[i]) return a[i] - b[i]; }
+      return 0;
+    };
+    return cmp(s.version, fromV) > 0 && cmp(s.version, toV) <= 0;
+  });
+  // 각 섹션에서 신규 명령/플래그/파일 추출
+  for (const s of ranged) {
+    s.newCommands = [];
+    s.newFlags = [];
+    s.newFiles = [];
+    // `leerness X [...]` 또는 backtick에 싸인 leerness 명령
+    for (const cm of s.body.matchAll(/`leerness\s+([a-z][\w-]*(?:\s+[a-z][\w-]*)?)/g)) {
+      const cmd = cm[1].trim();
+      if (!s.newCommands.includes(cmd)) s.newCommands.push(cmd);
+    }
+    // `--xxx` 플래그
+    for (const fm of s.body.matchAll(/`(--[a-z][\w-]*)`/g)) {
+      if (!s.newFlags.includes(fm[1])) s.newFlags.push(fm[1]);
+    }
+    // .harness/X.md 같은 신규 파일
+    for (const ff of s.body.matchAll(/`(\.harness\/[\w./-]+\.(?:md|json|jsonl))`/g)) {
+      if (!s.newFiles.includes(ff[1])) s.newFiles.push(ff[1]);
+    }
+  }
+  return ranged;
+}
+
+// 1.9.41: leerness whats-new [--from V] — 현재 워크스페이스 버전 → leerness latest 차분
+// 1.9.43: skill export-all — 모든 자체 skill을 agentskills.io 표준 SKILL.md로 일괄 export
+function skillExportAllCmd(root) {
+  root = absRoot(root || process.cwd());
+  const all = listAllSkills(root);
+  const ids = Object.keys(all);
+  const outDir = arg('--out', path.join(root, '.harness', 'skills-export'));
+  mkdirp(outDir);
+  let exported = 0;
+  log(`# leerness skill export-all (1.9.43)`);
+  log(`총 ${ids.length}개 skill → ${rel(root, outDir)}/`);
+  log('');
+  for (const id of ids) {
+    const data = all[id];
+    const description = (data.displayNameKo || data.description || (data.capabilities && data.capabilities[0]) || id).slice(0, 200);
+    const body = `---\nname: ${id}\ndescription: ${description}\n---\n\n# ${data.displayNameKo || id}\n\n## Capabilities\n${(data.capabilities || []).map(c => '- ' + c).join('\n') || '-'}\n\n## Sources\n${(data.sources || []).map(s => '- ' + (s.url || s)).join('\n') || '-'}\n`;
+    const skillDir = path.join(outDir, id);
+    mkdirp(skillDir);
+    writeUtf8(path.join(skillDir, 'SKILL.md'), body);
+    log(`  ✓ ${id} → ${rel(root, path.join(skillDir, 'SKILL.md'))}`);
+    exported++;
+  }
+  log('');
+  log(`✅ ${exported}개 skill 일괄 export 완료`);
+  log(`💡 다른 도구에서: leerness skill install <SKILL.md path>`);
+}
+
+// 1.9.43: MCP server — stdio JSON-RPC로 leerness 도구 노출 (Claude Code/Hermes 등이 호출)
+// 프로토콜: MCP 표준 (JSON-RPC 2.0). 메서드: initialize, tools/list, tools/call
+function mcpServeCmd(root) {
+  root = absRoot(root || process.cwd());
+  // 노출할 leerness 도구 목록
+  const TOOLS = [
+    { name: 'leerness_handoff', description: '워크스페이스 컨텍스트(plan/progress/decisions) 적재', inputSchema: { type: 'object', properties: { path: { type: 'string' } } } },
+    { name: 'leerness_drift_check', description: 'AI 에이전트 leerness 미사용 drift 자동 감지 (4 신호 + 4단계 레벨)', inputSchema: { type: 'object', properties: { path: { type: 'string' } } } },
+    { name: 'leerness_audit', description: '워크스페이스 일관성 감사 (verify + scan + encoding + lazy 통합)', inputSchema: { type: 'object', properties: { path: { type: 'string' }, fix: { type: 'boolean' } } } },
+    { name: 'leerness_verify_claim', description: 'AI 거짓 완료 자동 검증 (evidence 파일 + 실 테스트 실행)', inputSchema: { type: 'object', properties: { taskId: { type: 'string' }, path: { type: 'string' }, runTests: { type: 'boolean' }, strictClaims: { type: 'boolean' } }, required: ['taskId'] } },
+    { name: 'leerness_contract_verify', description: '명세 ↔ 구현 함수/필드 일치 자동 검사', inputSchema: { type: 'object', properties: { spec: { type: 'string' }, impl: { type: 'string' } }, required: ['spec', 'impl'] } },
+    { name: 'leerness_agents_list', description: '외부 AI CLI 가용성 표 (claude/codex/gemini/copilot 상태 + 환경변수 활성화 여부)', inputSchema: { type: 'object', properties: {} } },
+    { name: 'leerness_reuse_map', description: '워크스페이스 중복 함수/capability 자동 감지 (--all-apps + fuzzy 매칭)', inputSchema: { type: 'object', properties: { path: { type: 'string' }, allApps: { type: 'boolean' }, strictElements: { type: 'boolean' } } } },
+    { name: 'leerness_whats_new', description: 'CHANGELOG 차분 자동 추출 (from → to 사이 신규 명령/플래그/파일)', inputSchema: { type: 'object', properties: { from: { type: 'string' }, to: { type: 'string' } } } },
+    { name: 'leerness_usage_stats', description: 'leerness 명령별 누적 호출 통계 + drift 통계', inputSchema: { type: 'object', properties: { path: { type: 'string' } } } },
+    { name: 'leerness_session_close', description: '세션 마감 — handoff/current-state/task-log 자동 갱신', inputSchema: { type: 'object', properties: { path: { type: 'string' } } } }
+  ];
+
+  function send(obj) {
+    process.stdout.write(JSON.stringify(obj) + '\n');
+  }
+  function callLeerness(cliArgs) {
+    const r = cp.spawnSync(process.execPath, [__filename, ...cliArgs], {
+      encoding: 'utf8',
+      timeout: 60000,
+      env: { ...process.env, LEERNESS_NO_BANNER: '1', LEERNESS_NO_STALE_CHECK: '1', LEERNESS_NO_DRIFT_CHECK: '1', LEERNESS_NO_PROMPT: '1', LEERNESS_NO_WORKFLOW_GUIDE: '1' }
+    });
+    return { ok: r.status === 0, exit: r.status, stdout: r.stdout || '', stderr: r.stderr || '' };
+  }
+  function handleRequest(req) {
+    const id = req.id;
+    if (req.method === 'initialize') {
+      send({ jsonrpc: '2.0', id, result: {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'leerness', version: VERSION }
+      } });
+    } else if (req.method === 'tools/list') {
+      send({ jsonrpc: '2.0', id, result: { tools: TOOLS } });
+    } else if (req.method === 'tools/call') {
+      const { name, arguments: args = {} } = req.params || {};
+      const targetPath = args.path || root;
+      let cliArgs;
+      try {
+        switch (name) {
+          case 'leerness_handoff':         cliArgs = ['handoff', targetPath, '--compact', '--no-drift-check']; break;
+          case 'leerness_drift_check':     cliArgs = ['drift', 'check', targetPath]; break;
+          case 'leerness_audit':           cliArgs = ['audit', targetPath, ...(args.fix ? ['--fix'] : [])]; break;
+          case 'leerness_verify_claim':    cliArgs = ['verify-claim', args.taskId, '--path', targetPath, ...(args.runTests ? ['--run-tests'] : []), ...(args.strictClaims ? ['--strict-claims'] : [])]; break;
+          case 'leerness_contract_verify': cliArgs = ['contract', 'verify', args.spec, args.impl]; break;
+          case 'leerness_agents_list':     cliArgs = ['agents', 'list', '--json']; break;
+          case 'leerness_reuse_map':       cliArgs = ['reuse-map', targetPath, ...(args.allApps ? ['--all-apps'] : []), ...(args.strictElements ? ['--strict-elements'] : []), '--json']; break;
+          case 'leerness_whats_new':       cliArgs = ['whats-new', '--path', targetPath, ...(args.from ? ['--from', args.from] : []), ...(args.to ? ['--to', args.to] : []), '--json']; break;
+          case 'leerness_usage_stats':     cliArgs = ['usage', 'stats', targetPath, '--json']; break;
+          case 'leerness_session_close':   cliArgs = ['session', 'close', targetPath]; break;
+          default:
+            return send({ jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown tool: ${name}` } });
+        }
+        const r = callLeerness(cliArgs);
+        send({ jsonrpc: '2.0', id, result: {
+          content: [{ type: 'text', text: (r.stdout || r.stderr || '(no output)').slice(0, 50000) }],
+          isError: !r.ok
+        } });
+      } catch (e) {
+        send({ jsonrpc: '2.0', id, error: { code: -32603, message: 'Internal error: ' + e.message } });
+      }
+    } else {
+      send({ jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown method: ${req.method}` } });
+    }
+  }
+
+  // stdin JSON-RPC 한 줄 단위
+  let buf = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => {
+    buf += chunk;
+    let nl;
+    while ((nl = buf.indexOf('\n')) !== -1) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      try {
+        const req = JSON.parse(line);
+        handleRequest(req);
+      } catch (e) {
+        send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error: ' + e.message } });
+      }
+    }
+  });
+  process.stdin.on('end', () => process.exit(0));
+  // 인터럽트 처리
+  process.on('SIGINT', () => process.exit(0));
+  process.on('SIGTERM', () => process.exit(0));
+}
+
+function whatsNewCmd(root) {
+  root = absRoot(root || process.cwd());
+  const fromV = arg('--from', null) || (function () {
+    const hv = path.join(root, '.harness', 'HARNESS_VERSION');
+    if (exists(hv)) { try { return parseHarnessVersion(read(hv)).base || parseHarnessVersion(read(hv)).plus; } catch { return null; } }
+    return null;
+  })();
+  const toV = arg('--to', null) || VERSION;
+  if (!fromV) {
+    fail('현재 버전을 파악할 수 없습니다. --from <version> 명시');
+    return process.exit(1);
+  }
+  // CHANGELOG.md — 우선 root, 없으면 leerness-pkg 자체
+  let changelogPath = path.join(root, 'CHANGELOG.md');
+  if (!exists(changelogPath)) changelogPath = path.join(__dirname, '..', 'CHANGELOG.md');
+  if (!exists(changelogPath)) {
+    fail('CHANGELOG.md 없음');
+    return process.exit(1);
+  }
+  const diff = _parseChangelogBetween(read(changelogPath), fromV, toV);
+  if (has('--json')) { log(JSON.stringify({ from: fromV, to: toV, versions: diff }, null, 2)); return; }
+  if (!diff.length) {
+    log(`# leerness whats-new (1.9.41)`);
+    log(`현재 ${fromV} ↔ 대상 ${toV}: 새 항목 없음 (또는 CHANGELOG에 기록 안 됨)`);
+    return;
+  }
+  log(`# leerness whats-new (1.9.41)`);
+  log(`현재 워크스페이스 버전: ${fromV} → 대상: ${toV}`);
+  log(`범위: ${diff.length}개 버전 (${diff[0].version} → ${diff[diff.length - 1].version})`);
+  log('');
+  // AI 가독 요약 — 각 버전당 한 줄 + 신규 명령/플래그/파일
+  log(`## 🆕 신규 명령·플래그·파일 (AI 에이전트는 다음 명령을 우선 시도)`);
+  const allCommands = new Set();
+  const allFlags = new Set();
+  const allFiles = new Set();
+  for (const v of diff) {
+    v.newCommands.forEach(c => allCommands.add(c));
+    v.newFlags.forEach(f => allFlags.add(f));
+    v.newFiles.forEach(f => allFiles.add(f));
+  }
+  if (allCommands.size) log(`  📌 신규 명령: ${[...allCommands].join(', ')}`);
+  if (allFlags.size)    log(`  🚩 신규 플래그: ${[...allFlags].join(', ')}`);
+  if (allFiles.size)    log(`  📄 신규 파일: ${[...allFiles].join(', ')}`);
+  log('');
+  log(`## 📜 버전별 헤드라인`);
+  for (const v of diff) {
+    // body 첫 줄(또는 strong header) 추출
+    const firstLine = (v.body.match(/^\*\*([^*]+)\*\*/) || [])[1]
+                   || (v.body.split('\n').find(l => l.trim() && !l.startsWith('##')) || '').trim().slice(0, 120);
+    log(`  • ${v.version}${v.date ? ` (${v.date})` : ''} — ${firstLine || '(no headline)'}`);
+  }
+  log('');
+  log(`## 💡 권장 행동`);
+  log(`  1. 위 신규 명령들을 시도해 보세요 (예: \`leerness <명령> --help\`)`);
+  log(`  2. 신규 파일들을 읽어 보세요 (예: \`cat .harness/session-workflow.md\`)`);
+  log(`  3. AGENTS.md/CLAUDE.md 재독 — migrate가 인스트럭션을 업데이트했을 수 있음`);
+  log(`  4. 상세: \`cat CHANGELOG.md\` 또는 \`leerness whats-new --json\``);
+}
+
 function usageStatsCmd(root) {
   root = absRoot(root || process.cwd());
   const stats = _readUsageStats(root);
@@ -5963,6 +6441,7 @@ async function main() {
   if (cmd === 'contract' && args[1] === 'verify') return contractVerifyCmd(args[2], args[3]);
   if (cmd === 'drift' && (args[1] === 'check' || !args[1])) return driftCheckCmd(args[2] || arg('--path', process.cwd()));
   if (cmd === 'usage' && (args[1] === 'stats' || !args[1])) return usageStatsCmd(args[2] || arg('--path', process.cwd()));
+  if (cmd === 'whats-new') return whatsNewCmd(args[1] || arg('--path', process.cwd()));
   if (cmd === 'reuse' && args[1] === 'autodetect') return reuseAutodetectCmd(args[2] || arg('--path', process.cwd()));
   if (cmd === 'setup-agents' || cmd === 'setup' && args[1] === 'agents') return await setupAgentsCmd(args[1] && args[1] !== 'agents' ? args[1] : (args[2] || process.cwd()));
   if (cmd === 'session' && args[1] === 'close') { const r = sessionClose(args[2] || process.cwd()); viewworkEmit(args[2] || process.cwd(), { action: 'task', tool: 'session-close', note: 'session close' }); return r; }
@@ -5982,6 +6461,11 @@ async function main() {
   if (cmd === 'skill' && args[1] === 'optimize')    return skillOptimize(absRoot(arg('--path', process.cwd())), args[2]);
   if (cmd === 'skill' && args[1] === 'remove')      return skillRemove(absRoot(arg('--path', process.cwd())), args[2]);
   if (cmd === 'skill' && args[1] === 'consolidate') return skillConsolidate(absRoot(arg('--path', process.cwd())));
+  if (cmd === 'skill' && args[1] === 'install')     return await skillInstallCmd(absRoot(arg('--path', process.cwd())), args[2]);
+  if (cmd === 'skill' && args[1] === 'discover')    return await skillDiscoverCmd(absRoot(arg('--path', process.cwd())));
+  if (cmd === 'skill' && args[1] === 'export')      return skillExportCmd(absRoot(arg('--path', process.cwd())), args[2]);
+  if (cmd === 'skill' && args[1] === 'export-all')  return skillExportAllCmd(absRoot(arg('--path', process.cwd())));
+  if (cmd === 'mcp' && args[1] === 'serve')         return mcpServeCmd(absRoot(arg('--path', process.cwd())));
   if (cmd === 'gate')                               return gate(args[1] || process.cwd());
   if (cmd === 'verify-code')                        return verifyCodeCmd(args[1] || process.cwd());
   if (cmd === 'lessons')                            return lessonsCmd(arg('--path', process.cwd()));

package/package.json

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

package/scripts/e2e.js

@@ -950,6 +950,202 @@ total++;
   if (!ok) { failed++; console.log(r.stdout.slice(0, 800)); }
 }
 
+// 1.9.43 회귀: MCP server + skill export-all + _reports 비공개
+total++;
+{
+  // skill export-all: 모든 내장 skill을 SKILL.md로 일괄 export
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-exall-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpC, '--yes', '--no-banner', '--no-stale-check', '--language', 'ko', '--skills', 'all'], { stdio: 'ignore', timeout: 30000 });
+  const r = cp.spawnSync(process.execPath, [CLI, 'skill', 'export-all', '--path', tmpC], { encoding: 'utf8', timeout: 30000 });
+  const exportDir = path.join(tmpC, '.harness', 'skills-export');
+  const exists2 = fs.existsSync(exportDir);
+  const count = exists2 ? fs.readdirSync(exportDir).length : 0;
+  const ok = r.status === 0 && exists2 && count >= 5;
+  console.log(ok ? `✓ B(1.9.43) skill export-all: ${count}개 skill 일괄 SKILL.md 생성` : `✗ export-all 실패 (count=${count})`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
+}
+
+total++;
+{
+  // MCP server initialize: stdio JSON-RPC 정상 응답
+  const r = cp.spawnSync(process.execPath, [CLI, 'mcp', 'serve'], {
+    encoding: 'utf8', timeout: 10000,
+    input: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize' }) + '\n'
+  });
+  let parsed = null;
+  try { parsed = JSON.parse(r.stdout.split('\n').filter(Boolean)[0]); } catch {}
+  const ok = parsed
+    && parsed.jsonrpc === '2.0'
+    && parsed.id === 1
+    && parsed.result
+    && parsed.result.serverInfo
+    && parsed.result.serverInfo.name === 'leerness';
+  console.log(ok ? '✓ B(1.9.43) MCP server initialize: JSON-RPC 표준 응답 + serverInfo' : `✗ MCP initialize 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
+}
+
+total++;
+{
+  // MCP server tools/list: 10개 도구 노출
+  const r = cp.spawnSync(process.execPath, [CLI, 'mcp', 'serve'], {
+    encoding: 'utf8', timeout: 10000,
+    input: JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list' }) + '\n'
+  });
+  let parsed = null;
+  try { parsed = JSON.parse(r.stdout.split('\n').filter(Boolean)[0]); } catch {}
+  const ok = parsed
+    && Array.isArray(parsed.result && parsed.result.tools)
+    && parsed.result.tools.length >= 8
+    && parsed.result.tools.some(t => t.name === 'leerness_verify_claim')
+    && parsed.result.tools.some(t => t.name === 'leerness_drift_check');
+  console.log(ok ? `✓ B(1.9.43) MCP tools/list: ${parsed.result.tools.length}개 leerness 도구 노출` : `✗ MCP tools/list 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
+}
+
+total++;
+{
+  // .gitignore에 _reports/ 포함 — leerness-pkg
+  const giPath = path.join(__dirname, '..', '.gitignore');
+  const body = fs.existsSync(giPath) ? fs.readFileSync(giPath, 'utf8') : '';
+  const ok = /_reports\//.test(body) && /\*\.private\.md/.test(body);
+  console.log(ok ? '✓ B(1.9.43) leerness-pkg/.gitignore: _reports/ + *.private.md 차단' : `✗ .gitignore 실패`);
+  if (!ok) { failed++; console.log(body.slice(0, 300)); }
+}
+
+total++;
+{
+  // .npmignore에 _reports/ + 보고서 차단 명시
+  const niPath = path.join(__dirname, '..', '.npmignore');
+  const body = fs.existsSync(niPath) ? fs.readFileSync(niPath, 'utf8') : '';
+  const ok = /_reports\//.test(body) && /\*\.private/.test(body);
+  console.log(ok ? '✓ B(1.9.43) leerness-pkg/.npmignore: _reports/ 차단' : `✗ .npmignore 실패`);
+  if (!ok) { failed++; console.log(body.slice(0, 300)); }
+}
+
+// 1.9.42 회귀: agentskills.io 표준 호환 (skill install/discover/export + .env opt-in)
+total++;
+{
+  // skill discover: env 없으면 opt-in 안내로 거부
+  const env = { ...process.env };
+  delete env.LEERNESS_SKILL_DISCOVER_URL;
+  const r = cp.spawnSync(process.execPath, [CLI, 'skill', 'discover'], { encoding: 'utf8', timeout: 10000, env });
+  const ok = r.status !== 0 && /LEERNESS_SKILL_DISCOVER_URL.*필요|opt-in/.test(r.stdout + r.stderr);
+  console.log(ok ? '✓ B(1.9.42) skill discover: env 없으면 opt-in 안내 거부' : `✗ discover opt-in 실패`);
+  if (!ok) { failed++; console.log((r.stdout + r.stderr).slice(0, 400)); }
+}
+
+total++;
+{
+  // skill export → SKILL.md frontmatter 정확 생성
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-skex-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpC, '--yes', '--no-banner', '--no-stale-check', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  const r = cp.spawnSync(process.execPath, [CLI, 'skill', 'export', 'office', '--path', tmpC], { encoding: 'utf8', timeout: 15000 });
+  const skillFile = path.join(tmpC, '.harness', 'skills-export', 'office', 'SKILL.md');
+  const exists2 = fs.existsSync(skillFile);
+  const body = exists2 ? fs.readFileSync(skillFile, 'utf8') : '';
+  const ok = r.status === 0
+    && exists2
+    && /^---\nname: office\ndescription:/.test(body)
+    && /\n---\n/.test(body);
+  console.log(ok ? '✓ B(1.9.42) skill export: agentskills.io 표준 SKILL.md frontmatter 생성' : `✗ export 실패`);
+  if (!ok) { failed++; console.log(body.slice(0, 300) || r.stdout.slice(0, 300)); }
+}
+
+total++;
+{
+  // skill install: 로컬 SKILL.md import → .harness/skills/<id>/SKILL.md 자동 배치
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-skin-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpC, '--yes', '--no-banner', '--no-stale-check', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  // 로컬 SKILL.md 직접 작성
+  const skillSrc = path.join(tmpC, 'test-skill.md');
+  fs.writeFileSync(skillSrc, '---\nname: my-test-skill\ndescription: agentskills.io 표준 호환 e2e 검증\n---\n\n# Test Skill\n\n본문 내용.\n', 'utf8');
+  const r = cp.spawnSync(process.execPath, [CLI, 'skill', 'install', skillSrc, '--path', tmpC], { encoding: 'utf8', timeout: 15000 });
+  const installedFile = path.join(tmpC, '.harness', 'skills', 'my-test-skill', 'SKILL.md');
+  const ok = r.status === 0
+    && fs.existsSync(installedFile)
+    && /my-test-skill/.test(fs.readFileSync(installedFile, 'utf8'));
+  console.log(ok ? '✓ B(1.9.42) skill install: 로컬 SKILL.md → .harness/skills/<id>/ 배치' : `✗ install 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
+}
+
+total++;
+{
+  // skill install이 skill.json도 자동 작성 (자체 catalog 호환)
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-skin2-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpC, '--yes', '--no-banner', '--no-stale-check', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  const skillSrc = path.join(tmpC, 'test-skill2.md');
+  fs.writeFileSync(skillSrc, '---\nname: dual-format\ndescription: skill.json + SKILL.md 양쪽 자동 생성\n---\n\n# Dual\n', 'utf8');
+  cp.spawnSync(process.execPath, [CLI, 'skill', 'install', skillSrc, '--path', tmpC], { stdio: 'ignore', timeout: 15000 });
+  const jsonFile = path.join(tmpC, '.harness', 'skills', 'dual-format', 'skill.json');
+  const json = fs.existsSync(jsonFile) ? JSON.parse(fs.readFileSync(jsonFile, 'utf8')) : null;
+  const ok = json
+    && json.name === 'dual-format'
+    && json._source === 'agentskills.io'
+    && json.verification && json.verification.method === 'agentskills.io-import';
+  console.log(ok ? '✓ B(1.9.42) skill install: skill.json 자동 생성 + _source 추적' : `✗ skill.json 실패`);
+  if (!ok) { failed++; console.log(JSON.stringify(json || {})); }
+}
+
+// 1.9.41 회귀: whats-new 명령 + migrate 차분 AI must re-read + handoff fresh 알림
+total++;
+{
+  // whats-new --from 큰 점프 → 신규 명령 추출
+  const r = cp.spawnSync(process.execPath, [CLI, 'whats-new', '--from', '1.9.33', '--json'], { encoding: 'utf8', timeout: 15000 });
+  let parsed = null;
+  try { parsed = JSON.parse(r.stdout); } catch {}
+  const ok = parsed
+    && parsed.from === '1.9.33'
+    && Array.isArray(parsed.versions)
+    && parsed.versions.length >= 5
+    && parsed.versions.some(v => v.newCommands && v.newCommands.length > 0);
+  console.log(ok ? '✓ B(1.9.41) whats-new --from 1.9.33: 5+ 버전 차분 + 신규 명령 추출' : `✗ whats-new 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
+}
+
+total++;
+{
+  // migrate가 fromV가 있는 경우 AI must re-read 블록을 stdout에 출력
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-mig-'));
+  // 1.9.30 표시로 init한 척 (HARNESS_VERSION 직접 작성)
+  fs.mkdirSync(path.join(tmpC, '.harness'), { recursive: true });
+  fs.writeFileSync(path.join(tmpC, '.harness', 'HARNESS_VERSION'), 'leerness@1.9.36\n', 'utf8');
+  const r = cp.spawnSync(process.execPath, [CLI, 'migrate', tmpC, '--yes', '--no-banner', '--no-stale-check'], { encoding: 'utf8', timeout: 60000 });
+  const ok = r.status === 0
+    && /AI must re-read/.test(r.stdout)
+    && /1\.9\.36 → 1\.9\.\d+/.test(r.stdout)
+    && /신규 명령/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.41) migrate stdout: AI must re-read 차분 자동 출력' : `✗ migrate 차분 출력 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(-800)); }
+}
+
+total++;
+{
+  // migration-report.md에 AI must re-read 섹션 영구 기록
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-mig2-'));
+  fs.mkdirSync(path.join(tmpC, '.harness'), { recursive: true });
+  fs.writeFileSync(path.join(tmpC, '.harness', 'HARNESS_VERSION'), 'leerness@1.9.30\n', 'utf8');
+  cp.spawnSync(process.execPath, [CLI, 'migrate', tmpC, '--yes', '--no-banner', '--no-stale-check'], { stdio: 'ignore', timeout: 60000 });
+  const reportPath = path.join(tmpC, '.harness', 'migration-report.md');
+  const body = fs.existsSync(reportPath) ? fs.readFileSync(reportPath, 'utf8') : '';
+  const ok = /## 🤖 AI must re-read/.test(body) && /Previous: 1\.9\.30/.test(body);
+  console.log(ok ? '✓ B(1.9.41) migration-report.md: AI must re-read 섹션 + Previous 버전 기록' : `✗ report 기록 실패`);
+  if (!ok) { failed++; console.log(body.slice(0, 600)); }
+}
+
+total++;
+{
+  // handoff가 fresh migration-report (24h 내) 시 자동 알림
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-fresh-'));
+  fs.mkdirSync(path.join(tmpC, '.harness'), { recursive: true });
+  fs.writeFileSync(path.join(tmpC, '.harness', 'HARNESS_VERSION'), 'leerness@1.9.30\n', 'utf8');
+  cp.spawnSync(process.execPath, [CLI, 'migrate', tmpC, '--yes', '--no-banner', '--no-stale-check'], { stdio: 'ignore', timeout: 60000 });
+  const r = cp.spawnSync(process.execPath, [CLI, 'handoff', tmpC, '--no-drift-check'], { encoding: 'utf8', timeout: 15000 });
+  const ok = r.status === 0
+    && /최근.*시간 전 migrate 차분|AI must re-read/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.41) handoff: 최근 migrate 차분 자동 표시 (24h 내)' : `✗ handoff 차분 알림 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(-500)); }
+}
+
 // 1.9.40 회귀: release pack 통합 명령 + audit README mismatch 감지
 total++;
 {