@su-record/vibe 2.9.40 → 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/step-counter.js

@@ -68,7 +68,7 @@ function isResponseError(toolResponse) {
 }
 
 // ─────────────────────────────────────────────────────
-// 책임 3a: error_category 분류 (regex 만 — vibe-regress tag enum 일부)
+// 책임 3a: error_category 분류 (regex 만 — regress tag enum 일부)
 // ─────────────────────────────────────────────────────
 const ERROR_CATEGORIES = [
   { tag: 'nullability', re: /Cannot read propert(?:y|ies) of (?:undefined|null)|TypeError[^\n]*(?:undefined|null)/i },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@su-record/vibe",
-  "version": "2.9.40",
+  "version": "2.10.0",
   "description": "AI Coding Framework for Claude Code — 56 agents, 45 skills, multi-LLM orchestration",
   "type": "module",
   "main": "dist/cli/index.js",
@@ -27,6 +27,7 @@
     "dev": "tsc --watch",
     "gen:skill-docs": "npx tsx scripts/gen-skill-docs.ts",
     "gen:skill-docs:check": "npx tsx scripts/gen-skill-docs.ts --check",
+    "validate:skill-invocation": "npx tsx scripts/validate-skill-invocation.ts",
     "test": "vitest run",
     "test:watch": "vitest",
     "prepublishOnly": "pnpm build",

package/skills/agents-md/SKILL.md

@@ -1,5 +1,7 @@
 ---
 name: agents-md
+user-invocable: false
+invocation: [auto, chain]
 tier: standard
 description: "Optimize AGENTS.md / CLAUDE.md by removing discoverable info and keeping only gotchas. Based on Addy Osmani's AGENTS.md principles. Activates on agents.md, claude.md, context file optimization."
 triggers: [agents.md, claude.md, context file, optimize agents, optimize claude]

package/skills/arch-guard/SKILL.md

@@ -1,5 +1,7 @@
 ---
 name: arch-guard
+user-invocable: false
+invocation: [auto]
 tier: core
 description: "Generate architecture boundary tests that mechanically enforce layer constraints. Use when adding new modules, refactoring layers, or after detecting circular dependencies. Creates import-rule tests (e.g., 'UI must not import DB') that fail CI on violation. Must use this skill when user mentions layer enforcement, dependency rules, or architectural boundaries — even casually like 'make sure services don't import controllers'."
 triggers: [arch guard, architecture test, layer test, boundary test, structural test, arch validation]

package/skills/brand-assets/SKILL.md

@@ -1,5 +1,6 @@
 ---
 name: brand-assets
+invocation: [auto]
 tier: standard
 description: "Auto-generate app icons (iOS/Android/PWA), favicons, and OG images from SPEC brand information using Gemini Image API. Use when the project needs visual brand assets, when user mentions 'icon', 'favicon', 'logo', or 'brand assets', or when a SPEC defines brand colors/identity but no assets exist yet. Outputs multiple sizes and formats ready for deployment. Not for complex illustration or marketing graphics — focused on app identity assets."
 triggers: [icon, favicon, brand, logo, app icon, branding, assets]

package/skills/capability-loop/SKILL.md

@@ -1,5 +1,7 @@
 ---
 name: capability-loop
+user-invocable: false
+invocation: [auto]
 tier: standard
 description: "When an agent fails, diagnose which capability is missing and build it into the repo. Activates after repeated agent failures, tool errors, or when a task keeps failing in the same way. Analyzes failure transcripts, identifies the missing guardrail/tool/abstraction/doc, and creates it permanently. Use this skill whenever you see 3+ similar failures, an agent hitting the same wall repeatedly, or the user asking 'why does this keep failing'."
 triggers: [capability loop, failure loop, build capability, missing capability, agent failed, why did it fail]

package/skills/characterization-test/SKILL.md

@@ -1,5 +1,7 @@
 ---
 name: characterization-test
+user-invocable: false
+invocation: [auto]
 tier: core
 description: "Lock existing behavior with characterization tests before modifying code. Use BEFORE any refactor, rewrite, or large-scale modification of existing code — especially legacy code without tests. Captures current input/output behavior as test cases so regressions are caught immediately. Must use this skill when touching files >200 lines with no existing tests, when user says 'refactor', 'rewrite', 'modernize', or 'clean up' existing code."
 triggers: [legacy, characterization test, lock behavior, regression prevention, before refactor, large file]

package/skills/chub-usage/SKILL.md

@@ -1,5 +1,6 @@
 ---
 name: chub-usage
+invocation: [auto]
 tier: optional
 description: "Context Hub (chub) — fetch vetted, up-to-date API documentation. Write accurate code based on the latest docs instead of training data when working with external APIs/SDKs."
 triggers: [chub, context hub, API docs, latest API, deprecated API, SDK documentation, api reference, 최신 문서]

package/skills/claude-md-guide/SKILL.md

@@ -1,5 +1,7 @@
 ---
 name: claude-md-guide
+user-invocable: false
+invocation: [auto]
 tier: standard
 description: "Guide for writing effective CLAUDE.md files from scratch. Evidence-based methodology from 40+ sources including research papers, official docs, and real-world examples. Covers 3-layer architecture, Curse of Instructions mitigation, progressive disclosure, and maintenance. Use when creating new CLAUDE.md, improving existing ones, or teaching team members how to write project instructions for AI agents."
 triggers: [claude-md guide, write claude.md, create claude.md, claude.md 작성, 클로드 문서, project instructions, claude-md]