leerness 1.9.50 → 1.9.53

package/CHANGELOG.md

@@ -1,5 +1,74 @@
 # Changelog
 
+## 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 자동 감지)**.
+
+### Added
+- **`_parseSkillCatalog(body, sourceUrl)`** 통합 파서 — 4 형식 자동 감지:
+  1. **JSON manifest** — `{ "skills": [...] }` 또는 `[{...}]` (leerness `skill publish`가 만드는 형식과 호환)
+  2. **RSS/Atom** — `<item><title>X</title><link>...</link><description>...</description></item>`
+  3. **Markdown w/ description** — `- [name](url) — description`
+  4. **llms.txt URL-only** — 단순 URL 라인
+- 각 entry에 `format` 필드 추가 (json/rss/markdown/urls) — 출처 추적
+
+### 검증 (stress-v4)
+- M1-M5 5/5 PASS — 4 형식 인식 + 빈 body 안전 fallback
+
+## 1.9.51 — 2026-05-19
+
+**`benchmark --scenario` — leerness 고유 가치 시나리오 preset**.
+
+### Added
+- **`leerness benchmark --scenario <id|all> [--json]`** — 4 시나리오 자동 실행:
+  - `false-completion` — 거짓 완료 자동 감지 (lazy detect)
+  - `spec-mismatch` — 사양 ↔ 구현 불일치 (contract verify)
+  - `drift-detection` — 메타파일 stale (drift check 4 신호)
+  - `bom-handling` — UTF-8 BOM SKILL.md install (1.9.44 패치 효과)
+- 각 시나리오: setup → measure → 감지 여부 + 시간 측정
+- 결과: leerness 적용 워크스페이스에서 **4/4 정확 감지**
+
+### 검증 (stress-v4 + 누적 회귀)
+- L1-L4 (시나리오 preset) 4/4 PASS
+- M1-M5 (카탈로그 4 형식 + 빈 body) 5/5 PASS
+- N1-N5 (누적 회귀: MCP, skill match, publish, drift, agentskills round-trip) 5/5 PASS
+- **stress-v4: 14/14 PASS**, e2e: **205/205 PASS**
+
+### 결론
+- 1.9.51로 leerness 고유 가치가 **command 한 번에 정량 증명** 가능
+- 1.9.52로 다양한 카탈로그 형식과 호환 (agentskills.io 외 사용자 정의 RSS/JSON도)
+
 ## 1.9.50 — 2026-05-19
 
 **`skill match --embedding` (Ollama opt-in 임베딩 매칭)**.

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.50-green)]() [![tests](https://img.shields.io/badge/e2e-202%2F202-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.53-green)]() [![tests](https://img.shields.io/badge/e2e-206%2F206-success)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
 
 ```
   ╔══════════════════════════════════════════════════════════════╗
@@ -12,7 +12,7 @@
   ║  ██║     ██╔══╝  ██╔══╝  ██╔══██╗██║╚██╗██║██╔══╝  ╚════██║  ║
   ║  ███████╗███████╗███████╗██║  ██║██║ ╚████║███████╗███████║  ║
   ║  ╚══════╝╚══════╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝╚══════╝╚══════╝  ║
-  ║  v1.9.50   AI Agent Reliability Harness                      ║
+  ║  v1.9.53   AI Agent Reliability Harness                      ║
   ║  verify · remember · orchestrate · audit · prevent drift     ║
   ╚══════════════════════════════════════════════════════════════╝
 ```
@@ -433,6 +433,9 @@ npm test     # = node ./scripts/e2e.js
 
 ## 변경 이력 (최근)
 
+- **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).
 - **1.9.49** — `benchmark --measure "<task>"` — 외부 CLI 실 호출 시간 측정 + leerness 검수 오버헤드 측정.
 - **1.9.48** — cross-platform archive — `skill publish` tar 실패 시 PowerShell ZIP 자동 fallback (stress-v3 H1-H3 검증).

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.50';
+const VERSION = '1.9.53';
 const MARK = '<!-- leerness:managed -->';
 const README_START = '<!-- leerness:project-readme:start -->';
 const README_END = '<!-- leerness:project-readme:end -->';
@@ -954,6 +954,57 @@ async function skillInstallCmd(root, source) {
   log(`💡 다음: leerness skill info ${skillId}`);
 }
 
+// 1.9.52: 카탈로그 형식 자동 감지 + 파싱 (JSON, llms.txt, RSS, manifest.json, 일반 마크다운)
+// 표준화된 entry 형식: { name, url, description, format }
+function _parseSkillCatalog(body, sourceUrl) {
+  const entries = [];
+  const trimmed = body.trim();
+  // 1) JSON 카탈로그 — manifest.json 형식 (1.9.47에서 publish가 만드는 형식과 호환)
+  //    { "skills": [{ "id"/"name", "url"/"path", "description" }, ...] }
+  if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+    try {
+      const j = JSON.parse(trimmed);
+      const arr = Array.isArray(j) ? j : (j.skills || j.entries || j.items || []);
+      for (const e of arr) {
+        if (!e || (!e.name && !e.id)) continue;
+        entries.push({
+          name: e.name || e.id,
+          url: e.url || e.path || (sourceUrl ? sourceUrl.replace(/[^/]+$/, '') + (e.id || e.name) + '/SKILL.md' : ''),
+          description: e.description || '',
+          format: 'json'
+        });
+      }
+      if (entries.length) return entries;
+    } catch {}
+  }
+  // 2) RSS/Atom — <item><title>X</title><link>...</link><description>...</description></item>
+  if (/<rss|<feed|<channel|<item>/i.test(body)) {
+    for (const m of body.matchAll(/<(?:item|entry)\b[\s\S]*?<\/(?:item|entry)>/gi)) {
+      const item = m[0];
+      const title = (item.match(/<title>([^<]+)<\/title>/i) || [])[1];
+      const link = (item.match(/<link[^>]*>([^<]+)<\/link>/i) || item.match(/<link\s+href="([^"]+)"/i) || [])[1];
+      const desc = (item.match(/<description>([^<]+)<\/description>/i) || item.match(/<summary>([^<]+)<\/summary>/i) || [])[1];
+      if (title) entries.push({ name: title.trim(), url: (link || '').trim(), description: (desc || '').trim(), format: 'rss' });
+    }
+    if (entries.length) return entries;
+  }
+  // 3) 마크다운 링크 with description — "- [name](url) — description"
+  for (const m of body.matchAll(/^\s*[-*]\s*\[([^\]]+)\]\(([^)]+)\)\s*[-—:]\s*(.+)$/gm)) {
+    entries.push({ name: m[1], url: m[2], description: m[3].trim(), format: 'markdown' });
+  }
+  if (entries.length) return entries;
+  // 4) 마크다운 링크 without description — "- [name](url)"
+  for (const m of body.matchAll(/^\s*[-*]\s*\[([^\]]+)\]\(([^)]+\.md)\)/gm)) {
+    entries.push({ name: m[1], url: m[2], description: '', format: 'markdown' });
+  }
+  if (entries.length) return entries;
+  // 5) llms.txt — 단순 URL 라인
+  for (const m of body.matchAll(/(https?:\/\/[^\s)]+SKILL\.md)/g)) {
+    entries.push({ name: m[1].split('/').slice(-2)[0], url: m[1], description: '', format: 'urls' });
+  }
+  return entries;
+}
+
 // skill discover — agentskills.io 또는 사용자 지정 URL의 카탈로그 인덱스에서 매칭 추천
 async function skillDiscoverCmd(root) {
   const url = arg('--source', null) || process.env.LEERNESS_SKILL_DISCOVER_URL || null;
@@ -968,7 +1019,7 @@ async function skillDiscoverCmd(root) {
     ].join('\n'));
     return process.exit(1);
   }
-  log(`# leerness skill discover (1.9.42)`);
+  log(`# leerness skill discover (1.9.52)`);
   log(`source: ${url}`);
   if (query) log(`query: ${query}`);
   log(`fetching...`);
@@ -977,21 +1028,9 @@ async function skillDiscoverCmd(root) {
     fail(`fetch 실패 (HTTP ${r.status}${r.error ? `, ${r.error}` : ''})`);
     return process.exit(1);
   }
-  // 카탈로그 인덱스 파싱 — agentskills.io는 llms.txt 형식 또는 raw 마크다운
+  // 1.9.52: 카탈로그 형식 자동 감지 (JSON, llms.txt, RSS, manifest.json, 일반 마크다운)
   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: '' });
-    }
-  }
+  const entries = _parseSkillCatalog(body, url);
   if (has('--json')) { log(JSON.stringify({ source: url, query, entries }, null, 2)); return; }
   if (!entries.length) {
     log('  (스킬 항목을 찾지 못함 — URL 형식 확인)');
@@ -6100,6 +6139,90 @@ function skillPublishCmd(root) {
 // 1.9.46: leerness benchmark — 자체 워크스페이스 측정 + 타도구 대비 시뮬레이션 비교 매트릭스
 // 실 측정값: drift, usage stats, task 수, capability 수
 // 시뮬: leerness 미적용 vanilla / Hermes 단독 / Claude Code 단독 비교 (보고서 §5 기반)
+// 1.9.51: --scenario — leerness 고유 가치 시나리오 preset 자동 실행 + 정량 결과
+// 사용자가 직접 task 작성 안 해도 leerness의 검수 효과 즉시 측정 가능.
+const BENCHMARK_SCENARIOS = {
+  'false-completion': {
+    label: '거짓 완료 자동 감지',
+    description: 'evidence 없이 done인 task를 verify-claim/lazy detect가 잡는지',
+    setup: (dir) => {
+      // 빈 evidence로 done task 생성
+      cp.spawnSync(process.execPath, [__filename, 'task', 'add', '거짓 완료된 작업', '--status', 'done', '--evidence', '', '--path', dir],
+        { encoding: 'utf8', timeout: 10000, env: { ...process.env, LEERNESS_NO_PROMPT: '1' } });
+    },
+    measure: (dir) => {
+      const r = cp.spawnSync(process.execPath, [__filename, 'lazy', 'detect', dir],
+        { encoding: 'utf8', timeout: 15000, env: { ...process.env, LEERNESS_NO_DRIFT_CHECK: '1' } });
+      const detected = /✗ |found.*issue|증거 없는|empty/.test(r.stdout);
+      return { detected, exit: r.status, sample: r.stdout.slice(0, 200) };
+    }
+  },
+  'spec-mismatch': {
+    label: '사양 ↔ 구현 불일치 자동 감지',
+    description: 'spec.md에 명시된 함수가 impl.js의 module.exports에 없는지',
+    setup: (dir) => {
+      fs.writeFileSync(path.join(dir, 'mismatch-spec.md'), 'function fooBar() {}\nfunction missingFn() {}\n', 'utf8');
+      fs.writeFileSync(path.join(dir, 'mismatch-impl.js'), 'function fooBar() {}\nmodule.exports = { fooBar };\n', 'utf8');
+    },
+    measure: (dir) => {
+      const r = cp.spawnSync(process.execPath, [__filename, 'contract', 'verify',
+        path.join(dir, 'mismatch-spec.md'), path.join(dir, 'mismatch-impl.js'), '--json'],
+        { encoding: 'utf8', timeout: 15000, env: { ...process.env, LEERNESS_NO_DRIFT_CHECK: '1' } });
+      let j = null;
+      try { j = JSON.parse(r.stdout); } catch {}
+      const detected = j && j.missingFunctions && j.missingFunctions.includes('missingFn');
+      return { detected, ok: !!(j && j.ok === false), sample: r.stdout.slice(0, 200) };
+    }
+  },
+  'drift-detection': {
+    label: 'drift 감지 (메타파일 stale)',
+    description: '인공적으로 session-handoff stale 만들고 drift check가 잡는지',
+    setup: (dir) => {
+      const sh = path.join(dir, '.harness', 'session-handoff.md');
+      if (exists(sh)) {
+        let body = read(sh);
+        body = body.replace(/Last generated:.*/, 'Last generated: 2020-01-01T00:00:00.000Z');
+        writeUtf8(sh, body);
+      }
+    },
+    measure: (dir) => {
+      const r = cp.spawnSync(process.execPath, [__filename, 'drift', 'check', dir, '--json'],
+        { encoding: 'utf8', timeout: 15000, env: { ...process.env, LEERNESS_NO_DRIFT_CHECK: '0' } });
+      let j = null;
+      try { j = JSON.parse(r.stdout.trim()); } catch {}
+      const detected = j && (j.level === '🔴 critical' || j.level === '🟠 attention');
+      return { detected, level: j && j.level, score: j && j.score, sample: r.stdout.slice(0, 200) };
+    }
+  },
+  'bom-handling': {
+    label: 'UTF-8 BOM SKILL.md install (1.9.44 patch)',
+    description: 'BOM 포함 SKILL.md import 성공 (Windows 메모장 호환)',
+    setup: (dir) => {
+      const src = path.join(dir, 'bom-test.md');
+      const buf = Buffer.concat([Buffer.from([0xEF, 0xBB, 0xBF]),
+        Buffer.from('---\nname: bom-test\ndescription: BOM 처리 검증\n---\n\n# Body', 'utf8')]);
+      fs.writeFileSync(src, buf);
+    },
+    measure: (dir) => {
+      const r = cp.spawnSync(process.execPath, [__filename, 'skill', 'install',
+        path.join(dir, 'bom-test.md'), '--path', dir],
+        { encoding: 'utf8', timeout: 15000, env: { ...process.env, LEERNESS_NO_PROMPT: '1' } });
+      const f = path.join(dir, '.harness', 'skills', 'bom-test', 'SKILL.md');
+      return { detected: r.status === 0 && exists(f), sample: r.stdout.slice(0, 200) };
+    }
+  }
+};
+
+function _runScenario(root, key) {
+  const sc = BENCHMARK_SCENARIOS[key];
+  if (!sc) return { error: `알 수 없는 시나리오: ${key}` };
+  const t0 = Date.now();
+  try { sc.setup(root); } catch (e) { return { error: 'setup 실패: ' + e.message }; }
+  const result = sc.measure(root);
+  const elapsed = Date.now() - t0;
+  return { key, label: sc.label, description: sc.description, elapsed, ...result };
+}
+
 // 1.9.49: --measure 모드 — ready 외부 CLI에 동일 task 실측 + leerness verify-claim 적용 시 추가 시간 측정
 async function _benchmarkMeasure(root, task) {
   const results = [];
@@ -6132,6 +6255,32 @@ async function _benchmarkMeasure(root, task) {
 
 function benchmarkCmd(root) {
   root = absRoot(root || process.cwd());
+  // 1.9.51: --scenario [<id>|all] — leerness 고유 검수 시나리오 preset 자동 실행
+  if (has('--scenario')) {
+    const scenarioArg = arg('--scenario', 'all');
+    const keys = scenarioArg === 'all' || scenarioArg === 'true'
+      ? Object.keys(BENCHMARK_SCENARIOS)
+      : scenarioArg.split(',').map(s => s.trim()).filter(s => BENCHMARK_SCENARIOS[s]);
+    if (!keys.length) {
+      fail(`알 수 없는 scenario: ${scenarioArg}\n  사용 가능: ${Object.keys(BENCHMARK_SCENARIOS).join(', ')}, all`);
+      return process.exit(1);
+    }
+    const results = keys.map(k => _runScenario(root, k));
+    const detected = results.filter(r => r.detected).length;
+    if (has('--json')) { log(JSON.stringify({ scenarios: results, detectedCount: detected, total: results.length }, null, 2)); return; }
+    log(`# leerness benchmark --scenario (1.9.51)`);
+    log(`leerness 고유 검수 시나리오 ${results.length}개 자동 실행`);
+    log('');
+    log('| # | 시나리오 | 감지? | 시간 |');
+    log('|---|---|---|---:|');
+    results.forEach((r, i) => {
+      log(`| ${i+1} | ${r.label} | ${r.detected ? '✅' : r.error ? '⚠ error' : '❌'} | ${r.elapsed || 0}ms |`);
+    });
+    log('');
+    log(`✅ leerness가 정확히 감지: ${detected}/${results.length}`);
+    log(`💡 각 시나리오는 leerness 고유 가치 — 다른 도구(Claude Code/Hermes/Cursor)에는 없는 기능`);
+    return;
+  }
   // 1.9.49: --measure "<task>" 모드 — 실 CLI 시간 측정
   if (has('--measure')) {
     const task = arg('--measure', null) || arg('--task', null);
@@ -6212,6 +6361,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) {
@@ -6811,6 +7037,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.50",
+  "version": "1.9.53",
   "description": "Leerness: 비파괴 마이그레이션, 자동 버전 감지·업데이트, 계획/진행/핸드오프 자동화, 게으름·시크릿·인코딩 자동 가드, Claude Code 슬래시 통합을 갖춘 한국어 우선 AI 개발 하네스.",
   "keywords": [
     "leerness",

package/scripts/e2e.js

@@ -950,6 +950,67 @@ total++;
   if (!ok) { failed++; console.log(r.stdout.slice(0, 800)); }
 }
 
+// 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++;
+{
+  // benchmark --scenario all → 4개 시나리오 모두 감지
+  const tmpC = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-sc-'));
+  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, 'benchmark', tmpC, '--scenario', 'all', '--json'], { encoding: 'utf8', timeout: 60000 });
+  let j = null;
+  try { j = JSON.parse(r.stdout); } catch {}
+  const ok = j && j.scenarios && j.scenarios.length === 4 && j.detectedCount === 4;
+  console.log(ok ? '✓ B(1.9.51) benchmark --scenario all: 4/4 leerness 고유 가치 자동 감지' : `✗ scenario all 실패`);
+  if (!ok) { failed++; console.log(r.stdout.slice(0, 400)); }
+}
+
+total++;
+{
+  // benchmark --scenario 알 수 없는 ID → 친절 안내
+  const r = cp.spawnSync(process.execPath, [CLI, 'benchmark', '--scenario', 'unknown-x'], { encoding: 'utf8', timeout: 15000 });
+  const ok = r.status !== 0 && /알 수 없는 scenario/.test(r.stdout + r.stderr);
+  console.log(ok ? '✓ B(1.9.51) benchmark --scenario unknown: 친절 안내' : `✗ scenario 안내 실패`);
+  if (!ok) { failed++; console.log((r.stdout + r.stderr).slice(0, 300)); }
+}
+
+total++;
+{
+  // _parseSkillCatalog 4 형식 인식 — node -e로 동적 평가
+  const src = fs.readFileSync(CLI, 'utf8');
+  const m = src.match(/function _parseSkillCatalog\([\s\S]*?\n\}\n/);
+  if (!m) {
+    console.log('✗ _parseSkillCatalog 함수 위치 못 찾음');
+    failed++;
+  } else {
+    const fn = eval('(' + m[0].replace('function _parseSkillCatalog', 'function') + ')');
+    const jsonR = fn(JSON.stringify({ skills: [{ name: 'a', description: 'A' }] }), null);
+    const rssR = fn('<rss><channel><item><title>X</title><link>http://x.com/s.md</link></item></channel></rss>', null);
+    const mdR = fn('- [office](o.md) — Office\n- [crawling](c.md) — Web', null);
+    const urlR = fn('https://x.com/foo/SKILL.md', null);
+    const ok = jsonR[0].format === 'json' && rssR[0].format === 'rss'
+      && mdR[0].format === 'markdown' && urlR[0].format === 'urls';
+    console.log(ok ? '✓ B(1.9.52) _parseSkillCatalog: 4 형식 (JSON/RSS/Markdown/llms.txt) 모두 인식' : `✗ catalog 형식 실패`);
+    if (!ok) { failed++; console.log(JSON.stringify({jsonR, rssR, mdR, urlR}).slice(0, 400)); }
+  }
+}
+
 // 1.9.48~50 회귀
 total++;
 {