@su-record/vibe 2.9.40 → 2.10.2

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/codex-notify.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+/**
+ * Codex notify adapter — Codex `~/.codex/config.toml` 의 `notify` 프로그램으로 호출됨.
+ *
+ * Codex 는 Claude Code 의 Stop hook 등가물이 없다. 대신 lifecycle 이벤트마다
+ * `notify` 에 등록된 프로그램을 마지막 인자로 JSON payload 를 붙여 실행한다.
+ * 이 어댑터는 `agent-turn-complete` 이벤트를 CC 의 Stop 에 매핑해, stdin 이 필요
+ * 없는 결정적 후처리(auto-commit, devlog-gen)만 재사용한다.
+ *
+ * - codex-review-gate: stdout→Claude 주입 방식이라 Codex 에서 의미 없음 → 제외
+ * - stop-notify: Codex 가 자체 완료 표시를 하므로 중복 알림 방지 위해 제외
+ *
+ * 재귀 가드: VIBE_HOOK_DEPTH 가 있으면(자식 세션) 건너뛴다.
+ */
+import { spawnSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+if (process.env.VIBE_HOOK_DEPTH) process.exit(0);
+
+// Codex 는 payload JSON 을 마지막 인자로 전달한다.
+function parsePayload() {
+  const raw = process.argv[process.argv.length - 1];
+  if (!raw || raw === path.basename(process.argv[1] ?? '')) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+const payload = parsePayload();
+const type = payload?.type ?? payload?.['type'];
+
+// turn 완료 이벤트만 처리 (CC 의 Stop 등가)
+if (type !== 'agent-turn-complete') process.exit(0);
+
+const TURN_COMPLETE_SCRIPTS = ['auto-commit.js', 'devlog-gen.js'];
+
+for (const script of TURN_COMPLETE_SCRIPTS) {
+  spawnSync(process.execPath, [path.join(__dirname, script)], {
+    stdio: ['ignore', 'inherit', 'inherit'],
+    env: { ...process.env, VIBE_HOOK_DEPTH: '1' },
+  });
+}
+
+process.exit(0);

package/hooks/scripts/command-log.js

@@ -1,7 +1,7 @@
 /**
  * PreToolUse Hook - 모든 Bash 명령어를 타임스탬프와 함께 로깅
  *
- * 로그 위치: .vibe/command-log.txt (legacy .claude/vibe/ 또는 .coco/vibe/ 사용 중이면 그쪽)
+ * 로그 위치: .vibe/command-log.txt (legacy .claude/vibe/ 사용 중이면 그쪽)
  * exit 0 항상 통과 (로깅만 수행, 차단하지 않음)
  */
 import { appendFileSync, mkdirSync, existsSync } from 'fs';

package/hooks/scripts/lib/dispatcher.js

@@ -26,12 +26,11 @@ const SCRIPTS_DIR = path.resolve(__dirname, '..');
 
 function loadHookConfig() {
   try {
-    const projectDir = process.env.CLAUDE_PROJECT_DIR || process.env.COCO_PROJECT_DIR || process.cwd();
-    // Vibe config 탐색 — `.vibe/` 를 SSOT 로 삼고, legacy `.claude/vibe/`, `.coco/vibe/` fallback
+    const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    // Vibe config 탐색 — `.vibe/` 를 SSOT 로 삼고, legacy `.claude/vibe/` fallback
     const candidates = [
       path.join(projectDir, '.vibe', 'config.json'),
       path.join(projectDir, '.claude', 'vibe', 'config.json'),
-      path.join(projectDir, '.coco', 'vibe', 'config.json'),
     ];
     const configPath = candidates.find(p => fs.existsSync(p));
     if (!configPath) return {};

package/hooks/scripts/lib/scope-from-spec.js

@@ -27,7 +27,6 @@ export function isScopeGuardEnabled(projectDir) {
     const candidates = [
       path.join(projectDir, '.vibe', 'config.json'),
       path.join(projectDir, '.claude', 'vibe', 'config.json'),
-      path.join(projectDir, '.coco', 'vibe', 'config.json'),
     ];
     for (const p of candidates) {
       if (!fs.existsSync(p)) continue;
@@ -39,14 +38,13 @@ export function isScopeGuardEnabled(projectDir) {
 }
 
 /**
- * Vibe 에셋 루트 해석 — `.vibe/` (SSOT) 우선, legacy `.claude/vibe/`, `.coco/vibe/` fallback.
+ * Vibe 에셋 루트 해석 — `.vibe/` (SSOT) 우선, legacy `.claude/vibe/` fallback.
  * 반환값은 projectDir 기준 상대 경로 문자열 (예: `.vibe`, `.claude/vibe`).
  */
 function detectVibeRoot(projectDir) {
   try {
     if (fs.existsSync(path.join(projectDir, '.vibe'))) return '.vibe';
     if (fs.existsSync(path.join(projectDir, '.claude', 'vibe'))) return '.claude/vibe';
-    if (fs.existsSync(path.join(projectDir, '.coco', 'vibe'))) return '.coco/vibe';
   } catch { /* ignore */ }
   return '.vibe';
 }
@@ -108,7 +106,7 @@ function extractPaths(markdown) {
     // 명백한 비경로 제외
     if (/^[A-Z_]+$/.test(raw)) continue; // 상수
     if (/^\d+$/.test(raw)) continue; // 숫자
-    if (raw.startsWith('.') && !raw.startsWith('./') && !raw.startsWith('.vibe') && !raw.startsWith('.claude') && !raw.startsWith('.coco')) continue;
+    if (raw.startsWith('.') && !raw.startsWith('./') && !raw.startsWith('.vibe') && !raw.startsWith('.claude')) continue;
 
     const normalized = raw.replace(/^\.\//, '').replace(/\\/g, '/');
     // 각 세그먼트 안전성 재검증 — "a.b.c" 같은 필드 경로 제거