@su-record/vibe 3.2.64 → 4.0.1

package/hooks/scripts/clone-validate.js

@@ -1,286 +0,0 @@
-#!/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);
-
-// ─── 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);
-}
-
-// 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

@@ -1,354 +0,0 @@
-/**
- * PostToolUse Hook - Write/Edit 후 코드 품질 검사 + 관찰 자동 캡처
- *
- * findings를 console.log가 아닌 반환값으로 전달 — 디스패처가 수집해 additionalContext에 주입.
- *
- * 범위 (harness-review-2026-07-01 P1-4):
- * 오탐률이 낮은 결정론적 하드룰(any/@ts-ignore, console.log)만 탐지한다.
- * 함수 길이·중첩 깊이·매직 넘버 같은 휴리스틱은 모델이 컨텍스트 안에서 더
- * 정확히 판단하므로 주입하지 않으며, 정규식 발견은 커밋 게이트
- * (run-ledger verifyRequired)를 태우지 않는다 — 그 게이트는 결정론적
- * 검증 흐름(vibe.verify) 전용이다.
- */
-import { getToolsBaseUrl, PROJECT_DIR } from './utils.js';
-import { readFileSync } from 'fs';
-import { buildCliCtx, isDirectRun } from './lib/hook-context.js';
-import { CODE_EXT_RE, shouldCheckConsole } from './lib/console-allow.js';
-import { isEphemeralPath } from './lib/ephemeral-lane.js';
-
-const BASE_URL = getToolsBaseUrl();
-
-// P1 이슈 판단 기준: .ts/.tsx 파일에서만 적용
-const P1_DETECTORS = [
-  // `: any` — 타입 어노테이션
-  /:\s*any\b/,
-  // `as any` — 타입 캐스트
-  /\bas\s+any\b/,
-  // `<any>` — 제네릭 any (단, JSX 태그 제외 목적으로 뒤에 공백/쉼표/> 허용)
-  /<any[\s,>]/,
-  // @ts-ignore
-  /@ts-ignore\b/,
-];
-
-const TS_EXT_RE = /\.(ts|tsx)$/;
-
-/**
- * hook ctx에서 수정된 파일 경로 추출.
- * @param {object} ctx
- * @returns {string[]}
- */
-function getModifiedFiles(ctx) {
-  return ctx.filePath ? [ctx.filePath] : [];
-}
-
-/**
- * 파일 확장자/경로로 관찰 타입 분류
- * @param {string[]} files
- * @returns {{ type: string, title: string }}
- */
-function classifyObservation(files) {
-  const hasTest = files.some(f => /\.(test|spec)\.[jt]sx?$/.test(f) || /\/__tests__\//.test(f));
-  const hasConfig = files.some(f => /\.(json|ya?ml|toml|env|config)/.test(f));
-
-  if (hasTest) return { type: 'feature', title: 'Test file updated' };
-  if (hasConfig) return { type: 'refactor', title: 'Configuration updated' };
-  return { type: 'feature', title: 'Code modified' };
-}
-
-/**
- * 백슬래시로 이스케이프되지 않은 첫 token 위치. 없으면 -1.
- * 템플릿 리터럴 안의 \` 를 종료 백틱으로 오인하지 않기 위해 필요하다.
- * @param {string} str
- * @param {string} token
- * @returns {number}
- */
-function findUnescaped(str, token) {
-  for (let i = 0; i < str.length; i++) {
-    if (str[i] === '\\') { i++; continue; }
-    if (str.startsWith(token, i)) return i;
-  }
-  return -1;
-}
-
-/** 정규식 리터럴이 시작될 수 있는 위치인지 — 직전 코드로 나눗셈과 구분한다 */
-function canStartRegex(codeSoFar) {
-  const prev = codeSoFar.replace(/\s+$/, '');
-  if (prev === '') return true;
-  if (/\b(return|typeof|case|in|of|new|delete|void|throw)$/.test(prev)) return true;
-  return /[=(,:[!&|?{};+\-*%~^<>]$/.test(prev);
-}
-
-/** 템플릿 리터럴 안에서 종료 백틱과 `${` 중 먼저 오는 것을 찾는다 */
-function nextTemplateStop(rest) {
-  for (let i = 0; i < rest.length; i++) {
-    if (rest[i] === '\\') { i++; continue; }
-    if (rest[i] === '`') return { kind: 'end', index: i };
-    if (rest[i] === '$' && rest[i + 1] === '{') return { kind: 'expr', index: i };
-  }
-  return null;
-}
-
-/**
- * 템플릿 리터럴 본문을 소비한다. `${` 를 만나면 **코드 구간**으로 넘긴다 —
- * 보간 안은 문자열이 아니라 실행되는 코드다 (`` `${x as any}` `` 를 놓치던 원인).
- */
-function consumeTemplate(rest, state) {
-  const stop = nextTemplateStop(rest);
-  if (!stop) return null; // 줄 끝까지 템플릿 — 다음 줄로 상태를 이어간다
-  if (stop.kind === 'end') {
-    state.stack.pop();
-    return rest.slice(stop.index + 1);
-  }
-  // depth 는 보간 안에서 열린 `{` 수 — 0 일 때의 `}` 만 보간을 닫는다
-  state.stack.push({ kind: 'expr', depth: 0 });
-  return rest.slice(stop.index + 2);
-}
-
-/**
- * 한 줄에서 코드가 아닌 구간(주석·문자열·템플릿 리터럴)을 지운다.
- *
- * 상태는 스택이다 — 템플릿 안의 `${}` 안에 또 템플릿이 올 수 있다.
- * 여러 줄에 걸친 블록 주석·템플릿 리터럴은 스택으로 이어진다.
- *
- * @param {string} line
- * @param {{ stack: Array<'block'|'template'|'expr'> }} state - 제자리 갱신
- * @returns {string} 코드 구간만 남은 문자열
- */
-function stripNonCodeLine(line, state) {
-  let rest = line;
-  let code = '';
-
-  while (rest.length > 0) {
-    const frame = state.stack[state.stack.length - 1];
-    const top = typeof frame === 'object' ? frame.kind : frame;
-
-    if (top === 'block') {
-      const end = findUnescaped(rest, '*/');
-      if (end === -1) break;
-      state.stack.pop();
-      rest = rest.slice(end + 2);
-      continue;
-    }
-    if (top === 'template') {
-      const next = consumeTemplate(rest, state);
-      if (next === null) break;
-      rest = next;
-      continue;
-    }
-
-    // 코드 구간 (최상위 또는 `${}` 안)
-    const opener = rest.match(/\/\*|\/\/|`|'|"|\/|\{|\}/);
-    if (!opener) return code + rest;
-    code += rest.slice(0, opener.index);
-    const token = opener[0];
-    const consumed = rest.slice(opener.index + token.length);
-
-    if (token === '//') break;
-    if (token === '{') {
-      if (top === 'expr') frame.depth++;
-      code += '{';
-      rest = consumed;
-      continue;
-    }
-    if (token === '}') {
-      // 보간 안에서 열린 `{` 가 남아 있으면 그걸 닫는 것이지 보간의 끝이 아니다
-      // (`${ {a:1}.x as any }` 를 조기 종료하던 원인)
-      if (top === 'expr' && frame.depth === 0) state.stack.pop();
-      else if (top === 'expr') { frame.depth--; code += '}'; }
-      else code += '}';
-      rest = consumed;
-      continue;
-    }
-    if (token === '/*') { state.stack.push('block'); rest = consumed; continue; }
-    if (token === '`') { state.stack.push('template'); rest = consumed; continue; }
-    if (token === '/') {
-      // 정규식 리터럴이면 통째로 건너뛴다 — 안의 백틱/따옴표가 상태를 오염시킨다
-      if (canStartRegex(code)) {
-        const end = findUnescaped(consumed, '/');
-        rest = end === -1 ? '' : consumed.slice(end + 1);
-      } else {
-        code += '/';
-        rest = consumed;
-      }
-      continue;
-    }
-    const close = findUnescaped(consumed, token); // 홑/겹따옴표는 줄을 넘지 않는다
-    rest = close === -1 ? '' : consumed.slice(close + 1);
-  }
-  return code;
-}
-
-/**
- * P1: any 타입 탐지 — .ts/.tsx 전용, 단어 경계 기반.
- *
- * 주석·문자열·템플릿 리터럴은 제외한다: `any` 를 **금지하는** 문서 문장이
- * 그 자체로 P1 이 되면, 고칠 수도 없는 경고가 그 파일을 편집할 때마다
- * 주입돼 게이트 신뢰도가 떨어진다 (detectConsoleLogs의 확장자 게이트와 같은 이유).
- *
- * @param {string[]} lines
- * @returns {Array<{ line: number, match: string, severity: 'P1' }>}
- */
-function detectAnyType(lines) {
-  const findings = [];
-  const state = { stack: [] };
-  lines.forEach((line, i) => {
-    const code = stripNonCodeLine(line, state);
-    for (const re of P1_DETECTORS) {
-      if (re.test(code)) {
-        findings.push({
-          line: i + 1,
-          match: line.trim(),
-          severity: 'P1',
-          suggestion: "Replace with: unknown + type guard pattern: if (typeof x === 'string') { ... }",
-        });
-        break; // 한 줄에 여러 패턴이 있어도 중복 발견 방지
-      }
-    }
-  });
-  return findings;
-}
-
-/**
- * P1: console.log 탐지 — 허용 경로가 아닌 곳의 src/ 코드.
- *
- * 두 겹의 게이트를 쓴다:
- *  1. 확장자 — 마크다운·JSON·텍스트에 인용된 `console.log(` 는 커밋되면 안 되는
- *     디버그 코드가 아니라 문서상의 예시다. 이게 없으면 SKILL.md 안의 스니펫이
- *     매 편집마다 P1 으로 주입된다.
- *  2. 코드 구간 — 코드 파일 **안에서도** JSDoc 예시와 사용자에게 출력할 마크다운
- *     템플릿 리터럴에 `console.log(` 가 등장한다. 원본 라인을 그대로 검사하면
- *     그것들이 전부 P1 이 되어, 고칠 수 없는 경고가 반복되고 게이트 신뢰도가
- *     떨어진다 — detectAnyType 이 stripNonCodeLine 을 쓰는 것과 같은 이유다.
- *     (2026-07-28 감사: 실측 9건 중 7건이 이 오탐이었다)
- *
- * @param {string[]} lines
- * @param {string} filePath
- * @returns {Array<{ line: number, match: string, severity: 'P1' }>}
- */
-function detectConsoleLogs(lines, filePath) {
-  if (!shouldCheckConsole(filePath)) return [];
-  const findings = [];
-  const state = { stack: [] };
-  lines.forEach((line, i) => {
-    const code = stripNonCodeLine(line, state);
-    if (/console\.log\(/.test(code)) {
-      findings.push({
-        line: i + 1,
-        match: line.trim(),
-        severity: 'P1',
-        suggestion: 'Remove or replace with debugLog utility',
-      });
-    }
-  });
-  return findings;
-}
-
-/**
- * 하드룰 탐지기 실행. findings 배열 반환.
- * @param {string} filePath
- * @returns {{ p1: string[] }}
- */
-function runDetectors(filePath) {
-  let content;
-  try {
-    content = readFileSync(filePath, 'utf-8');
-  } catch {
-    return { p1: [] };
-  }
-
-  const lines = content.split('\n');
-  const isTs = TS_EXT_RE.test(filePath);
-
-  const p1Findings = [];
-
-  // P1: any 탐지 — TS 파일만
-  if (isTs) {
-    const anyHits = detectAnyType(lines).slice(0, 2);
-    for (const f of anyHits) {
-      p1Findings.push(`P1 any-type line ${f.line}: ${f.match.substring(0, 60)}`);
-    }
-  }
-
-  // P1: console.log — 허용 경로 제외
-  const consoleHits = detectConsoleLogs(lines, filePath).slice(0, 2);
-  for (const f of consoleHits) {
-    p1Findings.push(`P1 console.log line ${f.line}: ${f.match.substring(0, 60)}`);
-  }
-
-  return { p1: p1Findings };
-}
-
-/**
- * in-process 진입점 — 품질 검사 + 관찰 캡처.
- * findings 배열을 반환한다 (디스패처가 수집해 additionalContext에 주입).
- * @param {{ filePath: string }} ctx
- * @returns {Promise<{ exitCode: number, findings: string[] }>}
- */
-export async function run(ctx) {
-  const findings = [];
-  const files = getModifiedFiles(ctx);
-  if (files.length === 0) return { exitCode: 0, findings };
-
-  // 일회성 레인 — 생성·실행 후 폐기되는 코드에 durable 코드의 무게를 지우지 않는다.
-  // 판정은 **경로가** 한다 (모델이 아니라) — `lib/ephemeral-lane.js` 참조.
-  // 이 면제가 안전한 이유는 그 경로가 커밋될 수 없기 때문이다: gitignore 가 1차,
-  // pre-tool-guard 가 `git add -f` 를 막는 심층 방어다.
-  if (isEphemeralPath(files[0], PROJECT_DIR)) return { exitCode: 0, findings };
-
-  // 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);
-  } catch {
-    // 탐지기 실패 → 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`);
-    const result = await module.validateCodeQuality({
-      targetPath: files[0],
-      projectPath: PROJECT_DIR,
-    });
-    const text = result.content[0].text;
-    const critical = text.split('\n').filter(l => /\b(error|critical|P1|P2)\b/i.test(l)).slice(0, 3);
-    for (const line of critical) findings.push(`[CODE CHECK] ${line}`);
-  } catch {
-    // Silently continue on check failure
-  }
-
-  // 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 };
-}
-
-// standalone CLI 모드 (직접 실행 시 — 디스패처 없이)
-if (isDirectRun(import.meta.url)) {
-  process.on('uncaughtException', () => {});
-  process.on('unhandledRejection', () => {});
-  const { exitCode, findings } = await run(buildCliCtx());
-  if (findings.length > 0) process.stdout.write(findings.join('\n') + '\n');
-  process.exit(exitCode);
-}

package/hooks/scripts/codex-detect.js

@@ -1,46 +0,0 @@
-#!/usr/bin/env node
-/**
- * Codex 플러그인 감지 유틸
- *
- * 워크플로우 스킬(.md)에서 Bash로 호출하여 Codex 사용 가능 여부 확인.
- *
- * 사용법 (스킬 마크다운에서):
- *   node {{VIBE_PATH}}/hooks/scripts/codex-detect.js
- *
- * 출력:
- *   "available" — Codex CLI 설치 + auth 존재
- *   "unavailable" — 미설치 또는 미인증
- *
- * 종료 코드:
- *   0 — available
- *   1 — unavailable
- */
-
-import fs from 'fs';
-import path from 'path';
-import { execSync } from 'child_process';
-import os from 'os';
-
-const codexDir = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
-
-// CLI 설치 확인
-let cliInstalled = fs.existsSync(codexDir);
-if (!cliInstalled) {
-  try {
-    execSync('which codex', { stdio: 'ignore' });
-    cliInstalled = true;
-  } catch {
-    // not found
-  }
-}
-
-// 인증 확인
-const authExists = fs.existsSync(path.join(codexDir, 'auth.json'));
-
-if (cliInstalled && authExists) {
-  console.log('available');
-  process.exit(0);
-} else {
-  console.log('unavailable');
-  process.exit(1);
-}