@su-record/vibe 2.9.38 → 2.10.0

package/hooks/scripts/clone-to-scss.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+
+/**
+ * clone-to-scss.js — sections.json → SCSS partials + class plan
+ *
+ * Usage:
+ *   node clone-to-scss.js <sections.json> --out=<styles-dir> [--feature=<name>] [--asset-root=<public-prefix>]
+ *
+ * Output:
+ *   <styles-dir>/
+ *     index.scss           (master orchestrator)
+ *     _tokens.scss         (CSS variables from tokens)
+ *     _base.scss           (@font-face + body defaults from stylesheets.json hints)
+ *     _shared.scss         (placeholder for cross-section utilities)
+ *     sections/_<name>.scss (per-section partial)
+ *   <styles-dir>/class-plan.json  (node.id → BEM class name; HTML scaffolder applies these)
+ *
+ * Rules:
+ *   - CSS values copied verbatim from sections.json — no eyeballing
+ *   - Token-referenced values stay as var(--xxx)
+ *   - Selectors are class-based, BEM-flavored: .{feature}__{section}__{role}
+ *   - One class per node; nested rules use SCSS &__ syntax
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+// ─── CLI ────────────────────────────────────────────────────────────
+function parseArgs(argv) {
+  const [, , inputPath, ...rest] = argv;
+  const opts = {};
+  for (const a of rest) {
+    if (a.startsWith('--out=')) opts.out = a.slice(6);
+    else if (a.startsWith('--feature=')) opts.feature = a.slice(10);
+    else if (a.startsWith('--asset-root=')) opts.assetRoot = a.slice(13);
+  }
+  return { inputPath, opts };
+}
+
+const { inputPath, opts } = parseArgs(process.argv);
+if (!inputPath || !opts.out) {
+  console.error('Usage: node clone-to-scss.js <sections.json> --out=<styles-dir> [--feature=<name>] [--asset-root=<public-prefix>]');
+  process.exit(1);
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────
+function kebab(s) {
+  return String(s)
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/[^a-zA-Z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .toLowerCase() || 'x';
+}
+
+function shorten(id) {
+  // node id like "0.1.2.3" → "n-0-1-2-3"
+  return 'n-' + id.replace(/[^0-9]/g, '-').replace(/^-+|-+$/g, '').slice(0, 20);
+}
+
+// Detect a semantic role for a node based on tag/class/text/attrs
+function semanticRole(node) {
+  const cls = (node.classes || '').toLowerCase();
+  const tag = node.tag;
+  if (tag === 'h1' || /\bheadline\b|\bhero-title\b/.test(cls)) return 'title';
+  if (/^h[2-6]$/.test(tag)) return `heading-${tag.slice(1)}`;
+  if (tag === 'p' || /\bsubtitle\b|\bdescription\b/.test(cls)) return 'body';
+  if (tag === 'a' && (/\bbutton\b|\bbtn\b|\bcta\b/.test(cls) || (node.attrs && /button/.test(node.attrs.role || '')))) return 'button';
+  if (tag === 'button') return 'button';
+  if (tag === 'img' || (node.css && node.css['background-image'] && node.css['background-image'] !== 'none')) return 'media';
+  if (tag === 'ul' || tag === 'ol') return 'list';
+  if (tag === 'li') return 'item';
+  if (tag === 'nav' || /\bnav\b/.test(cls)) return 'nav';
+  if (tag === 'form') return 'form';
+  if (tag === 'input' || tag === 'textarea' || tag === 'select') return 'field';
+  if (tag === 'header') return 'header';
+  if (tag === 'footer') return 'footer';
+  if (tag === 'section' || tag === 'article') return 'content';
+  if (tag === 'div' && node.children && node.children.length > 1) return 'group';
+  return 'el';
+}
+
+// ─── Class plan: assign one BEM class per visible node ──────────────
+function buildClassPlan(sections, feature) {
+  const plan = {}; // id → class name
+  const usedNames = new Map(); // base name → count for disambiguation
+  const sectionUsedRoles = new Map();
+
+  const assign = (sectionName, node, parentRole) => {
+    if (!node || node.pseudo) return;
+    const sectionKey = kebab(sectionName);
+    let role = semanticRole(node);
+    if (parentRole === 'list' && role !== 'item') role = 'item';
+    // disambiguate within section by role
+    const k = `${sectionKey}::${role}`;
+    const idx = (sectionUsedRoles.get(k) || 0) + 1;
+    sectionUsedRoles.set(k, idx);
+    const suffix = idx === 1 ? role : `${role}-${idx}`;
+    const cls = `${feature}__${sectionKey}__${suffix}`;
+    plan[node.id] = cls;
+    for (const child of (node.children || [])) assign(sectionName, child, role);
+  };
+
+  for (const sec of sections) {
+    // Root section class
+    const sectionKey = kebab(sec.name);
+    plan[sec.nodeRef] = `${feature}__${sectionKey}`;
+    for (const child of (sec.children || [])) assign(sec.name, child, 'section');
+  }
+
+  return plan;
+}
+
+// ─── CSS emission ───────────────────────────────────────────────────
+const SKIP_DEFAULT_VALUES = {
+  'pointer-events': 'auto',
+  'visibility': 'visible',
+  'opacity': '1',
+  'transform': 'none',
+  'background-repeat': 'repeat',
+  'background-attachment': 'scroll',
+  'background-blend-mode': 'normal',
+  'mix-blend-mode': 'normal',
+  'filter': 'none',
+  'backdrop-filter': 'none',
+  'overflow': 'visible',
+  'overflow-x': 'visible',
+  'overflow-y': 'visible',
+};
+
+function emitDeclarations(css, indent) {
+  const out = [];
+  for (const [prop, val] of Object.entries(css)) {
+    if (!val || prop.startsWith('--')) continue;
+    if (SKIP_DEFAULT_VALUES[prop] === val) continue;
+    out.push(`${indent}${prop}: ${val};`);
+  }
+  return out.join('\n');
+}
+
+function emitNodeRule(node, plan, indent) {
+  const cls = plan[node.id];
+  if (!cls) return '';
+  const lines = [];
+  lines.push(`${indent}.${cls} {`);
+  const decl = emitDeclarations(node.css || {}, indent + '  ');
+  if (decl) lines.push(decl);
+  // pseudo-elements
+  for (const child of (node.children || [])) {
+    if (child.pseudo) {
+      const kind = child.tag.replace('::', '');
+      lines.push('');
+      lines.push(`${indent}  &::${kind} {`);
+      lines.push(emitDeclarations(child.css || {}, indent + '    '));
+      lines.push(`${indent}  }`);
+    }
+  }
+  lines.push(`${indent}}`);
+
+  // Non-pseudo children — emit at same level (BEM flat)
+  const childRules = (node.children || [])
+    .filter((c) => !c.pseudo)
+    .map((c) => emitNodeRule(c, plan, indent))
+    .filter(Boolean);
+
+  return [lines.join('\n'), ...childRules].join('\n\n');
+}
+
+// ─── File emission ──────────────────────────────────────────────────
+function emitTokens(tokens) {
+  const lines = [':root {'];
+  for (const c of tokens.colors) lines.push(`  --${c.name}: ${c.value};`);
+  for (const t of tokens.typography) {
+    lines.push(`  --${t.name}-family: ${t.family};`);
+    lines.push(`  --${t.name}-size: ${t.size};`);
+    lines.push(`  --${t.name}-weight: ${t.weight};`);
+    if (t.lineHeight && t.lineHeight !== 'normal') lines.push(`  --${t.name}-line-height: ${t.lineHeight};`);
+    if (t.letterSpacing && t.letterSpacing !== 'normal') lines.push(`  --${t.name}-letter-spacing: ${t.letterSpacing};`);
+  }
+  for (const s of tokens.spacing) lines.push(`  --${s.name}: ${s.value};`);
+  for (const r of tokens.radius) lines.push(`  --${r.name}: ${r.value};`);
+  for (const s of tokens.shadow) lines.push(`  --${s.name}: ${s.value};`);
+  lines.push('}');
+  return lines.join('\n') + '\n';
+}
+
+function emitBase(feature, stylesheets) {
+  const lines = [];
+  lines.push('// Auto-generated by clone-to-scss.js — do not edit by hand.');
+  lines.push('');
+  if (stylesheets && stylesheets.fontFaces) {
+    for (const ff of stylesheets.fontFaces) {
+      lines.push('@font-face {');
+      lines.push(`  font-family: '${ff.family}';`);
+      if (ff.weight) lines.push(`  font-weight: ${ff.weight};`);
+      if (ff.style) lines.push(`  font-style: ${ff.style};`);
+      if (ff.display) lines.push(`  font-display: ${ff.display};`);
+      const srcs = ff.sources.map((s) => s.format
+        ? `url('${s.url}') format('${s.format}')`
+        : `url('${s.url}')`).join(',\n       ');
+      lines.push(`  src: ${srcs};`);
+      lines.push('}');
+      lines.push('');
+    }
+  }
+  return lines.join('\n');
+}
+
+function emitSection(section, plan) {
+  const lines = [];
+  lines.push(`// Section: ${section.name}`);
+  lines.push('');
+  // root + descendants
+  lines.push(emitNodeRule({ ...section, id: section.nodeRef, children: section.children }, plan, ''));
+  return lines.join('\n') + '\n';
+}
+
+function emitIndex(feature, sections) {
+  const lines = [];
+  lines.push(`// ${feature} — auto-generated by clone-to-scss.js`);
+  lines.push('');
+  lines.push(`@use './tokens';`);
+  lines.push(`@use './base';`);
+  lines.push(`@use './shared';`);
+  for (const sec of sections) {
+    lines.push(`@use './sections/${kebab(sec.name)}';`);
+  }
+  return lines.join('\n') + '\n';
+}
+
+// ─── Main ───────────────────────────────────────────────────────────
+function main() {
+  const data = JSON.parse(fs.readFileSync(inputPath, 'utf8'));
+  const feature = opts.feature || data.meta?.feature || 'clone';
+  const featureClass = kebab(feature);
+
+  // Read sibling stylesheets.json if present (from clone-extract.js output)
+  const sectionsDir = path.dirname(inputPath);
+  const stylesheetsPath = path.join(sectionsDir, 'stylesheets.json');
+  let stylesheets = null;
+  if (fs.existsSync(stylesheetsPath)) {
+    stylesheets = JSON.parse(fs.readFileSync(stylesheetsPath, 'utf8'));
+  }
+
+  const outDir = opts.out;
+  fs.mkdirSync(outDir, { recursive: true });
+  fs.mkdirSync(path.join(outDir, 'sections'), { recursive: true });
+
+  const plan = buildClassPlan(data.sections, featureClass);
+
+  // Write files
+  fs.writeFileSync(path.join(outDir, '_tokens.scss'), emitTokens(data.tokens));
+  fs.writeFileSync(path.join(outDir, '_base.scss'), emitBase(featureClass, stylesheets));
+  fs.writeFileSync(
+    path.join(outDir, '_shared.scss'),
+    `// Cross-section utilities — extend as needed.\n`,
+  );
+
+  for (const sec of data.sections) {
+    const fname = `_${kebab(sec.name)}.scss`;
+    fs.writeFileSync(path.join(outDir, 'sections', fname), emitSection(sec, plan));
+  }
+
+  fs.writeFileSync(path.join(outDir, 'index.scss'), emitIndex(featureClass, data.sections));
+  fs.writeFileSync(path.join(outDir, 'class-plan.json'), JSON.stringify(plan, null, 2));
+
+  console.log(`[clone-to-scss] done → ${outDir}`);
+  console.log(`  sections: ${data.sections.length}, classes: ${Object.keys(plan).length}`);
+}
+
+try { main(); }
+catch (e) {
+  console.error(`[clone-to-scss] FAIL: ${e.message}`);
+  if (process.env.DEBUG) console.error(e.stack);
+  process.exit(1);
+}

package/hooks/scripts/clone-validate.js

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+
+/**
+ * clone-validate.js — written SCSS vs sections.json (source of truth)
+ *
+ * Usage:
+ *   node clone-validate.js <styles-dir> <sections.json> [--section=<name>]
+ *
+ * Reads:
+ *   <styles-dir>/sections/_<section>.scss
+ *   <styles-dir>/class-plan.json
+ *   <sections.json>
+ *
+ * Compares emitted CSS declarations against expectations:
+ *   - Missing property → P1
+ *   - Mismatched value → P1 (if box prop and delta > 4px), else P2
+ *   - Extra property → P3 (informational)
+ *
+ * Exit codes:
+ *   0 PASS, 1 FAIL (P1 found), 2 usage error
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+function parseArgs(argv) {
+  const [, , stylesDir, sectionsPath, ...rest] = argv;
+  const opts = {};
+  for (const a of rest) {
+    if (a.startsWith('--section=')) opts.section = a.slice(10);
+    else if (a === '--quiet') opts.quiet = true;
+  }
+  return { stylesDir, sectionsPath, opts };
+}
+
+const { stylesDir, sectionsPath, opts } = parseArgs(process.argv);
+if (!stylesDir || !sectionsPath) {
+  console.error('Usage: node clone-validate.js <styles-dir> <sections.json> [--section=<name>]');
+  process.exit(2);
+}
+
+// ─── Minimal SCSS parser ────────────────────────────────────────────
+// Strips comments, expands `&::pseudo` (one level), flattens nested rules.
+// NOT a full SCSS engine — assumes clone-to-scss.js output style.
+
+function stripComments(src) {
+  return src
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/\/\/[^\n]*/g, '');
+}
+
+function parseScss(src) {
+  const clean = stripComments(src);
+  const rules = new Map(); // selector → { prop: value }
+  let i = 0;
+  const len = clean.length;
+
+  const skipWs = () => { while (i < len && /\s/.test(clean[i])) i++; };
+
+  const readUntil = (chars) => {
+    let buf = '';
+    while (i < len && !chars.includes(clean[i])) buf += clean[i++];
+    return buf;
+  };
+
+  const stack = []; // selector stack
+
+  while (i < len) {
+    skipWs();
+    if (i >= len) break;
+    const ch = clean[i];
+    if (ch === '}') { stack.pop(); i++; continue; }
+
+    // Lookahead: is this a rule (has '{' before ';' or end) or declaration?
+    let depth = 0;
+    let j = i;
+    let kind = 'decl';
+    while (j < len) {
+      const c = clean[j];
+      if (c === '"' || c === "'") {
+        const q = c; j++;
+        while (j < len && clean[j] !== q) { if (clean[j] === '\\') j++; j++; }
+      }
+      if (c === '(') depth++;
+      else if (c === ')') depth--;
+      else if (depth === 0 && c === ';') { kind = 'decl'; break; }
+      else if (depth === 0 && c === '{') { kind = 'rule'; break; }
+      else if (depth === 0 && c === '}') { break; }
+      j++;
+    }
+
+    if (kind === 'rule') {
+      const selector = clean.slice(i, j).trim();
+      i = j + 1; // consume '{'
+      // Resolve nested selector
+      const parent = stack[stack.length - 1] || '';
+      let resolved;
+      if (selector.startsWith('&')) {
+        resolved = parent + selector.slice(1);
+      } else if (parent) {
+        // descendant
+        resolved = selector.split(',').map((s) => parent + ' ' + s.trim()).join(', ');
+      } else {
+        resolved = selector;
+      }
+      stack.push(resolved);
+      if (!rules.has(resolved)) rules.set(resolved, {});
+    } else {
+      // declaration
+      const text = clean.slice(i, j).trim();
+      i = j + 1;
+      if (!text) continue;
+      const colon = text.indexOf(':');
+      if (colon < 0) continue;
+      const prop = text.slice(0, colon).trim();
+      const val = text.slice(colon + 1).trim();
+      const sel = stack[stack.length - 1];
+      if (sel) {
+        if (!rules.has(sel)) rules.set(sel, {});
+        rules.get(sel)[prop] = val;
+      }
+    }
+  }
+
+  return rules;
+}
+
+// ─── Comparison ─────────────────────────────────────────────────────
+const BOX_PROPS = new Set([
+  'width', 'height', 'min-width', 'min-height', 'max-width', 'max-height',
+  'margin-top', 'margin-right', 'margin-bottom', 'margin-left',
+  'padding-top', 'padding-right', 'padding-bottom', 'padding-left',
+  'top', 'right', 'bottom', 'left', 'gap', 'row-gap', 'column-gap',
+  'border-top-width', 'border-right-width', 'border-bottom-width', 'border-left-width',
+]);
+
+function pxOf(v) {
+  if (typeof v !== 'string') return null;
+  const m = /^(-?\d+(?:\.\d+)?)px$/.exec(v.trim());
+  return m ? Number(m[1]) : null;
+}
+
+function normalize(v) {
+  if (typeof v !== 'string') return v;
+  return v.trim().toLowerCase().replace(/\s+/g, ' ');
+}
+
+function compareValue(prop, expected, actual) {
+  if (normalize(expected) === normalize(actual)) return { ok: true };
+  if (BOX_PROPS.has(prop)) {
+    const ep = pxOf(expected), ap = pxOf(actual);
+    if (ep !== null && ap !== null) {
+      const delta = Math.abs(ep - ap);
+      return { ok: delta <= 4, severity: delta > 4 ? 'P1' : 'P2', delta };
+    }
+  }
+  return { ok: false, severity: 'P1' };
+}
+
+function walkNodes(section) {
+  const flat = [];
+  const recur = (n) => {
+    flat.push(n);
+    for (const c of (n.children || [])) recur(c);
+  };
+  flat.push({ id: section.nodeRef, css: section.css, tag: section.tag, classes: section.classes });
+  for (const c of (section.children || [])) recur(c);
+  return flat;
+}
+
+// ─── Main ───────────────────────────────────────────────────────────
+function main() {
+  const sectionsJson = JSON.parse(fs.readFileSync(sectionsPath, 'utf8'));
+  const classPlanPath = path.join(stylesDir, 'class-plan.json');
+  if (!fs.existsSync(classPlanPath)) {
+    console.error(`class-plan.json not found at ${classPlanPath}. Run clone-to-scss.js first.`);
+    process.exit(2);
+  }
+  const classPlan = JSON.parse(fs.readFileSync(classPlanPath, 'utf8'));
+
+  const targets = opts.section
+    ? sectionsJson.sections.filter((s) => s.name === opts.section)
+    : sectionsJson.sections;
+
+  if (opts.section && targets.length === 0) {
+    console.error(`Section not found: ${opts.section}`);
+    process.exit(2);
+  }
+
+  const issues = [];
+  let totalChecked = 0;
+
+  for (const section of targets) {
+    const kebabName = section.name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+    const scssPath = path.join(stylesDir, 'sections', `_${kebabName}.scss`);
+    if (!fs.existsSync(scssPath)) {
+      issues.push({ section: section.name, severity: 'P1', kind: 'missing-file', path: scssPath });
+      continue;
+    }
+    const scss = fs.readFileSync(scssPath, 'utf8');
+    const rules = parseScss(scss);
+
+    const flat = walkNodes(section);
+    for (const node of flat) {
+      const cls = classPlan[node.id];
+      if (!cls || !node.css) continue;
+      const selector = `.${cls}`;
+      const declared = rules.get(selector) || {};
+
+      for (const [prop, expected] of Object.entries(node.css)) {
+        if (prop.startsWith('--')) continue;
+        if (!expected || expected === 'normal' || expected === 'auto' || expected === 'none') continue;
+        totalChecked++;
+        const actual = declared[prop];
+        if (actual === undefined) {
+          issues.push({
+            section: section.name,
+            nodeId: node.id,
+            class: cls,
+            prop,
+            severity: 'P1',
+            kind: 'missing-prop',
+            expected,
+          });
+          continue;
+        }
+        const cmp = compareValue(prop, expected, actual);
+        if (!cmp.ok) {
+          issues.push({
+            section: section.name,
+            nodeId: node.id,
+            class: cls,
+            prop,
+            severity: cmp.severity,
+            kind: 'value-mismatch',
+            expected,
+            actual,
+            delta: cmp.delta,
+          });
+        }
+      }
+    }
+  }
+
+  const p1 = issues.filter((i) => i.severity === 'P1');
+  const p2 = issues.filter((i) => i.severity === 'P2');
+  const p3 = issues.filter((i) => i.severity === 'P3');
+
+  if (!opts.quiet) {
+    console.log(`[clone-validate] checked ${totalChecked} declarations across ${targets.length} section(s)`);
+    console.log(`  P1: ${p1.length}, P2: ${p2.length}, P3: ${p3.length}`);
+    const show = (label, list, limit = 20) => {
+      if (list.length === 0) return;
+      console.log(`\n${label}:`);
+      for (const it of list.slice(0, limit)) {
+        const loc = it.class ? `.${it.class}` : it.path || '?';
+        if (it.kind === 'missing-file') console.log(`  ${it.severity} ${it.section}: missing ${it.path}`);
+        else if (it.kind === 'missing-prop') console.log(`  ${it.severity} ${loc} { ${it.prop}: MISSING (expected ${it.expected}) }`);
+        else console.log(`  ${it.severity} ${loc} { ${it.prop}: ${it.actual} ≠ ${it.expected}${it.delta != null ? ` (Δ${it.delta}px)` : ''} }`);
+      }
+      if (list.length > limit) console.log(`  …and ${list.length - limit} more`);
+    };
+    show('P1 issues', p1);
+    show('P2 issues', p2);
+  }
+
+  if (p1.length > 0) {
+    if (!opts.quiet) console.error(`\n[clone-validate] FAIL: ${p1.length} P1 issue(s)`);
+    process.exit(1);
+  }
+  if (!opts.quiet) console.log('\n[clone-validate] PASS');
+  process.exit(0);
+}
+
+try { main(); }
+catch (e) {
+  console.error(`[clone-validate] FAIL: ${e.message}`);
+  if (process.env.DEBUG) console.error(e.stack);
+  process.exit(2);
+}

package/hooks/scripts/lib/curation-index.js

@@ -0,0 +1,101 @@
+/**
+ * Phase 3 — Curation index loader
+ *
+ * `.vibe/recipes/*.md` 와 `.vibe/anti-patterns/*.md` 의 frontmatter 만 parse 해
+ * 1줄 요약 인덱스를 만든다. 본문은 읽지 않음 (세션 컨텍스트 절약).
+ *
+ * SPEC 결정:
+ *   - INDEX.jsonl 미사용. 디렉토리 스캔 + frontmatter parse 가 충분히 빠르다 (<100 파일).
+ *   - 최근 N=5 상한 (created 내림차순).
+ *
+ * 의도적 제한:
+ *   - 본격 YAML parser 의존성 추가 거부. 우리가 *직접 작성*한 frontmatter 만
+ *     읽으므로 문법이 정해져 있다. 라인별 정규식이면 충분.
+ */
+import fs from 'fs';
+import path from 'path';
+import { projectVibeRoot } from '../utils.js';
+
+const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---/;
+// "key: value" 또는 'key: "quoted value"' (이스케이프 \\" 포함)
+const FIELD_RE = /^([a-z][a-z0-9_-]*):\s*(?:"((?:[^"\\]|\\.)*)"|(.+?))\s*$/;
+
+function parseFrontmatter(content) {
+  const m = FRONTMATTER_RE.exec(content);
+  if (!m) return null;
+  const fields = {};
+  for (const line of m[1].split('\n')) {
+    const fm = FIELD_RE.exec(line);
+    if (!fm) continue;
+    const key = fm[1];
+    const value = fm[2] !== undefined ? fm[2].replace(/\\"/g, '"') : fm[3];
+    fields[key] = value;
+  }
+  return fields;
+}
+
+function readHead(filePath, bytes = 2048) {
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    const buf = Buffer.alloc(bytes);
+    const n = fs.readSync(fd, buf, 0, bytes, 0);
+    return buf.toString('utf-8', 0, n);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function listMd(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter((f) => f.endsWith('.md') && !f.startsWith('_') && f !== 'README.md')
+    .map((f) => path.join(dir, f));
+}
+
+function safeParse(filePath) {
+  try {
+    const head = readHead(filePath);
+    const fields = parseFrontmatter(head);
+    if (!fields || !fields.slug) return null;
+    return fields;
+  } catch {
+    return null;
+  }
+}
+
+function compareCreatedDesc(a, b) {
+  // created 가 ISO 면 문자열 비교로 시간 정렬 가능, 아니면 mtime fallback
+  return (b.created || '').localeCompare(a.created || '');
+}
+
+/**
+ * 프로젝트의 recipes + anti-patterns 인덱스를 로드.
+ * @returns { recipes: [{slug, summary}], antiPatterns: [{tag, summary}] }
+ */
+export function loadCurationIndex(projectDir, opts = {}) {
+  const { recipeLimit = 5, antiPatternLimit = 5 } = opts;
+  const root = projectVibeRoot(projectDir);
+
+  const recipes = listMd(path.join(root, 'recipes'))
+    .map(safeParse).filter(Boolean)
+    .sort(compareCreatedDesc)
+    .slice(0, recipeLimit)
+    .map((f) => ({
+      slug: f.slug,
+      summary: f.recipe || f['symptom-context'] || '(no summary)',
+    }));
+
+  const antiPatterns = listMd(path.join(root, 'anti-patterns'))
+    .map(safeParse).filter(Boolean)
+    .sort(compareCreatedDesc)
+    .slice(0, antiPatternLimit)
+    .map((f) => ({
+      tag: f['root-cause-tag'] || 'other',
+      summary: f['suggested-stop'] || f['trigger-signature'] || '(no summary)',
+    }));
+
+  return { recipes, antiPatterns };
+}
+
+/** Test-only: frontmatter parser 노출 */
+export const _internal = { parseFrontmatter };