@su-record/vibe 3.0.0 → 3.2.0

package/hooks/scripts/clone-merge-responsive.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+
+/**
+ * clone-merge-responsive.js — MO/PC per-BP SCSS → mobile-first responsive merge
+ *
+ * Usage:
+ *   node clone-merge-responsive.js --mo=<styles-dir> --pc=<styles-dir> --out=<dir> [--breakpoint=1024]
+ *
+ * Why this exists (clone Phase 3C):
+ *   Phase 3A/3B produce two fixed-viewport SCSS trees (styles/{feature}/mo, /pc).
+ *   This merges them mobile-first: MO declarations become the base, and only the
+ *   declarations where PC differs go into a single @media (min-width: <bp>) block.
+ *   Deterministic text merge — no value invention. Post-merge correctness is judged
+ *   by Phase 5 (pixel + computed-CSS verification at BOTH viewports).
+ *
+ * Fail-open:
+ *   - PC-only selectors → whole rule inside the media block
+ *   - MO-only selectors → base as-is (reported)
+ *   - unparseable/missing files → reported and skipped, never a hard abort
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { parseScss, normalize } from './clone-validate.js';
+
+// ─── CLI ────────────────────────────────────────────────────────────
+function parseArgs(argv) {
+  const opts = { breakpoint: 1024 };
+  for (const a of argv.slice(2)) {
+    if (a.startsWith('--mo=')) opts.mo = a.slice(5);
+    else if (a.startsWith('--pc=')) opts.pc = a.slice(5);
+    else if (a.startsWith('--out=')) opts.out = a.slice(6);
+    else if (a.startsWith('--breakpoint=')) opts.breakpoint = Number(a.slice(13)) || 1024;
+  }
+  return opts;
+}
+
+// ─── Merge core (pure — exported for tests) ─────────────────────────
+// moRules/pcRules: Map<selector, {prop: value}> (parseScss output)
+// → { base: Map, media: Map, stats }
+function mergeRules(moRules, pcRules) {
+  const base = new Map();
+  const media = new Map();
+  const stats = { selectors: 0, moOnly: 0, pcOnly: 0, overrides: 0, shared: 0 };
+
+  const selectors = new Set([...moRules.keys(), ...pcRules.keys()]);
+  for (const sel of selectors) {
+    stats.selectors++;
+    const mo = moRules.get(sel);
+    const pc = pcRules.get(sel);
+    if (mo && Object.keys(mo).length) base.set(sel, mo);
+
+    if (!pc || !Object.keys(pc).length) { if (mo) stats.moOnly++; continue; }
+    if (!mo || !Object.keys(mo).length) {
+      // PC 전용 셀렉터 — 데스크탑에서만 존재하는 노드
+      media.set(sel, pc);
+      stats.pcOnly++;
+      continue;
+    }
+
+    const diff = {};
+    for (const [prop, val] of Object.entries(pc)) {
+      if (mo[prop] === undefined || normalize(mo[prop]) !== normalize(val)) diff[prop] = val;
+    }
+    if (Object.keys(diff).length) { media.set(sel, diff); stats.overrides++; }
+    else stats.shared++;
+  }
+  return { base, media, stats };
+}
+
+function emitRules(rules, indent) {
+  const out = [];
+  for (const [sel, decls] of rules) {
+    const body = Object.entries(decls).map(([p, v]) => `${indent}  ${p}: ${v};`).join('\n');
+    if (!body) continue;
+    out.push(`${indent}${sel} {\n${body}\n${indent}}`);
+  }
+  return out.join('\n\n');
+}
+
+// Merged partial: MO base rules + one @media (min-width) block with PC diffs.
+function emitMerged(moRules, pcRules, breakpoint, header) {
+  const { base, media, stats } = mergeRules(moRules, pcRules);
+  const parts = [header, '', emitRules(base, '')];
+  if (media.size) {
+    parts.push('');
+    parts.push(`@media (min-width: ${breakpoint}px) {`);
+    parts.push(emitRules(media, '  '));
+    parts.push('}');
+  }
+  return { scss: parts.filter((p) => p !== null).join('\n') + '\n', stats };
+}
+
+// ─── File-level orchestration ───────────────────────────────────────
+function readScssRules(file) {
+  if (!fs.existsSync(file)) return null;
+  try { return parseScss(fs.readFileSync(file, 'utf8')); }
+  catch (e) {
+    console.error(`[clone-merge] parse skipped (${e.message}): ${file}`);
+    return null;
+  }
+}
+
+function listSections(dir) {
+  const d = path.join(dir, 'sections');
+  if (!fs.existsSync(d)) return [];
+  return fs.readdirSync(d).filter((f) => f.startsWith('_') && f.endsWith('.scss'));
+}
+
+function mergeTokens(moDir, pcDir, outDir, breakpoint) {
+  const mo = readScssRules(path.join(moDir, '_tokens.scss')) || new Map();
+  const pc = readScssRules(path.join(pcDir, '_tokens.scss')) || new Map();
+  const { scss } = emitMerged(mo, pc, breakpoint, '// Auto-merged by clone-merge-responsive.js (mobile-first)');
+  fs.writeFileSync(path.join(outDir, '_tokens.scss'), scss);
+}
+
+function copyIfExists(src, dst) {
+  if (fs.existsSync(src)) fs.copyFileSync(src, dst);
+}
+
+function mergeClassPlans(moDir, pcDir, outDir) {
+  const read = (d) => {
+    const f = path.join(d, 'class-plan.json');
+    return fs.existsSync(f) ? JSON.parse(fs.readFileSync(f, 'utf8')) : {};
+  };
+  // MO 우선 — 동일 노드 id가 다른 클래스면 MO가 base이므로 MO를 채택
+  const merged = { ...read(pcDir), ...read(moDir) };
+  fs.writeFileSync(path.join(outDir, 'class-plan.json'), JSON.stringify(merged, null, 2));
+}
+
+function main() {
+  const opts = parseArgs(process.argv);
+  if (!opts.mo || !opts.pc || !opts.out) {
+    console.error('Usage: node clone-merge-responsive.js --mo=<styles-dir> --pc=<styles-dir> --out=<dir> [--breakpoint=1024]');
+    process.exit(2);
+  }
+
+  fs.mkdirSync(path.join(opts.out, 'sections'), { recursive: true });
+
+  const files = [...new Set([...listSections(opts.mo), ...listSections(opts.pc)])].sort();
+  const totals = { selectors: 0, moOnly: 0, pcOnly: 0, overrides: 0, shared: 0 };
+  const merged = [];
+
+  for (const f of files) {
+    const mo = readScssRules(path.join(opts.mo, 'sections', f)) || new Map();
+    const pc = readScssRules(path.join(opts.pc, 'sections', f)) || new Map();
+    if (!mo.size && !pc.size) { console.error(`[clone-merge] empty on both BPs, skipped: ${f}`); continue; }
+    const { scss, stats } = emitMerged(mo, pc, opts.breakpoint, `// Section: ${f} — merged mobile-first`);
+    fs.writeFileSync(path.join(opts.out, 'sections', f), scss);
+    for (const k of Object.keys(totals)) totals[k] += stats[k];
+    merged.push(f);
+  }
+
+  mergeTokens(opts.mo, opts.pc, opts.out, opts.breakpoint);
+  copyIfExists(path.join(opts.mo, '_base.scss'), path.join(opts.out, '_base.scss'));
+  copyIfExists(path.join(opts.mo, '_shared.scss'), path.join(opts.out, '_shared.scss'));
+  mergeClassPlans(opts.mo, opts.pc, opts.out);
+
+  const index = [
+    '// Auto-merged by clone-merge-responsive.js — mobile-first responsive',
+    '',
+    `@use './tokens';`,
+    `@use './base';`,
+    `@use './shared';`,
+    ...merged.map((f) => `@use './sections/${f.replace(/^_|\.scss$/g, '')}';`),
+  ].join('\n') + '\n';
+  fs.writeFileSync(path.join(opts.out, 'index.scss'), index);
+
+  console.log(`[clone-merge] done → ${opts.out}`);
+  console.log(`  sections: ${merged.length}, selectors: ${totals.selectors} (shared ${totals.shared}, overrides ${totals.overrides}, mo-only ${totals.moOnly}, pc-only ${totals.pcOnly})`);
+  console.log(`  breakpoint: @media (min-width: ${opts.breakpoint}px)`);
+}
+
+const isMain = process.argv[1] && process.argv[1].replace(/\\/g, '/').endsWith('clone-merge-responsive.js');
+if (isMain) {
+  try { main(); }
+  catch (e) {
+    console.error(`[clone-merge] FAIL: ${e.message}`);
+    if (process.env.DEBUG) console.error(e.stack);
+    process.exit(1);
+  }
+}
+
+export { mergeRules, emitMerged };

package/hooks/scripts/clone-spec.js

@@ -28,6 +28,7 @@ function parseArgs(argv) {
     else if (a.startsWith('--section=')) opts.section = a.slice(10);
     else if (a.startsWith('--feature=')) opts.feature = a.slice(10);
     else if (a.startsWith('--behaviors=')) opts.behaviors = a.slice(12);
+    else if (a === '--real-content') opts.realContent = true;
   }
   return { sectionsPath, opts };
 }
@@ -101,20 +102,28 @@ function sectionHasNode(section, tag, cls) {
   return (section.children || []).some(hit);
 }
 
+function diffLines(changed) {
+  return Object.entries(changed)
+    .map(([k, v]) => `    - ${k}: \`${v.from}\` → \`${v.to}\``).join('\n');
+}
+
 function behaviorsBlock(section, behaviors) {
   if (!behaviors) return null;
-  const scroll = (behaviors.scroll || []).filter((b) => sectionHasNode(section, b.tag, b.cls));
+  const inSection = (list) => (list || []).filter((b) => sectionHasNode(section, b.tag, b.cls));
+  const scroll = inSection(behaviors.scroll);
+  const hover = inSection(behaviors.hover);
+  const inview = inSection(behaviors.inview);
+  const timed = inSection(behaviors.timeDriven);
   // Tab groups aren't tag-keyed; attach to any section that contains a [role=tab]-ish node.
   const tabs = (behaviors.interactive || []).filter(() =>
     sectionHasNode(section, 'button') || sectionHasNode(section, 'li') || sectionHasNode(section, 'a'),
   );
-  if (!scroll.length && !tabs.length) return null;
+  const lib = behaviors.scrollLib;
+  if (!scroll.length && !tabs.length && !hover.length && !inview.length && !timed.length && !lib) return null;
 
   const lines = [];
   for (const b of scroll) {
-    const diffs = Object.entries(b.changed)
-      .map(([k, v]) => `    - ${k}: \`${v.from}\` → \`${v.to}\``).join('\n');
-    lines.push(`- **Scroll-triggered** on \`${b.label}\` (past ~${b.triggerScrollY}px scroll):\n${diffs}`);
+    lines.push(`- **Scroll-triggered** on \`${b.label}\` (past ~${b.triggerScrollY}px scroll):\n${diffLines(b.changed)}`);
   }
   for (const t of tabs) {
     const labels = (t.tabLabels || []).map((l) => `"${l}"`).join(', ') || '(unlabeled)';
@@ -123,6 +132,19 @@ function behaviorsBlock(section, behaviors) {
       : 'no content swap detected (styling-only tabs)';
     lines.push(`- **Tab group** ×${t.count} [${labels}]: ${swap}`);
   }
+  for (const b of hover) {
+    const tr = b.transition && b.transition !== 'all 0s ease 0s' ? ` (transition: \`${b.transition}\`)` : '';
+    lines.push(`- **Hover** on \`${b.label}\`${tr}:\n${diffLines(b.changed)}`);
+  }
+  for (const b of inview) {
+    lines.push(`- **In-view entrance** on \`${b.label}\` (enters at ~${b.triggerY}px):\n${diffLines(b.changed)}`);
+  }
+  for (const b of timed) {
+    lines.push(`- **Time-driven** \`${b.label}\` — ${b.mutations} mutations/3s [${(b.kinds || []).join(', ')}] → carousel/auto-cycle candidate`);
+  }
+  if (lib) {
+    lines.push(`- **Smooth-scroll library (page-level):** ${lib.name} (evidence: \`${lib.evidence}\`) → wire in globals, not per-section`);
+  }
   return lines.join('\n');
 }
 
@@ -171,7 +193,9 @@ ${cssBlock(section.css)}
 ## Assets (local paths only — never hotlink)
 ${assetsBlock(section.images)}
 
-## Text content (replace copyrighted copy with placeholders)
+## Text content ${meta.realContent
+    ? '(verbatim — user confirmed rights to reuse this copy)'
+    : '(replace copyrighted copy with placeholders)'}
 ${textBlock}
 
 ## Component candidates
@@ -179,7 +203,7 @@ ${componentsBlock(section.components)}
 
 ## Build checklist
 - [ ] HTML semantics + final tags chosen
-- [ ] SCSS via clone-to-scss.js (computed values as-is — no eyeballing)
+- [ ] SCSS started from the clone-to-scss.js draft — value edits only with evidence cited from computed.json/states.json/behaviors.json (no eyeballing); clone-validate.js is the judge
 - [ ] Every state above implemented
 - [ ] Interaction model confirmed on live site & wired
 - [ ] All assets local (public/images/${meta.feature}/) — no hotlinks
@@ -196,6 +220,7 @@ function main() {
     url: data.meta && data.meta.url,
     viewport: data.meta && data.meta.viewport,
     bp: opts.section ? (data.meta && data.meta.bp) : (data.meta && data.meta.bp) || '?',
+    realContent: !!opts.realContent,
   };
   // behaviors.json (active interaction sweep) lives next to the source computed.json.
   const behaviorsPath = opts.behaviors || path.join(path.dirname(sectionsPath), 'behaviors.json');
@@ -223,7 +248,7 @@ function main() {
 const isMain = process.argv[1] && process.argv[1].replace(/\\/g, '/').endsWith('clone-spec.js');
 if (isMain) {
   if (!sectionsPath || !opts.out) {
-    console.error('Usage: node clone-spec.js <sections.json> --out=<dir> [--section=Name] [--feature=name] [--behaviors=path]');
+    console.error('Usage: node clone-spec.js <sections.json> --out=<dir> [--section=Name] [--feature=name] [--behaviors=path] [--real-content]');
     process.exit(1);
   }
   try { main(); }

package/hooks/scripts/clone-validate.js

@@ -34,10 +34,6 @@ function parseArgs(argv) {
 }
 
 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.
@@ -272,9 +268,19 @@ function main() {
   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);
+// isMain 가드 — clone-merge-responsive.js가 parseScss를 import할 때 main()이 돌면 안 된다
+const isMain = process.argv[1] && process.argv[1].replace(/\\/g, '/').endsWith('clone-validate.js');
+if (isMain) {
+  if (!stylesDir || !sectionsPath) {
+    console.error('Usage: node clone-validate.js <styles-dir> <sections.json> [--section=<name>]');
+    process.exit(2);
+  }
+  try { main(); }
+  catch (e) {
+    console.error(`[clone-validate] FAIL: ${e.message}`);
+    if (process.env.DEBUG) console.error(e.stack);
+    process.exit(2);
+  }
 }
+
+export { parseScss, normalize, compareValue };

package/hooks/scripts/code-check.js

@@ -14,6 +14,7 @@ import { getToolsBaseUrl, PROJECT_DIR, readProjectConfig } from './utils.js';
 import { readFileSync } from 'fs';
 import path from 'path';
 import { buildCliCtx, isDirectRun } from './lib/hook-context.js';
+import { globToRegExp } from './lib/glob.js';
 
 const BASE_URL = getToolsBaseUrl();
 
@@ -42,35 +43,6 @@ const DEFAULT_CONSOLE_ALLOW_GLOBS = [
   '**/__tests__/**',
 ];
 
-/**
- * 경량 glob → RegExp 변환 (scope-guard와 동일 알고리즘, 독립 복사본).
- * @param {string} glob
- * @returns {RegExp}
- */
-function globToRegExp(glob) {
-  const normalized = glob.replace(/\\/g, '/');
-  let out = '';
-  for (let i = 0; i < normalized.length; i++) {
-    const c = normalized[i];
-    if (c === '*') {
-      if (normalized[i + 1] === '*') {
-        out += '.*';
-        i++;
-        if (normalized[i + 1] === '/') i++;
-      } else {
-        out += '[^/]*';
-      }
-    } else if (c === '?') {
-      out += '[^/]';
-    } else if ('.+^$()|{}[]\\'.includes(c)) {
-      out += '\\' + c;
-    } else {
-      out += c;
-    }
-  }
-  return new RegExp('^' + out + '$');
-}
-
 /**
  * .vibe/config.json의 qualityCheck.consoleAllow 글로브 목록 로드.
  * 기본 글로브와 병합하여 반환.
@@ -105,19 +77,12 @@ function isConsoleAllowed(filePath) {
 }
 
 /**
- * hook input에서 수정된 파일 경로 추출.
+ * hook ctx에서 수정된 파일 경로 추출.
  * @param {object} ctx
  * @returns {string[]}
  */
 function getModifiedFiles(ctx) {
-  try {
-    const parsed = ctx.payload || (ctx.hookInput ? JSON.parse(ctx.hookInput) : null);
-    const filePath = parsed?.tool_input?.file_path || parsed?.tool_input?.path;
-    return filePath ? [filePath] : [];
-  } catch {
-    // ignore
-  }
-  return [];
+  return ctx.filePath ? [ctx.filePath] : [];
 }
 
 /**
@@ -217,7 +182,7 @@ function runDetectors(filePath) {
 /**
  * in-process 진입점 — 품질 검사 + 관찰 캡처.
  * findings 배열을 반환한다 (디스패처가 수집해 additionalContext에 주입).
- * @param {{ payload: object|null, hookInput: string|null }} ctx
+ * @param {{ filePath: string }} ctx
  * @returns {Promise<{ exitCode: number, findings: string[] }>}
  */
 export async function run(ctx) {
@@ -225,9 +190,10 @@ export async function run(ctx) {
   const files = getModifiedFiles(ctx);
   if (files.length === 0) return { exitCode: 0, findings };
 
-  // 1. 하드룰 탐지기 실행 (changed file only) — additionalContext 주입만.
-  //    커밋 게이트(verifyRequired)는 태우지 않는다: 정규식 오탐 하나가
-  //    auto-commit을 차단하는 결합은 제거됨 (harness-review-2026-07-01).
+  // 1. 하드룰 탐지기 실행 (changed file only, regex only — 동적 import 없음) —
+  //    additionalContext 주입만. 커밋 게이트(verifyRequired)는 태우지 않는다:
+  //    정규식 오탐 하나가 auto-commit을 차단하는 결합은 제거됨
+  //    (harness-review-2026-07-01).
   try {
     const { p1 } = runDetectors(files[0]);
     for (const msg of p1) findings.push(msg);
@@ -235,6 +201,10 @@ export async function run(ctx) {
     // 탐지기 실패 → fail-open, 계속 진행
   }
 
+  // validateCodeQuality가 처리하지 않는 확장자는 무거운 동적 import
+  // (convention/index.js·memory/index.js — 모듈 그래프 + SQLite 오픈) 전에 조기 반환.
+  if (!CODE_EXT_RE.test(files[0])) return { exitCode: 0, findings };
+
   // 2. validateCodeQuality 호출 (P1/P2 필터)
   try {
     const module = await import(`${BASE_URL}convention/index.js`);
@@ -249,19 +219,21 @@ export async function run(ctx) {
     // Silently continue on check failure
   }
 
-  // 3. 관찰 자동 캡처
-  try {
-    const memModule = await import(`${BASE_URL}memory/index.js`);
-    const { type, title } = classifyObservation(files);
-
-    await memModule.addObservation({
-      type,
-      title: `${title}: ${files.map(f => f.split(/[\\/]/).pop()).join(', ')}`,
-      filesModified: files,
-      projectPath: PROJECT_DIR,
-    });
-  } catch {
-    // 관찰 캡처 실패해도 무시
+  // 3. 관찰 자동 캡처 — 위반(findings)이 실제로 있을 때만 SQLite 기록 (clean edit은 write 생략)
+  if (findings.length > 0) {
+    try {
+      const memModule = await import(`${BASE_URL}memory/index.js`);
+      const { type, title } = classifyObservation(files);
+
+      await memModule.addObservation({
+        type,
+        title: `${title}: ${files.map(f => f.split(/[\\/]/).pop()).join(', ')}`,
+        filesModified: files,
+        projectPath: PROJECT_DIR,
+      });
+    } catch {
+      // 관찰 캡처 실패해도 무시
+    }
   }
 
   return { exitCode: 0, findings };

package/hooks/scripts/lib/glob.js

@@ -0,0 +1,32 @@
+/**
+ * 경량 glob → RegExp 변환 — code-check.js·scope-guard.js 공용 (중복 제거).
+ *  - `**` : 경로 구분자 포함 임의 문자열
+ *  - `*`  : 구분자 제외 임의 문자열
+ *  - `?`  : 구분자 제외 한 글자
+ *  - 기타 정규식 메타문자는 이스케이프
+ * @param {string} glob
+ * @returns {RegExp}
+ */
+export function globToRegExp(glob) {
+  const normalized = glob.replace(/\\/g, '/');
+  let out = '';
+  for (let i = 0; i < normalized.length; i++) {
+    const c = normalized[i];
+    if (c === '*') {
+      if (normalized[i + 1] === '*') {
+        out += '.*';
+        i++;
+        if (normalized[i + 1] === '/') i++; // `**/` → `.*`
+      } else {
+        out += '[^/]*';
+      }
+    } else if (c === '?') {
+      out += '[^/]';
+    } else if ('.+^$()|{}[]\\'.includes(c)) {
+      out += '\\' + c;
+    } else {
+      out += c;
+    }
+  }
+  return new RegExp('^' + out + '$');
+}

package/hooks/scripts/lib/hook-context.js

@@ -7,11 +7,13 @@
  *   2. standalone CLI: antigravity-hooks.json / 기존 테스트가 스크립트를
  *      직접 실행 — isDirectRun()으로 감지해 stdin/argv/env에서 ctx를 구성
  *
- * ctx 형태: { toolName, toolInput, payload, hookInput }
+ * ctx 형태: { toolName, toolInput, payload, hookInput, filePath }
  *   - toolName: payload.tool_name 우선, argv 폴백 (현행 각 스크립트와 동일 우선순위)
  *   - toolInput: 문자열 정규화된 tool_input (payload → argv[3] → env.TOOL_INPUT)
  *   - payload: 파싱된 stdin JSON 또는 null
  *   - hookInput: stdin 원문 문자열 (code-check의 HOOK_INPUT 사용처 대체)
+ *   - filePath: toolInput 에서 뽑은 대상 파일 경로 (file_path → notebook_path →
+ *     path 우선순위 — 각 스크립트의 인라인 추출 로직과 동일 규약)
  */
 import fs from 'fs';
 import { pathToFileURL } from 'url';
@@ -96,6 +98,21 @@ export function readStdinSync() {
   return { raw: null, parsed: null, truncated: false };
 }
 
+/**
+ * toolInput(문자열화된 JSON)에서 대상 파일 경로 추출.
+ * 각 훅 스크립트의 인라인 추출과 동일 우선순위: file_path → notebook_path → path.
+ * @param {string} toolInput
+ * @returns {string}
+ */
+function extractFilePath(toolInput) {
+  try {
+    const parsed = JSON.parse(toolInput || '{}');
+    return parsed.file_path || parsed.notebook_path || parsed.path || '';
+  } catch {
+    return '';
+  }
+}
+
 /**
  * 실행 컨텍스트 구성. 우선순위는 현행 스크립트들과 동일:
  *   toolName: payload.tool_name → argvToolName
@@ -106,7 +123,7 @@ export function buildCtx({ rawInput = null, payload = null, argvToolName = '', a
   const toolInput = payload?.tool_input !== undefined && payload?.tool_input !== null
     ? (typeof payload.tool_input === 'string' ? payload.tool_input : JSON.stringify(payload.tool_input))
     : (argvToolInput || process.env.TOOL_INPUT || '');
-  return { toolName, toolInput, payload, hookInput: rawInput };
+  return { toolName, toolInput, payload, hookInput: rawInput, filePath: extractFilePath(toolInput) };
 }
 
 /** standalone CLI 모드용 ctx — stdin/argv/env에서 구성 */

package/hooks/scripts/post-edit.js

@@ -17,14 +17,13 @@ const CODE_EXT_RE = /\.(ts|tsx|js|jsx|mjs|cjs)$/;
 /**
  * in-process 진입점 — console.log 감지만 수행.
  * findings 배열 반환 (디스패처가 수집해 additionalContext에 주입).
- * @param {{ toolInput: string }} ctx
+ * @param {{ filePath: string }} ctx
  * @returns {Promise<{ exitCode: number, findings: string[] }>}
  */
 export async function run(ctx) {
   const findings = [];
   try {
-    const input = JSON.parse(ctx.toolInput || '{}');
-    const filePath = input.file_path || input.path || '';
+    const filePath = ctx.filePath;
 
     if (filePath && CODE_EXT_RE.test(filePath)) {
       const resolved = path.resolve(filePath);

package/hooks/scripts/prompt-dispatcher.js

@@ -76,7 +76,7 @@ const DISPATCH_RULES = [
   {
     pattern: /e2e.*테스트|e2e.*test|playwright|브라우저.*테스트|browser.*test/i,
     script: null,
-    echo: '[E2E MODE] Use /vibe.utils --e2e for Playwright-based browser testing. Supports visual regression and video recording.',
+    echo: '[E2E MODE] Use /vibe.verify --e2e for Playwright-based browser testing. Supports visual regression and video recording.',
     label: 'e2e-echo',
   },
 

package/hooks/scripts/scope-guard.js

@@ -23,6 +23,7 @@ import fs from 'fs';
 import path from 'path';
 import { PROJECT_DIR, logHookDecision, projectVibePath, projectVibeRoot } from './utils.js';
 import { buildCliCtx, isDirectRun } from './lib/hook-context.js';
+import { globToRegExp } from './lib/glob.js';
 
 const SCOPE_PATH = projectVibePath(PROJECT_DIR, 'scope.json');
 
@@ -45,37 +46,6 @@ function readScope() {
   }
 }
 
-/**
- * 경량 glob → RegExp 변환.
- *  - `**` : 경로 구분자 포함 임의 문자열
- *  - `*`  : 구분자 제외 임의 문자열
- *  - `?`  : 구분자 제외 한 글자
- *  - 기타 정규식 메타문자는 이스케이프
- */
-function globToRegExp(glob) {
-  const normalized = glob.replace(/\\/g, '/');
-  let out = '';
-  for (let i = 0; i < normalized.length; i++) {
-    const c = normalized[i];
-    if (c === '*') {
-      if (normalized[i + 1] === '*') {
-        out += '.*';
-        i++;
-        if (normalized[i + 1] === '/') i++; // `**/` → `.*`
-      } else {
-        out += '[^/]*';
-      }
-    } else if (c === '?') {
-      out += '[^/]';
-    } else if ('.+^$()|{}[]\\'.includes(c)) {
-      out += '\\' + c;
-    } else {
-      out += c;
-    }
-  }
-  return new RegExp('^' + out + '$');
-}
-
 function matchesAny(relPath, patterns) {
   return patterns.some(p => globToRegExp(p).test(relPath));
 }
@@ -87,18 +57,9 @@ function toRelative(filePath) {
   return rel || path.basename(filePath).replace(/\\/g, '/');
 }
 
-function extractFilePath(toolInput) {
-  if (!toolInput) return '';
-  if (typeof toolInput === 'string') {
-    try { return JSON.parse(toolInput).file_path || ''; }
-    catch { return toolInput; }
-  }
-  return typeof toolInput.file_path === 'string' ? toolInput.file_path : '';
-}
-
 /**
  * in-process 진입점 — 디스패처가 ctx를 전달해 직접 호출.
- * @param {{ toolName: string, toolInput: string }} ctx
+ * @param {{ toolName: string, toolInput: string, filePath: string }} ctx
  * @returns {Promise<number>} exit code (0 = allow/no-op, 2 = block)
  */
 export async function run(ctx) {
@@ -108,7 +69,7 @@ export async function run(ctx) {
   const toolName = ctx.toolName;
   if (toolName !== 'Edit' && toolName !== 'Write') return 0;
 
-  const filePath = extractFilePath(ctx.toolInput);
+  const filePath = ctx.filePath;
   if (!filePath) return 0;
 
   const rel = toRelative(filePath);