@su-record/vibe 2.9.21 → 2.9.23

package/hooks/scripts/keyword-detector.js

@@ -1,214 +1,214 @@
-#!/usr/bin/env node
-/**
- * Keyword Detector & Combiner
- * 매직 키워드 감지 및 조합 처리
- */
-
-import { VIBE_PATH, PROJECT_DIR } from './utils.js';
-
-// 매직 키워드 정의
-const MAGIC_KEYWORDS = {
-  // 지속성 모드 (완료까지 계속)
-  ralph: {
-    name: 'Ralph Loop',
-    description: 'Continue until task is verified complete',
-    flags: ['persistence', 'verification'],
-    output: '[RALPH MODE] Self-referential completion loop activated. Will continue until ALL tasks verified complete. NO early stopping.',
-  },
-
-  // 울트라워크 모드 (병렬 + 자동 계속)
-  ultrawork: {
-    name: 'Ultrawork',
-    description: 'Maximum parallel execution, no pause',
-    flags: ['parallel', 'auto_continue', 'no_confirmation'],
-    output: '[ULTRAWORK MODE] Use PARALLEL Task calls. Auto-continue through ALL phases. Auto-retry on errors up to 3 times. Do NOT ask for confirmation between phases.',
-  },
-  ulw: {
-    alias: 'ultrawork',
-  },
-  울트라워크: {
-    alias: 'ultrawork',
-  },
-
-  // 계획 모드
-  plan: {
-    name: 'Plan Mode',
-    description: 'Planning interview mode',
-    flags: ['planning', 'interview'],
-    output: '[PLAN MODE] Enter planning interview mode. Gather requirements before implementation.',
-  },
-
-  // Ralph + Plan 조합
-  ralplan: {
-    name: 'Ralph Plan',
-    description: 'Iterative planning with persistence',
-    flags: ['persistence', 'planning', 'iteration'],
-    output: '[RALPLAN MODE] Iterative planning with consensus. Will refine plan until approved, then execute with Ralph persistence.',
-  },
-
-  // 검증 모드
-  verify: {
-    name: 'Verify Mode',
-    description: 'Strict verification after each step',
-    flags: ['verification', 'strict'],
-    output: '[VERIFY MODE] Strict verification enabled. Every change must be verified before proceeding.',
-  },
-
-  // 탐색 모드
-  explore: {
-    name: 'Explore Mode',
-    description: 'Deep codebase exploration',
-    flags: ['exploration', 'thorough'],
-    output: '[EXPLORE MODE] Deep exploration enabled. Use multiple Explore agents for thorough codebase analysis.',
-  },
-
-  // 빠른 모드
-  quick: {
-    name: 'Quick Mode',
-    description: 'Fast execution, minimal verification',
-    flags: ['fast', 'minimal_verification'],
-    output: '[QUICK MODE] Fast execution mode. Minimal verification, single round reviews.',
-  },
-};
-
-// 키워드 조합 시너지
-const KEYWORD_SYNERGIES = {
-  'ralph+ultrawork': {
-    name: 'Ralph Ultrawork',
-    output: '[RALPH+ULTRAWORK] Maximum persistence AND parallel execution. Will NOT stop until ALL phases complete with verification.',
-  },
-  'ralph+verify': {
-    name: 'Ralph Verify',
-    output: '[RALPH+VERIFY] Persistent completion with strict verification at each step.',
-  },
-  'ultrawork+explore': {
-    name: 'Ultrawork Explore',
-    output: '[ULTRAWORK+EXPLORE] Parallel exploration agents for maximum coverage.',
-  },
-};
-
-/**
- * 텍스트에서 키워드 추출
- */
-function detectKeywords(text) {
-  const lowerText = text.toLowerCase();
-  const detected = [];
-  const resolvedKeywords = new Map();
-
-  for (const [keyword, config] of Object.entries(MAGIC_KEYWORDS)) {
-    // 키워드 매칭 (단어 경계)
-    const regex = new RegExp(`\\b${keyword}\\b`, 'i');
-    if (regex.test(lowerText)) {
-      // alias 해결
-      const resolved = config.alias ? MAGIC_KEYWORDS[config.alias] : config;
-      const resolvedName = config.alias || keyword;
-
-      if (!resolvedKeywords.has(resolvedName)) {
-        resolvedKeywords.set(resolvedName, resolved);
-        detected.push({
-          keyword: resolvedName,
-          original: keyword,
-          ...resolved,
-        });
-      }
-    }
-  }
-
-  return detected;
-}
-
-/**
- * 키워드 조합 처리
- */
-function processCombinations(detected) {
-  if (detected.length <= 1) {
-    return null;
-  }
-
-  // 키워드 이름 정렬하여 조합 키 생성
-  const keywordNames = detected.map(d => d.keyword).sort();
-
-  // 모든 2-조합 확인
-  for (let i = 0; i < keywordNames.length; i++) {
-    for (let j = i + 1; j < keywordNames.length; j++) {
-      const comboKey = `${keywordNames[i]}+${keywordNames[j]}`;
-      if (KEYWORD_SYNERGIES[comboKey]) {
-        return KEYWORD_SYNERGIES[comboKey];
-      }
-    }
-  }
-
-  return null;
-}
-
-/**
- * 모든 플래그 수집
- */
-function collectFlags(detected) {
-  const flags = new Set();
-  for (const d of detected) {
-    if (d.flags) {
-      d.flags.forEach(f => flags.add(f));
-    }
-  }
-  return Array.from(flags);
-}
-
-/**
- * 출력 생성
- */
-function generateOutput(detected, combination) {
-  const outputs = [];
-
-  // 시너지 조합 우선
-  if (combination) {
-    outputs.push(combination.output);
-  } else {
-    // 개별 키워드 출력
-    for (const d of detected) {
-      if (d.output) {
-        outputs.push(d.output);
-      }
-    }
-  }
-
-  // 모든 플래그 수집
-  const flags = collectFlags(detected);
-  if (flags.length > 0) {
-    outputs.push(`[FLAGS] ${flags.join(', ')}`);
-  }
-
-  return outputs.join('\n');
-}
-
-// 메인 실행
-const input = process.argv.slice(2).join(' ') || process.env.USER_PROMPT || '';
-
-if (!input) {
-  console.log(`
-VIBE Keyword Detector
-
-Available magic keywords:
-${Object.entries(MAGIC_KEYWORDS)
-  .filter(([_, v]) => !v.alias)
-  .map(([k, v]) => `  ${k.padEnd(12)} - ${v.description}`)
-  .join('\n')}
-
-Keyword combinations:
-${Object.entries(KEYWORD_SYNERGIES)
-  .map(([k, v]) => `  ${k.padEnd(20)} - ${v.name}`)
-  .join('\n')}
-
-Usage:
-  node keyword-detector.js "implement login ralph ultrawork"
-  `);
-  process.exit(0);
-}
-
-const detected = detectKeywords(input);
-
-if (detected.length > 0) {
-  const combination = processCombinations(detected);
-  const output = generateOutput(detected, combination);
-  console.log(output);
-}
+#!/usr/bin/env node
+/**
+ * Keyword Detector & Combiner
+ * 매직 키워드 감지 및 조합 처리
+ */
+
+import { VIBE_PATH, PROJECT_DIR } from './utils.js';
+
+// 매직 키워드 정의
+const MAGIC_KEYWORDS = {
+  // 지속성 모드 (완료까지 계속)
+  ralph: {
+    name: 'Ralph Loop',
+    description: 'Continue until task is verified complete',
+    flags: ['persistence', 'verification'],
+    output: '[RALPH MODE] Self-referential completion loop activated. Will continue until ALL tasks verified complete. NO early stopping.',
+  },
+
+  // 울트라워크 모드 (병렬 + 자동 계속)
+  ultrawork: {
+    name: 'Ultrawork',
+    description: 'Maximum parallel execution, no pause',
+    flags: ['parallel', 'auto_continue', 'no_confirmation'],
+    output: '[ULTRAWORK MODE] Use PARALLEL Task calls. Auto-continue through ALL phases. Auto-retry on errors up to 3 times. Do NOT ask for confirmation between phases.',
+  },
+  ulw: {
+    alias: 'ultrawork',
+  },
+  울트라워크: {
+    alias: 'ultrawork',
+  },
+
+  // 계획 모드
+  plan: {
+    name: 'Plan Mode',
+    description: 'Planning interview mode',
+    flags: ['planning', 'interview'],
+    output: '[PLAN MODE] Enter planning interview mode. Gather requirements before implementation.',
+  },
+
+  // Ralph + Plan 조합
+  ralplan: {
+    name: 'Ralph Plan',
+    description: 'Iterative planning with persistence',
+    flags: ['persistence', 'planning', 'iteration'],
+    output: '[RALPLAN MODE] Iterative planning with consensus. Will refine plan until approved, then execute with Ralph persistence.',
+  },
+
+  // 검증 모드
+  verify: {
+    name: 'Verify Mode',
+    description: 'Strict verification after each step',
+    flags: ['verification', 'strict'],
+    output: '[VERIFY MODE] Strict verification enabled. Every change must be verified before proceeding.',
+  },
+
+  // 탐색 모드
+  explore: {
+    name: 'Explore Mode',
+    description: 'Deep codebase exploration',
+    flags: ['exploration', 'thorough'],
+    output: '[EXPLORE MODE] Deep exploration enabled. Use multiple Explore agents for thorough codebase analysis.',
+  },
+
+  // 빠른 모드
+  quick: {
+    name: 'Quick Mode',
+    description: 'Fast execution, minimal verification',
+    flags: ['fast', 'minimal_verification'],
+    output: '[QUICK MODE] Fast execution mode. Minimal verification, single round reviews.',
+  },
+};
+
+// 키워드 조합 시너지
+const KEYWORD_SYNERGIES = {
+  'ralph+ultrawork': {
+    name: 'Ralph Ultrawork',
+    output: '[RALPH+ULTRAWORK] Maximum persistence AND parallel execution. Will NOT stop until ALL phases complete with verification.',
+  },
+  'ralph+verify': {
+    name: 'Ralph Verify',
+    output: '[RALPH+VERIFY] Persistent completion with strict verification at each step.',
+  },
+  'ultrawork+explore': {
+    name: 'Ultrawork Explore',
+    output: '[ULTRAWORK+EXPLORE] Parallel exploration agents for maximum coverage.',
+  },
+};
+
+/**
+ * 텍스트에서 키워드 추출
+ */
+function detectKeywords(text) {
+  const lowerText = text.toLowerCase();
+  const detected = [];
+  const resolvedKeywords = new Map();
+
+  for (const [keyword, config] of Object.entries(MAGIC_KEYWORDS)) {
+    // 키워드 매칭 (단어 경계)
+    const regex = new RegExp(`\\b${keyword}\\b`, 'i');
+    if (regex.test(lowerText)) {
+      // alias 해결
+      const resolved = config.alias ? MAGIC_KEYWORDS[config.alias] : config;
+      const resolvedName = config.alias || keyword;
+
+      if (!resolvedKeywords.has(resolvedName)) {
+        resolvedKeywords.set(resolvedName, resolved);
+        detected.push({
+          keyword: resolvedName,
+          original: keyword,
+          ...resolved,
+        });
+      }
+    }
+  }
+
+  return detected;
+}
+
+/**
+ * 키워드 조합 처리
+ */
+function processCombinations(detected) {
+  if (detected.length <= 1) {
+    return null;
+  }
+
+  // 키워드 이름 정렬하여 조합 키 생성
+  const keywordNames = detected.map(d => d.keyword).sort();
+
+  // 모든 2-조합 확인
+  for (let i = 0; i < keywordNames.length; i++) {
+    for (let j = i + 1; j < keywordNames.length; j++) {
+      const comboKey = `${keywordNames[i]}+${keywordNames[j]}`;
+      if (KEYWORD_SYNERGIES[comboKey]) {
+        return KEYWORD_SYNERGIES[comboKey];
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * 모든 플래그 수집
+ */
+function collectFlags(detected) {
+  const flags = new Set();
+  for (const d of detected) {
+    if (d.flags) {
+      d.flags.forEach(f => flags.add(f));
+    }
+  }
+  return Array.from(flags);
+}
+
+/**
+ * 출력 생성
+ */
+function generateOutput(detected, combination) {
+  const outputs = [];
+
+  // 시너지 조합 우선
+  if (combination) {
+    outputs.push(combination.output);
+  } else {
+    // 개별 키워드 출력
+    for (const d of detected) {
+      if (d.output) {
+        outputs.push(d.output);
+      }
+    }
+  }
+
+  // 모든 플래그 수집
+  const flags = collectFlags(detected);
+  if (flags.length > 0) {
+    outputs.push(`[FLAGS] ${flags.join(', ')}`);
+  }
+
+  return outputs.join('\n');
+}
+
+// 메인 실행
+const input = process.argv.slice(2).join(' ') || process.env.USER_PROMPT || '';
+
+if (!input) {
+  console.log(`
+VIBE Keyword Detector
+
+Available magic keywords:
+${Object.entries(MAGIC_KEYWORDS)
+  .filter(([_, v]) => !v.alias)
+  .map(([k, v]) => `  ${k.padEnd(12)} - ${v.description}`)
+  .join('\n')}
+
+Keyword combinations:
+${Object.entries(KEYWORD_SYNERGIES)
+  .map(([k, v]) => `  ${k.padEnd(20)} - ${v.name}`)
+  .join('\n')}
+
+Usage:
+  node keyword-detector.js "implement login ralph ultrawork"
+  `);
+  process.exit(0);
+}
+
+const detected = detectKeywords(input);
+
+if (detected.length > 0) {
+  const combination = processCombinations(detected);
+  const output = generateOutput(detected, combination);
+  console.log(output);
+}

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

@@ -0,0 +1,261 @@
+/**
+ * Scope synthesizer — derive allow-glob patterns from active SPECs.
+ *
+ * 활성 SPEC(`.claude/vibe/specs/*.md` with frontmatter status ∈ pending|in-progress|active)을
+ * 스캔해 백틱으로 감싼 파일 경로를 수집 → `<dir>/**` glob으로 변환한다.
+ *
+ * 수동 편집된 scope.json은 건드리지 않는다 — `auto: true` 플래그가 있는 파일만 덮어쓴다.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+const ACTIVE_STATUSES = new Set(['pending', 'in-progress', 'in_progress', 'active', 'running']);
+
+// 항상 허용: SPEC/plan/TODO 등 메타 문서는 구현 중에도 갱신 가능해야 함
+const DEFAULT_ALLOW = ['.claude/vibe/**', 'CLAUDE.md', 'AGENTS.md'];
+
+function readFrontmatter(content) {
+  if (!content.startsWith('---')) return {};
+  const end = content.indexOf('\n---', 3);
+  if (end < 0) return {};
+  const block = content.slice(3, end);
+  const out = {};
+  for (const line of block.split('\n')) {
+    const m = line.match(/^([a-zA-Z_][\w-]*)\s*:\s*(.*)$/);
+    if (m) out[m[1]] = m[2].trim();
+  }
+  return out;
+}
+
+/**
+ * 본문에서 백틱으로 감싼 파일 경로 후보 추출.
+ *  - 확장자 있는 경로 (foo.ts, hooks/scripts/bar.js)
+ *  - 슬래시 포함 상대경로 (src/cli/commands)
+ *  - 절대경로(/etc/...) 및 URL(http://...) 제외
+ */
+// 허용 파일명 확장자 (실제 소스/자산). SPEC에 적힌 임의 토큰을 걸러낸다.
+const ALLOWED_EXTS = new Set([
+  'ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs', 'json', 'md', 'mdx',
+  'css', 'scss', 'sass', 'less', 'html', 'yaml', 'yml', 'toml',
+  'py', 'rs', 'go', 'java', 'kt', 'rb', 'php', 'swift', 'c', 'cpp', 'h', 'hpp',
+  'sh', 'bash', 'sql', 'env', 'feature', 'txt', 'svg', 'png', 'jpg', 'webp',
+]);
+
+function extractPaths(markdown) {
+  const paths = new Set();
+  const backtickRe = /`([^`\n]+)`/g;
+  let m;
+  while ((m = backtickRe.exec(markdown)) !== null) {
+    const raw = m[1].trim();
+    if (!raw || raw.length > 200) continue;
+    if (raw.startsWith('/') || raw.startsWith('~')) continue; // 시스템/홈
+    if (raw.startsWith('http') || raw.includes('://')) continue;
+    if (/[\s{}[\]()<>`'"=,;|&$?!*@#%^+]/.test(raw)) continue; // 코드/템플릿/속성 접근자
+
+    const hasSlash = raw.includes('/');
+    const extMatch = raw.match(/\.([a-zA-Z0-9]{1,6})$/);
+    const ext = extMatch ? extMatch[1].toLowerCase() : null;
+
+    // 확장자 있으면 화이트리스트 체크, 없으면 디렉토리로 간주 (슬래시 필수)
+    if (ext) {
+      if (!ALLOWED_EXTS.has(ext)) continue;
+    } else {
+      if (!hasSlash) continue;
+    }
+
+    // 명백한 비경로 제외
+    if (/^[A-Z_]+$/.test(raw)) continue; // 상수
+    if (/^\d+$/.test(raw)) continue; // 숫자
+    if (raw.startsWith('.') && !raw.startsWith('./') && !raw.startsWith('.claude')) continue;
+
+    const normalized = raw.replace(/^\.\//, '').replace(/\\/g, '/');
+    // 각 세그먼트 안전성 재검증 — "a.b.c" 같은 필드 경로 제거
+    const segments = normalized.split('/');
+    const lastSeg = segments[segments.length - 1];
+    // 파일명에 점이 2개 이상이면 보통 필드 경로 (except .test.ts, .d.ts 같은 허용 패턴)
+    const dotCount = (lastSeg.match(/\./g) || []).length;
+    if (dotCount > 2) continue;
+    if (dotCount === 2 && !/\.(test|spec|d|config|module|stories)\.[a-z]+$/i.test(lastSeg)) continue;
+
+    paths.add(normalized);
+  }
+  return [...paths];
+}
+
+/**
+ * 경로 목록 → glob 패턴 집합.
+ *  - 확장자 있는 파일: dirname을 `<dir>/**`로
+ *  - 디렉토리(확장자 없음, 슬래시 포함): `<path>/**`
+ *  - 최상위 파일은 그대로 포함
+ */
+function pathsToGlobs(paths) {
+  const globs = new Set();
+  for (const p of paths) {
+    const hasExt = /\.[a-zA-Z0-9]{1,6}$/.test(p);
+    if (hasExt) {
+      const dir = path.posix.dirname(p);
+      if (dir && dir !== '.') globs.add(`${dir}/**`);
+      else globs.add(p);
+    } else {
+      const trimmed = p.replace(/\/+$/, '');
+      globs.add(`${trimmed}/**`);
+    }
+  }
+  return collapseDominated([...globs]);
+}
+
+/**
+ * `a/**`가 `a/b/**`를 포함하면 후자 제거.
+ */
+function collapseDominated(globs) {
+  const sorted = [...new Set(globs)].sort((a, b) => a.length - b.length);
+  const kept = [];
+  for (const g of sorted) {
+    const base = g.replace(/\/\*\*$/, '');
+    const dominated = kept.some(k => {
+      const kb = k.replace(/\/\*\*$/, '');
+      return g !== k && g.endsWith('/**') && k.endsWith('/**') && (base === kb || base.startsWith(kb + '/'));
+    });
+    if (!dominated) kept.push(g);
+  }
+  return kept;
+}
+
+/**
+ * 프로젝트의 활성 SPEC 목록 수집.
+ */
+export function findActiveSpecs(projectDir) {
+  const specsDir = path.join(projectDir, '.claude', 'vibe', 'specs');
+  if (!fs.existsSync(specsDir)) return [];
+  const results = [];
+  const walk = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.isFile() && entry.name.endsWith('.md')) results.push(full);
+    }
+  };
+  walk(specsDir);
+  return results.filter(f => {
+    try {
+      const content = fs.readFileSync(f, 'utf-8');
+      const fm = readFrontmatter(content);
+      const status = (fm.status || '').toLowerCase();
+      if (!fm.status) return true; // status 없으면 활성 간주
+      return ACTIVE_STATUSES.has(status);
+    } catch { return false; }
+  });
+}
+
+/**
+ * SPEC 파일 목록 → scope.json 객체.
+ */
+export function synthesizeScope(specFiles, { projectDir } = {}) {
+  const allPaths = new Set();
+  const sourceNames = [];
+  for (const f of specFiles) {
+    try {
+      const content = fs.readFileSync(f, 'utf-8');
+      for (const p of extractPaths(content)) allPaths.add(p);
+      sourceNames.push(path.relative(projectDir || '.', f).replace(/\\/g, '/'));
+    } catch { /* ignore */ }
+  }
+  const derived = pathsToGlobs([...allPaths]);
+  // 파일시스템 검증: 디렉토리 glob은 실제 존재할 때만 포함. 파일은 파일명만
+  // 있을 수 있으므로 (중첩 경로의 basename), 확장자 있으면 통과.
+  const verified = projectDir
+    ? derived.filter(g => {
+      if (!g.endsWith('/**')) return true; // 파일은 유지
+      const base = g.replace(/\/\*\*$/, '');
+      try { return fs.existsSync(path.join(projectDir, base)); }
+      catch { return false; }
+    })
+    : derived;
+  const allow = collapseDominated([...DEFAULT_ALLOW, ...verified]);
+  return {
+    auto: true,
+    mode: 'warn',
+    allow,
+    deny: [],
+    reason: sourceNames.length > 0
+      ? `auto-derived from active SPECs: ${sourceNames.join(', ')}`
+      : 'auto-derived (no active SPECs found)',
+    generatedAt: new Date().toISOString(),
+    sources: sourceNames,
+  };
+}
+
+/**
+ * scope.json을 활성 SPEC 기반으로 동기화.
+ *  - 파일 없음 → 생성 (활성 SPEC이 있을 때만)
+ *  - 파일 있음 + `auto: true` → 갱신
+ *  - 파일 있음 + `auto` 없거나 false → 수동 관리 중, 건드리지 않음
+ *
+ * @returns {{ action: 'created'|'updated'|'skipped-manual'|'skipped-no-specs'|'unchanged', path: string }}
+ */
+export function syncScopeFile(projectDir) {
+  const scopePath = path.join(projectDir, '.claude', 'vibe', 'scope.json');
+  const specs = findActiveSpecs(projectDir);
+
+  // 기존 파일이 수동 관리면 스킵
+  if (fs.existsSync(scopePath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(scopePath, 'utf-8'));
+      if (existing.auto !== true) {
+        return { action: 'skipped-manual', path: scopePath };
+      }
+    } catch { /* 파싱 실패 → 자동 생성 덮어쓰기 */ }
+  }
+
+  if (specs.length === 0) {
+    // 자동 파일만 있고 활성 SPEC 없음 → 제거
+    if (fs.existsSync(scopePath)) {
+      try {
+        const existing = JSON.parse(fs.readFileSync(scopePath, 'utf-8'));
+        if (existing.auto === true) {
+          fs.unlinkSync(scopePath);
+          return { action: 'removed', path: scopePath };
+        }
+      } catch { /* ignore */ }
+    }
+    return { action: 'skipped-no-specs', path: scopePath };
+  }
+
+  const next = synthesizeScope(specs, { projectDir });
+  const nextStr = JSON.stringify(next, null, 2);
+
+  // 변경 없음 체크 (generatedAt 제외)
+  if (fs.existsSync(scopePath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(scopePath, 'utf-8'));
+      const { generatedAt: _a, ...exRest } = existing;
+      const { generatedAt: _b, ...nextRest } = next;
+      if (JSON.stringify(exRest) === JSON.stringify(nextRest)) {
+        return { action: 'unchanged', path: scopePath };
+      }
+    } catch { /* ignore */ }
+  }
+
+  const existed = fs.existsSync(scopePath);
+  fs.mkdirSync(path.dirname(scopePath), { recursive: true });
+  fs.writeFileSync(scopePath, nextStr + '\n', 'utf-8');
+  return { action: existed ? 'updated' : 'created', path: scopePath };
+}
+
+// CLI 엔트리: `node hooks/scripts/lib/scope-from-spec.js [projectDir]`
+// init/update나 스크립트에서 자동 동기화 용도로 직접 호출 가능.
+import { fileURLToPath } from 'url';
+if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
+  const dir = process.argv[2] || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const result = syncScopeFile(dir);
+  const label = {
+    created: '✓ scope.json created',
+    updated: '✓ scope.json updated',
+    unchanged: '· scope.json unchanged',
+    removed: '✓ scope.json removed (no active SPECs)',
+    'skipped-manual': '· scope.json is manually managed (auto=false)',
+    'skipped-no-specs': '· no active SPECs — scope.json not generated',
+  }[result.action] || result.action;
+  console.log(`[scope-sync] ${label}`);
+}