leerness 1.9.52 → 1.9.55

package/CHANGELOG.md

@@ -1,5 +1,70 @@
 # Changelog
 
+## 1.9.55 — 2026-05-19
+
+**MCP server 12 도구 — `leerness_skill_suggest` + `leerness_lessons` 노출**.
+
+### Added
+- **MCP `leerness_skill_suggest`** (1.9.53 자동 학습을 외부 노출):
+  - Claude Code/Hermes/Cursor가 `tools/call`로 호출 가능
+  - args: `{ path, min, days }` → JSON candidates 반환
+- **MCP `leerness_lessons`** (1.9.7/54 lessons를 외부 노출):
+  - args: `{ path, query, auto, limit }`
+- MCP 총 **10 → 12 도구**
+
+## 1.9.54 — 2026-05-19
+
+**`leerness lessons --auto` — 과거 lessons 자동 재상기**.
+
+### Added
+- **`leerness lessons --auto [--path X]`**:
+  - 가장 최근 in-progress/planned task의 `request` 컬럼에서 키워드 자동 추출
+  - 그 키워드로 lessons 자동 검색 (decisions / review-evidence / task-log / handoff)
+  - 임계: 4자+ 키워드, 가장 긴 단어 선택
+  - stopword 자동 제외 (한국어 + 영어 20+ 단어)
+- **stopword 확장** (1.9.55 패치): "프로젝트/관리/기능/시스템" 등 너무 일반적인 단어 제외
+
+### 검증 (stress-v6)
+- Q1-Q3 (lessons --auto) 3/3 PASS
+- R1-R3 (MCP 12 도구 + 신규 호출) 3/3 PASS
+- S1-S4 (1.9.43~53 누적 회귀) 4/4 PASS
+- **stress-v6: 10/10 PASS**, e2e: **208/208 PASS**
+
+### 발견·패치 (stress-v6)
+- 🟡 stopword 부족 → "프로젝트"가 default task에서 키워드로 잡혀 false positive
+- 1.9.55 패치: stopword 20+ 단어로 확장
+
+## 1.9.53 — 2026-05-19
+
+**`leerness skill suggest` — Hermes-style 자동 학습 (사용 패턴 → skill 후보 자동 제안)**.
+
+### 배경
+1.9.2부터 `skill learn` / `skill use` / `skill optimize` / `skill consolidate` / `lessons` / `rule add` 등 자체 학습 인프라가 있었으나, **모두 명시 호출 필요**. Hermes처럼 *사용 중* 자동으로 새 skill을 만들지 못함.
+
+### Added
+- **`leerness skill suggest [--min N] [--days N] [--json]`** — Hermes-style 자동 학습의 leerness 버전:
+  - **task-log.md** — `` `leerness X` `` 명령 인용 패턴 감지
+  - **progress-tracker.md** — request/nextAction 컬럼의 4자+ 키워드
+  - **usage-stats.json** — 명령별 누적 카운트
+  - 임계 (`--min`, 기본 3회) 이상 + **기존 skill에 없는** 키워드만 후보로
+  - `--days N` lookback (기본 30일)
+  - 출처 (`task-log` / `progress` / `usage`) 자동 분류
+- 실 워크스페이스 검증: 본 프로젝트에서 6 후보 자동 감지 (leerness 22회, publish 14회, github 5회 등)
+
+### Hermes vs leerness 학습 비교 (1.9.53 후)
+| 영역 | Hermes | leerness |
+|---|---|---|
+| 새 skill 자동 생성 | ✅ LLM 기반 | ⚠ 후보 제안만 (수동 등록 권장) |
+| **반복 패턴 감지** | ✅ | ✅ **1.9.53 신규** |
+| 사용 카운트 추적 | ✅ | ✅ 1.9.38 |
+| 중복 자동 통합 | ✅ | ✅ 1.9.2 `skill consolidate` |
+| 외부 docs 학습 | ✅ | ✅ 1.9.2 `skill learn --doc` |
+
+### 검증 (필수 stress-v5)
+- O1-O5 (skill suggest 시나리오) 5/5 PASS
+- P1-P5 (1.9.43~52 누적 회귀) 5/5 PASS
+- **stress-v5: 10/10 PASS** + e2e: **206/206 PASS**
+
 ## 1.9.52 — 2026-05-19
 
 **`skill discover` 카탈로그 형식 다양성 (JSON/RSS/Markdown/llms.txt 자동 감지)**.

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.52-green)]() [![tests](https://img.shields.io/badge/e2e-205%2F205-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.55-green)]() [![tests](https://img.shields.io/badge/e2e-208%2F208-success)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
 
 ```
   ╔══════════════════════════════════════════════════════════════╗
@@ -12,7 +12,7 @@
   ║  ██║     ██╔══╝  ██╔══╝  ██╔══██╗██║╚██╗██║██╔══╝  ╚════██║  ║
   ║  ███████╗███████╗███████╗██║  ██║██║ ╚████║███████╗███████║  ║
   ║  ╚══════╝╚══════╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝╚══════╝╚══════╝  ║
-  ║  v1.9.52   AI Agent Reliability Harness                      ║
+  ║  v1.9.55   AI Agent Reliability Harness                      ║
   ║  verify · remember · orchestrate · audit · prevent drift     ║
   ╚══════════════════════════════════════════════════════════════╝
 ```
@@ -433,6 +433,9 @@ npm test     # = node ./scripts/e2e.js
 
 ## 변경 이력 (최근)
 
+- **1.9.55** — MCP server에 `leerness_skill_suggest` + `leerness_lessons` 추가 (10 → 12 도구) · lessons --auto의 stopword 확장 (false positive 차단).
+- **1.9.54** — `leerness lessons --auto` — 최근 in-progress task에서 키워드 자동 추출 → 과거 lessons 자동 매칭·재상기.
+- **1.9.53** — `leerness skill suggest` — task-log / progress-tracker / usage-stats에서 반복 패턴 **자동 감지 → 새 skill 후보 제안** (Hermes-style 자동 학습의 leerness 버전).
 - **1.9.52** — `skill discover` 카탈로그 형식 다양성 — JSON manifest / RSS·Atom / Markdown / llms.txt URL 4 형식 자동 감지 (`_parseSkillCatalog`).
 - **1.9.51** — `benchmark --scenario <id|all>` — leerness 고유 가치 시나리오 4종 (거짓 완료 / 사양 불일치 / drift / BOM) **command 한 번에 정량 증명**.
 - **1.9.50** — `skill match --embedding` — Ollama API 코사인 유사도 매칭 (opt-in, 실패 시 jaccard fallback).

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.52';
+const VERSION = '1.9.55';
 const MARK = '<!-- leerness:managed -->';
 const README_START = '<!-- leerness:project-readme:start -->';
 const README_END = '<!-- leerness:project-readme:end -->';
@@ -5354,8 +5354,34 @@ function verifyCodeCmd(root) {
 // ===== 1.9.7 B: lessons — 과거 결정/실수 자동 회수 =====
 function lessonsCmd(root) {
   root = absRoot(root);
-  const query = arg('--query', null);
+  let query = arg('--query', null);
   const limit = parseInt(arg('--limit', '10'), 10);
+  // 1.9.54: --auto 옵션 — 현재 진행 중인 task의 키워드 자동 추출 → query로 사용
+  if (has('--auto') && !query) {
+    const rows = readProgressRows(root);
+    // 가장 최근 in-progress 또는 가장 최근 row의 request에서 키워드 추출
+    const latest = rows.filter(r => r.status === 'in-progress' || r.status === 'planned').pop()
+                || rows[rows.length - 1];
+    if (latest && latest.request) {
+      // 4자+ 키워드 중 가장 긴 단어 1개 선택
+      const tokens = String(latest.request).toLowerCase().match(/[\w가-힣]{4,}/g) || [];
+      // 1.9.55: stopword 확장 — 너무 일반적인 단어 제외 (lessons 매칭에 도움 안 됨)
+      const stopwords = new Set([
+        '이런', '저런', '하다', '하고', '있는', '하지', '에서',
+        '작업', '구현', '추가', '진행', '수정', '변경', '검토', '확인',
+        '프로젝트', '관리', '기능', '시스템', '코드', '파일', '버전', '정리', '계획',
+        'next', 'action', 'task', 'todo', 'work'
+      ]);
+      const candidate = tokens.filter(t => !stopwords.has(t)).sort((a, b) => b.length - a.length)[0];
+      if (candidate) query = candidate;
+    }
+    if (!query) {
+      log('# Lessons --auto');
+      log('(현재 작업에서 추출할 키워드 없음 — 새 task 등록 후 다시 시도)');
+      return;
+    }
+    log(`# Lessons --auto (1.9.54): 추출 키워드 "${query}"`);
+  }
   const decisions = exists(decisionsPath(root)) ? read(decisionsPath(root)) : '';
   const evidence = exists(evidencePath(root)) ? read(evidencePath(root)) : '';
   const tlog = exists(taskLogPath(root)) ? read(taskLogPath(root)) : '';
@@ -6361,6 +6387,83 @@ function benchmarkCmd(root) {
   log('💡 시뮬레이션은 정성적 추정 — 실 측정은 별도 환경 필요 (사용자 환경)');
 }
 
+// 1.9.53: leerness skill suggest — task-log + usage-stats에서 반복 패턴 감지 → 새 skill 후보 제안
+// Hermes-style 자동 학습의 leerness 버전. 명시적 `skill learn` 호출 없이도 패턴 추출.
+function skillSuggestCmd(root) {
+  root = absRoot(root || process.cwd());
+  const minOccurrence = parseInt(arg('--min', '3'), 10);
+  const lookbackDays = parseInt(arg('--days', '30'), 10);
+  const cutoff = Date.now() - lookbackDays * 86400000;
+  const seen = {}; // keyword → { count, samples, files }
+  // 1) task-log.md 라인 분석
+  const taskLog = taskLogPath(root);
+  if (exists(taskLog)) {
+    const body = read(taskLog);
+    // 날짜 헤더 ## YYYY-MM-DD 안의 라인들
+    const blocks = body.split(/^## \d{4}-\d{2}-\d{2}/m);
+    for (const block of blocks) {
+      // 명령 인용 `leerness X` 또는 키워드 (3+ chars)
+      for (const m of block.matchAll(/`leerness\s+([a-z][\w-]+(?:\s+[a-z][\w-]+)?)`/g)) {
+        const cmd = m[1].trim();
+        seen[cmd] = seen[cmd] || { count: 0, samples: [], source: 'task-log' };
+        seen[cmd].count++;
+        if (seen[cmd].samples.length < 3) seen[cmd].samples.push(block.slice(0, 80).replace(/\n/g, ' '));
+      }
+    }
+  }
+  // 2) progress-tracker request 컬럼 분석
+  const rows = readProgressRows(root);
+  for (const row of rows) {
+    const text = (row.request || '') + ' ' + (row.nextAction || '');
+    // 도메인 키워드 (한글 + 영어 단어, 3자 이상)
+    for (const m of text.toLowerCase().matchAll(/[\w가-힣]{4,}/g)) {
+      const kw = m[0];
+      if (/^\d+$/.test(kw)) continue;
+      if (['이런', '저런', '하다', '하고', '있는', '하지', '에서'].includes(kw)) continue;
+      seen[kw] = seen[kw] || { count: 0, samples: [], source: 'progress' };
+      seen[kw].count++;
+      if (seen[kw].samples.length < 3) seen[kw].samples.push((row.request || '').slice(0, 60));
+    }
+  }
+  // 3) usage-stats의 명령 카운트
+  try {
+    const stats = _readUsageStats(root);
+    for (const [cmd, n] of Object.entries(stats.commands || {})) {
+      if (n >= minOccurrence) {
+        seen[`cmd:${cmd}`] = seen[`cmd:${cmd}`] || { count: 0, samples: [], source: 'usage' };
+        seen[`cmd:${cmd}`].count = n;
+      }
+    }
+  } catch {}
+  // 4) 임계 이상 + 기존 skill에 없는 키워드만 필터
+  const existing = new Set(Object.keys(listAllSkills(root)));
+  const installed = _readInstalledSkills(root);
+  const installedTokens = new Set(installed.flatMap(s => [..._tokenize(s.name + ' ' + s.description)]));
+  const candidates = Object.entries(seen)
+    .filter(([kw, info]) => info.count >= minOccurrence)
+    .filter(([kw]) => !existing.has(kw) && !installedTokens.has(kw.replace(/^cmd:/, '')))
+    .map(([kw, info]) => ({ keyword: kw, ...info }))
+    .sort((a, b) => b.count - a.count);
+  if (has('--json')) { log(JSON.stringify({ minOccurrence, lookbackDays, candidates: candidates.slice(0, 20) }, null, 2)); return; }
+  log(`# leerness skill suggest (1.9.53)`);
+  log(`반복 패턴 자동 감지 (최소 ${minOccurrence}회, ${lookbackDays}일 이내)`);
+  log('');
+  if (!candidates.length) {
+    log('  (아직 패턴 부족 — task-log/progress-tracker에 작업이 더 누적되면 자동 감지)');
+    return;
+  }
+  log(`발견된 후보: ${candidates.length}건`);
+  log('');
+  log('| 키워드/명령 | 출처 | 등장 횟수 | 예시 |');
+  log('|---|---|---:|---|');
+  for (const c of candidates.slice(0, 10)) {
+    log(`| ${c.keyword} | ${c.source} | ${c.count} | ${(c.samples[0] || '').replace(/\|/g, '\\|').slice(0, 50)} |`);
+  }
+  log('');
+  log(`💡 신규 skill로 등록 권장:`);
+  log(`   leerness skill learn <id> --capability "${candidates[0].keyword}" --note "1.9.53 auto-suggest"`);
+}
+
 // 1.9.45: skill match <query> — 설치된 SKILL.md description ↔ 사용자 요청 키워드 매칭 추천
 // jaccard similarity (단어 집합 교집합/합집합).
 function _tokenize(s) {
@@ -6529,7 +6632,9 @@ function mcpServeCmd(root) {
     { 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' } } } }
+    { name: 'leerness_session_close', description: '세션 마감 — handoff/current-state/task-log 자동 갱신', inputSchema: { type: 'object', properties: { path: { type: 'string' } } } },
+    { name: 'leerness_skill_suggest', description: '1.9.53 — 사용 패턴 자동 분석 → 새 skill 후보 제안 (Hermes-style 자동 학습)', inputSchema: { type: 'object', properties: { path: { type: 'string' }, min: { type: 'number' }, days: { type: 'number' } } } },
+    { name: 'leerness_lessons', description: '1.9.7/54 — 과거 결정·실수 자동 회수 (--auto: 현재 task 키워드 자동 추출)', inputSchema: { type: 'object', properties: { path: { type: 'string' }, query: { type: 'string' }, auto: { type: 'boolean' }, limit: { type: 'number' } } } }
   ];
 
   function send(obj) {
@@ -6569,6 +6674,8 @@ function mcpServeCmd(root) {
           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;
+          case 'leerness_skill_suggest':   cliArgs = ['skill', 'suggest', '--path', targetPath, '--json', ...(args.min ? ['--min', String(args.min)] : []), ...(args.days ? ['--days', String(args.days)] : [])]; break;
+          case 'leerness_lessons':         cliArgs = ['lessons', '--path', targetPath, ...(args.auto ? ['--auto'] : []), ...(args.query ? ['--query', args.query] : []), ...(args.limit ? ['--limit', String(args.limit)] : [])]; break;
           default:
             return send({ jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown tool: ${name}` } });
         }
@@ -6960,6 +7067,7 @@ async function main() {
   if (cmd === 'skill' && args[1] === 'match')       return skillMatchCmd(absRoot(arg('--path', process.cwd())), args.slice(2).filter(x => !x.startsWith('-')).join(' '));
   if (cmd === 'benchmark')                          return benchmarkCmd(absRoot(args[1] || arg('--path', process.cwd())));
   if (cmd === 'skill' && args[1] === 'publish')     return skillPublishCmd(absRoot(arg('--path', process.cwd())));
+  if (cmd === 'skill' && args[1] === 'suggest')     return skillSuggestCmd(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());

package/package.json

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

package/scripts/e2e.js

@@ -950,6 +950,54 @@ total++;
   if (!ok) { failed++; console.log(r.stdout.slice(0, 800)); }
 }
 
+// 1.9.54/55 회귀
+total++;
+{
+  // lessons --auto 키워드 자동 추출
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-la-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpC, '--yes', '--no-banner', '--no-stale-check', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  fs.writeFileSync(path.join(tmpC, '.harness', 'review-evidence.md'),
+    '## 2026-04-01\nNote: ✗ payment 처리 실패 — 검수 누락\n', 'utf8');
+  cp.spawnSync(process.execPath, [CLI, 'task', 'add', 'payment 검증 작업', '--status', 'in-progress', '--path', tmpC], { stdio: 'ignore', timeout: 10000 });
+  const r = cp.spawnSync(process.execPath, [CLI, 'lessons', '--path', tmpC, '--auto', '--limit', '5'], { encoding: 'utf8', timeout: 15000 });
+  const ok = /추출 키워드.*payment/.test(r.stdout) && /payment.*실패/.test(r.stdout);
+  console.log(ok ? '✓ B(1.9.54) lessons --auto: in-progress task 키워드 자동 추출 + 매칭' : `✗ lessons --auto 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
+}
+
+total++;
+{
+  // MCP server tools/list 12 도구 (1.9.55)
+  const r = cp.spawnSync(process.execPath, [CLI, 'mcp', 'serve'], {
+    encoding: 'utf8', timeout: 8000,
+    input: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list' }) + '\n'
+  });
+  let resp = null;
+  try { resp = JSON.parse(r.stdout.split('\n').filter(Boolean)[0]); } catch {}
+  const tools = resp && resp.result && resp.result.tools;
+  const hasNew = tools && tools.some(t => t.name === 'leerness_skill_suggest') && tools.some(t => t.name === 'leerness_lessons');
+  const ok = tools && tools.length >= 12 && hasNew;
+  console.log(ok ? `✓ B(1.9.55) MCP: ${tools.length} 도구 (skill_suggest + lessons 추가)` : `✗ MCP 12 도구 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
+}
+
+// 1.9.53 회귀: skill suggest 자동 학습
+total++;
+{
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-sg-'));
+  cp.spawnSync(process.execPath, [CLI, 'init', tmpC, '--yes', '--no-banner', '--no-stale-check', '--language', 'ko', '--skills', 'recommended'], { stdio: 'ignore', timeout: 30000 });
+  // 반복 키워드 6회
+  for (let i = 0; i < 6; i++) {
+    cp.spawnSync(process.execPath, [CLI, 'task', 'add', `autosuggestkw 작업 ${i}`, '--path', tmpC], { stdio: 'ignore', timeout: 10000 });
+  }
+  const r = cp.spawnSync(process.execPath, [CLI, 'skill', 'suggest', '--path', tmpC, '--min', '3', '--json'], { encoding: 'utf8', timeout: 15000 });
+  let j = null;
+  try { j = JSON.parse(r.stdout); } catch {}
+  const ok = j && j.candidates && j.candidates.some(c => /autosuggestkw/.test(c.keyword) && c.count >= 3);
+  console.log(ok ? '✓ B(1.9.53) skill suggest: progress-tracker 반복 패턴 자동 감지 (Hermes-style)' : `✗ suggest 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
+}
+
 // 1.9.51/52 회귀
 total++;
 {