@su-record/vibe 2.12.3 → 2.12.5

package/hooks/scripts/__tests__/keyword-detector.test.js

@@ -71,38 +71,71 @@ describe('keyword-detector', () => {
     });
   });
 
-  describe('verify keyword', () => {
-    it('should detect verify keyword', () => {
-      const result = runDetector('verify the implementation is correct');
+  // strict 키워드(일상어): 명령 끝 위치 또는 --flag 에서만 발동.
+  // 일상 영어("please verify", "quick question")의 오탐을 막기 위함.
+  describe('verify keyword (strict)', () => {
+    it('should detect verify at command tail', () => {
+      const result = runDetector('make the implementation correct, verify');
       expect(result.stdout).toContain('[VERIFY MODE]');
       expect(result.stdout).toContain('verification');
     });
+
+    it('should detect --verify flag', () => {
+      const result = runDetector('fix the bug --verify');
+      expect(result.stdout).toContain('[VERIFY MODE]');
+    });
   });
 
-  describe('quick keyword', () => {
-    it('should detect quick keyword', () => {
-      const result = runDetector('quick fix this typo');
+  describe('quick keyword (strict)', () => {
+    it('should detect quick at command tail', () => {
+      const result = runDetector('fix this typo quick');
       expect(result.stdout).toContain('[QUICK MODE]');
       expect(result.stdout).toContain('fast');
     });
+
+    it('should detect --quick flag', () => {
+      const result = runDetector('build the payment API --quick');
+      expect(result.stdout).toContain('[QUICK MODE]');
+    });
   });
 
-  describe('explore keyword', () => {
-    it('should detect explore keyword', () => {
-      const result = runDetector('explore the codebase structure');
+  describe('explore keyword (strict)', () => {
+    it('should detect --explore flag', () => {
+      const result = runDetector('analyze the codebase --explore');
       expect(result.stdout).toContain('[EXPLORE MODE]');
       expect(result.stdout).toContain('exploration');
     });
   });
 
-  describe('plan keyword', () => {
-    it('should detect plan keyword', () => {
-      const result = runDetector('plan the new feature');
+  describe('plan keyword (strict)', () => {
+    it('should detect --plan flag', () => {
+      const result = runDetector('the new feature --plan');
       expect(result.stdout).toContain('[PLAN MODE]');
       expect(result.stdout).toContain('planning');
     });
   });
 
+  // ══════════════════════════════════════════════════
+  // 오탐 방지 회귀 테스트 — 일상어가 명령 중간/시작에 올 때 발동 금지
+  // ══════════════════════════════════════════════════
+  describe('strict keyword false-positive guard', () => {
+    it('should NOT trigger on "quick question on auth"', () => {
+      expect(runDetector('quick question on auth').stdout).toBe('');
+    });
+
+    it('should NOT trigger on "please verify the fix works"', () => {
+      expect(runDetector('please verify the fix works').stdout).toBe('');
+    });
+
+    it('should NOT trigger on "I plan to refactor later"', () => {
+      expect(runDetector('I plan to refactor later').stdout).toBe('');
+    });
+
+    it('should NOT trigger on "let me explore the options first"', () => {
+      expect(runDetector('let me explore the options first').stdout).toBe('');
+    });
+  });
+
   // ══════════════════════════════════════════════════
   // Keyword combinations / synergies
   // ══════════════════════════════════════════════════
@@ -115,15 +148,16 @@ describe('keyword-detector', () => {
     });
 
     it('should detect ralph+verify synergy', () => {
-      const result = runDetector('ralph verify each step carefully');
+      // verify is strict → use --verify flag (ralph stays bare)
+      const result = runDetector('ralph fix each step --verify');
       expect(result.stdout).toContain('[RALPH+VERIFY]');
     });
 
     it('should output both keywords when no synergy key matches sorted order', () => {
       // KEYWORD_SYNERGIES defines 'ultrawork+explore' but processCombinations
       // sorts keywords alphabetically → tries 'explore+ultrawork' which has no match.
-      // So individual outputs are emitted instead.
-      const result = runDetector('ultrawork explore the entire project');
+      // So individual outputs are emitted instead. explore is strict → --explore.
+      const result = runDetector('ultrawork analyze the entire project --explore');
       expect(result.stdout).toContain('[ULTRAWORK MODE]');
       expect(result.stdout).toContain('[EXPLORE MODE]');
       expect(result.stdout).toContain('[FLAGS]');
@@ -190,7 +224,8 @@ describe('keyword-detector', () => {
     });
 
     it('should merge flags from multiple keywords', () => {
-      const result = runDetector('ralph quick finish this');
+      // quick is strict → place at command tail
+      const result = runDetector('ralph finish this quick');
       expect(result.stdout).toContain('[FLAGS]');
       expect(result.stdout).toContain('persistence');
       expect(result.stdout).toContain('fast');

package/hooks/scripts/auto-commit.js

@@ -1,16 +1,23 @@
 /**
  * Stop Hook - 에이전트 응답 완료 시 자동 커밋 + 롤백 체크포인트
  *
- * 변경사항이 있으면 자동으로 git add + commit.
- * 커밋 메시지는 변경 파일 목록 기반으로 생성.
- * feature branch에서만 동작 (main/master 보호).
+ * ⚠️ OPT-IN ONLY (기본 비활성).
+ *   매 턴 자동 커밋은 "사용자가 요청할 때만 커밋한다"는 원칙과 충돌하고,
+ *   `git add -A` 가 스코프 밖 파일(임시/미완성)까지 스테이징하는 부작용이 있다.
+ *   따라서 `.vibe/config.json` 에서 `hooks["auto-commit"].enabled === true`
+ *   로 명시적으로 켰을 때만 동작한다.
  *
- * 체크포인트: 커밋마다 vibe-checkpoint 태그를 생성해
- * 문제 발생 시 `git reset --hard vibe-checkpoint-N` 으로 롤백 가능.
- * 최근 5개만 유지, 오래된 체크포인트는 자동 정리.
+ * 동작 시: 변경사항이 있으면 git add -A + commit (커밋 메시지는 변경 파일 목록 기반),
+ *   feature branch 에서만 (main/master 보호).
+ * 체크포인트: 커밋마다 vibe-checkpoint 태그 생성 → `git reset --hard vibe-checkpoint-N`
+ *   으로 롤백 가능. 최근 5개만 유지.
  */
 import { execSync } from 'child_process';
-import { PROJECT_DIR } from './utils.js';
+import { PROJECT_DIR, readProjectConfig } from './utils.js';
+
+// Opt-in 가드 — 명시적으로 켜지 않았으면 아무것도 하지 않는다.
+const __autoCommitCfg = readProjectConfig();
+if (__autoCommitCfg?.hooks?.['auto-commit']?.enabled !== true) process.exit(0);
 
 const PROTECTED_BRANCHES = ['main', 'master', 'develop', 'production'];
 const MAX_FILES_IN_MSG = 5;
@@ -24,14 +31,6 @@ function getCurrentBranch() {
   }).trim();
 }
 
-function hasChanges() {
-  const status = execSync('git status --porcelain', {
-    cwd: PROJECT_DIR,
-    encoding: 'utf-8',
-  }).trim();
-  return status.length > 0;
-}
-
 function getChangedFiles() {
   const status = execSync('git status --porcelain', {
     cwd: PROJECT_DIR,
@@ -81,9 +80,10 @@ try {
     process.exit(0);
   }
 
-  if (!hasChanges()) process.exit(0);
-
+  // 변경 유무와 파일 목록을 단일 `git status --porcelain` 호출로 처리
   const files = getChangedFiles();
+  if (files.length === 0) process.exit(0);
+
   const msg = buildCommitMessage(files);
 
   execSync('git add -A', { cwd: PROJECT_DIR, stdio: 'ignore' });

package/hooks/scripts/auto-format.js

@@ -19,13 +19,18 @@ function getFilePath() {
   return input.file_path || input.path || '';
 }
 
+// PATH 직접 스캔 — `which` execSync는 매 파일 저장마다 자식 프로세스를 동기
+// spawn하므로, fs.existsSync로 대체하고 프로세스 내 캐싱한다.
+const _binCache = new Map();
 function hasBin(name) {
-  try {
-    execSync(`which ${name}`, { stdio: 'ignore' });
-    return true;
-  } catch {
-    return false;
-  }
+  const cached = _binCache.get(name);
+  if (cached !== undefined) return cached;
+  const candidates = process.platform === 'win32' ? [`${name}.exe`, `${name}.cmd`, name] : [name];
+  const found = (process.env.PATH || '').split(path.delimiter).some(
+    dir => dir && candidates.some(c => existsSync(path.join(dir, c))),
+  );
+  _binCache.set(name, found);
+  return found;
 }
 
 function hasPrettier() {

package/hooks/scripts/code-check.js

@@ -225,35 +225,32 @@ function clearFailure(filePath) {
 }
 
 async function main() {
+  const files = getModifiedFiles();
+  if (files.length === 0) return;
+
   // 1. Code quality check (changed files only — never scan entire project)
   try {
-    const files = getModifiedFiles();
-    if (files.length > 0) {
-      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;
-      // Output P1/P2 only — skip P3 (style)
-      const critical = text.split('\n').filter(l => /\b(error|critical|P1|P2)\b/i.test(l)).slice(0, 3);
-      if (critical.length > 0) {
-        console.log('[CODE CHECK]', critical.join(' | '));
-        trackFailure(files[0], critical);
-      } else {
-        clearFailure(files[0]);
-      }
-      emitSelfHealMessages(files[0]);
+    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;
+    // Output P1/P2 only — skip P3 (style)
+    const critical = text.split('\n').filter(l => /\b(error|critical|P1|P2)\b/i.test(l)).slice(0, 3);
+    if (critical.length > 0) {
+      console.log('[CODE CHECK]', critical.join(' | '));
+      trackFailure(files[0], critical);
+    } else {
+      clearFailure(files[0]);
     }
+    emitSelfHealMessages(files[0]);
   } catch {
     // Silently continue on check failure — never block progress
   }
 
   // 2. 관찰 자동 캡처
   try {
-    const files = getModifiedFiles();
-    if (files.length === 0) return;
-
     const memModule = await import(`${BASE_URL}memory/index.js`);
     const { type, title } = classifyObservation(files);
 

package/hooks/scripts/codex-hook-adapter.js

@@ -37,11 +37,15 @@ function childEnv() {
 
 function runScript(scriptName, args = []) {
   const scriptPath = path.join(__dirname, scriptName);
+  // prompt-dispatcher 는 명시적 외부 LLM 호출(hook 모드 최대 ~50s)을 포함할 수 있어
+  // 그보다 약간 긴 timeout 으로 감싼다. 나머지 경량 스크립트는 30s. (B-2 정합 —
+  // 30s 고정이면 prompt-dispatcher 의 외부 LLM 호출을 다시 hard-kill 한다)
+  const timeout = scriptName.includes('prompt-dispatcher') ? 55000 : 30000;
   return spawnSync(process.execPath, [scriptPath, ...args], {
     input: stdinData || JSON.stringify(payload),
     encoding: 'utf-8',
     env: childEnv(),
-    timeout: 30000,
+    timeout,
   });
 }
 

package/hooks/scripts/keyword-detector.js

@@ -36,6 +36,7 @@ const MAGIC_KEYWORDS = {
     description: 'Planning interview mode',
     flags: ['planning', 'interview'],
     output: '[PLAN MODE] Enter planning interview mode. Gather requirements before implementation.',
+    strict: true, // 일상어 — 명령 끝 위치 또는 --plan 플래그에서만 (오탐 방지)
   },
 
   // Ralph + Plan 조합
@@ -52,6 +53,7 @@ const MAGIC_KEYWORDS = {
     description: 'Strict verification after each step',
     flags: ['verification', 'strict'],
     output: '[VERIFY MODE] Strict verification enabled. Every change must be verified before proceeding.',
+    strict: true, // 일상어 ("please verify the fix" 오탐 방지)
   },
 
   // 탐색 모드
@@ -60,6 +62,7 @@ const MAGIC_KEYWORDS = {
     description: 'Deep codebase exploration',
     flags: ['exploration', 'thorough'],
     output: '[EXPLORE MODE] Deep exploration enabled. Use multiple Explore agents for thorough codebase analysis.',
+    strict: true, // 일상어 ("let me explore the options" 오탐 방지)
   },
 
   // 빠른 모드
@@ -68,6 +71,7 @@ const MAGIC_KEYWORDS = {
     description: 'Fast execution, minimal verification',
     flags: ['fast', 'minimal_verification'],
     output: '[QUICK MODE] Fast execution mode. Minimal verification, single round reviews.',
+    strict: true, // 일상어 ("quick question on auth" 오탐 방지)
   },
 };
 
@@ -96,8 +100,16 @@ function detectKeywords(text) {
   const resolvedKeywords = new Map();
 
   for (const [keyword, config] of Object.entries(MAGIC_KEYWORDS)) {
-    // 키워드 매칭 (단어 경계)
-    const regex = new RegExp(`\\b${keyword}\\b`, 'i');
+    // alias는 본체의 strict 설정을 따른다.
+    const target = config.alias ? MAGIC_KEYWORDS[config.alias] : config;
+    // strict 키워드(일상어: quick/plan/verify/explore)는 단어경계만으로는
+    // "quick question", "please verify" 등에 오탐한다. 따라서
+    //   ① 명령 끝 위치의 독립 토큰 ("... 만들어줘 quick")  또는
+    //   ② 명시 플래그 ("--quick", "-quick", "/quick")
+    // 에서만 매칭한다. 조어(ralph/ultrawork)는 오탐이 거의 없어 단어경계 유지.
+    const regex = target.strict
+      ? new RegExp(`(?:(?:^|\\s)--?${keyword}\\b)|(?:(?:^|\\s)${keyword}\\s*$)`, 'i')
+      : new RegExp(`\\b${keyword}\\b`, 'i');
     if (regex.test(lowerText)) {
       // alias 해결
       const resolved = config.alias ? MAGIC_KEYWORDS[config.alias] : config;

package/hooks/scripts/llm-orchestrate.js

@@ -42,7 +42,9 @@ const mode = process.argv[3] || 'orchestrate';
 // WHY 3 retries: Enough to ride out brief 503/overload blips (typically 1-2
 // consecutive), but not so many that a genuinely down provider delays the
 // fallback chain for minutes.
-const MAX_RETRIES = 3;
+// VIBE_LLM_MAX_RETRIES override: UserPromptSubmit(hook) 모드에서는 1(재시도 없음)로
+// 낮춰 부모 dispatcher timeout 안에 단일 시도로 끝낸다. (B-2: hard-kill/무음실패 방지)
+const MAX_RETRIES = Number(process.env.VIBE_LLM_MAX_RETRIES) || 3;
 // WHY 2000ms initial delay: LLM rate-limit windows are typically 1-5s;
 // starting at 2s with exponential backoff (2s, 4s, 8s) covers most reset intervals.
 const INITIAL_DELAY_MS = 2000;
@@ -203,7 +205,9 @@ function parseAnalyzeImageArgs(args) {
 // CLI Provider Functions
 // ============================================
 
-const CLI_TIMEOUT_MS = 180000;
+// VIBE_LLM_PRIMARY_TIMEOUT_MS override: hook 모드에서는 부모 dispatcher timeout 보다
+// 짧게 잡아(예: 45s) 자식이 스스로 정리하고 의미있는 메시지를 반환하게 한다.
+const CLI_TIMEOUT_MS = Number(process.env.VIBE_LLM_PRIMARY_TIMEOUT_MS) || 180000;
 const CLI_FALLBACK_TIMEOUT_MS = 30000;
 const IS_WINDOWS = os.platform() === 'win32';
 
@@ -599,6 +603,13 @@ async function main() {
     providerChain = claudeSecondary ? ['antigravity', 'claude'] : ['antigravity', 'gpt'];
   }
 
+  // hook(UserPromptSubmit) 모드: 사용자가 `gpt`/`agy` 접두사로 명시적으로 부른 단발
+  // 보조 호출이라 cross-provider fallback 이 불필요하다. primary 1개로 단축해
+  // 부모 dispatcher timeout 안에 단일 시도로 끝낸다. (B-2)
+  if (process.env.VIBE_LLM_HOOK_MODE) {
+    providerChain = [providerChain[0]];
+  }
+
   const vibeConfig = readVibeConfig();
 
   for (let i = 0; i < providerChain.length; i++) {

package/hooks/scripts/prompt-dispatcher.js

@@ -82,39 +82,47 @@ const DISPATCH_RULES = [
     label: 'e2e-echo',
   },
 
-  // 외부 LLM 호출 (GPT/Antigravity) - 패턴 매칭 필수
+  // 외부 LLM 호출 (GPT/Antigravity) — 명시적 provider 접두사 필수.
+  //
+  // 과거에는 "추론해", "코드 리뷰", "디버깅해" 같은 자연어 패턴이 prompt
+  // 어디서든 매칭되어, 평범한 한국어/영어 요청에도 외부 LLM이 동기로 spawn되고
+  // 그 응답이 컨텍스트에 주입되었다(컨텍스트 오염 + 최대 30s 블로킹).
+  // 이제는 prompt가 `gpt`/`agy`/`antigravity` 로 **시작**할 때만 발동한다.
+  // 즉 사용자가 외부 LLM을 콕 집어 부를 때만 동작하고, 일상 요청엔 걸리지 않는다.
+  // (참고: `/vibe.reason` 스킬이 일반 추론을 담당하므로 자연어 자동호출은 불필요)
+  // `s` 플래그(dotAll)로 여러 줄 prompt 의 역할 키워드도 매칭한다.
   {
-    pattern: /아키텍처.*(검토|리뷰|분석)|architecture.*(review|analyz)|설계.*검토|구조.*분석.*해/i,
+    pattern: /^\s*gpt\b.*(아키텍처|architecture|설계|구조)/is,
     script: 'llm-orchestrate.js',
     args: ['gpt', 'orchestrate', 'You are a software architect. Analyze and review the architecture.'],
     label: 'gpt-architecture',
   },
   {
-    pattern: /(UI|UX).*(리뷰|검토|피드백|개선)|사용자.*경험.*검토|디자인.*리뷰|design.*feedback/i,
+    pattern: /^\s*(agy|antigravity)\b.*(ui|ux|디자인|design|사용자.*경험)/is,
     script: 'llm-orchestrate.js',
     args: ['antigravity', 'orchestrate', 'You are a UI/UX expert. Analyze and provide feedback.'],
     label: 'antigravity-uiux',
   },
   {
-    pattern: /디버깅.*해|버그.*찾아|find.*bug|debug.*this.*code/i,
+    pattern: /^\s*gpt\b.*(디버깅|debug|버그|bug)/is,
     script: 'llm-orchestrate.js',
     args: ['gpt', 'orchestrate', 'You are a debugging expert. Find bugs and suggest fixes.'],
     label: 'gpt-debug',
   },
   {
-    pattern: /코드.*정적.*분석|코드.*분석.*해줘|analyze.*code.*quality/i,
+    pattern: /^\s*(agy|antigravity)\b.*(분석|analyz|코드.*품질|code.*quality)/is,
     script: 'llm-orchestrate.js',
     args: ['antigravity', 'orchestrate', 'You are a code analysis expert. Review and analyze the code.'],
     label: 'antigravity-analysis',
   },
   {
-    pattern: /코드.*리뷰|code.*review|PR.*리뷰|리뷰.*해줘.*코드/i,
+    pattern: /^\s*gpt\b.*(리뷰|review)/is,
     script: 'llm-orchestrate.js',
     args: ['gpt', 'orchestrate', 'You are a code review expert. Review the code for best practices, security, and performance.'],
     label: 'gpt-codereview',
   },
   {
-    pattern: /추론.*해|reasoning|복잡.*분석|deep.*analysis/i,
+    pattern: /^\s*gpt\b.*(추론|reasoning|복잡.*분석|deep.*analysis)/is,
     script: 'llm-orchestrate.js',
     args: ['gpt', 'orchestrate', 'You are a reasoning expert. Analyze the problem deeply and provide detailed reasoning.'],
     label: 'gpt-reasoning',
@@ -155,14 +163,29 @@ for (const rule of DISPATCH_RULES) {
   const scriptPath = path.join(__dirname, rule.script);
   const args = rule.args || [];
 
+  // 외부 LLM 호출(llm-orchestrate)은 부모/자식 timeout 을 정합시킨다 (B-2):
+  // 자식은 hook 모드(primary 45s, fallback 없음, retry 없음)로 단일 시도 후 스스로
+  // 정리하고, 부모는 그보다 약간 긴 50s 로 감싸 hard-kill 을 피한다.
+  // 경량 스크립트(keyword-detector 등)는 기존 30s 유지.
+  const isLlm = rule.script === 'llm-orchestrate.js';
+  const execTimeout = isLlm ? 50000 : 30000;
+  const childEnv = isLlm
+    ? { ...process.env, VIBE_LLM_HOOK_MODE: '1', VIBE_LLM_PRIMARY_TIMEOUT_MS: '45000', VIBE_LLM_MAX_RETRIES: '1' }
+    : { ...process.env };
+
   execPromises.push(
     new Promise((resolve) => {
       execFile('node', [scriptPath, ...args], {
-        timeout: 30000,
-        env: { ...process.env },
+        timeout: execTimeout,
+        env: childEnv,
       }, (error, stdout, stderr) => {
         if (stdout?.trim()) {
           process.stdout.write(stdout);
+        } else if (error) {
+          // 무음실패 방지 — 외부 LLM 호출이 timeout 또는 에러로 결과 없이 죽을 때,
+          // 사용자가 원인을 알 수 있도록 한 줄만 노출한다.
+          const reason = error.killed ? `timed out (${execTimeout / 1000}s)` : (error.message || 'failed');
+          process.stdout.write(`[${rule.label}] external LLM call ${reason} — no result injected.\n`);
         }
         resolve();
       });

package/hooks/scripts/session-start.js

@@ -1,12 +1,11 @@
 /**
  * SessionStart Hook - 세션 시작 시 메모리/시간 로드 + 버전 체크
  */
-import { getToolsBaseUrl, PROJECT_DIR, projectVibePath, projectVibeRoot } from './utils.js';
+import { getToolsBaseUrl, getGlobalNpmPath, PROJECT_DIR, projectVibePath, projectVibeRoot } from './utils.js';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import https from 'https';
-import { execSync } from 'child_process';
 
 const BASE_URL = getToolsBaseUrl();
 
@@ -33,6 +32,30 @@ function fetchLatestVersion() {
   });
 }
 
+// 버전 체크 결과 24시간 파일 캐시 — 매 SessionStart마다 npm registry에
+// HTTP 요청(타임아웃 시 3초 블로킹)을 보내지 않도록 한다. 릴리즈 주기 대비
+// 하루 1회 확인이면 충분하다.
+const VERSION_CACHE_PATH = path.join(os.homedir(), '.vibe', 'version-check.json');
+const VERSION_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+
+async function getLatestVersionCached() {
+  try {
+    const cached = JSON.parse(fs.readFileSync(VERSION_CACHE_PATH, 'utf8'));
+    if (cached.version && Date.now() - cached.checkedAt < VERSION_CACHE_TTL_MS) {
+      return cached.version;
+    }
+  } catch { /* 캐시 없음/손상 → 네트워크 조회 */ }
+
+  const version = await fetchLatestVersion();
+  if (version) {
+    try {
+      fs.mkdirSync(path.dirname(VERSION_CACHE_PATH), { recursive: true });
+      fs.writeFileSync(VERSION_CACHE_PATH, JSON.stringify({ version, checkedAt: Date.now() }));
+    } catch { /* 캐시 기록 실패는 무시 */ }
+  }
+  return version;
+}
+
 function compareVersions(a, b) {
   const partsA = a.replace(/^v/, '').split('.').map(Number);
   const partsB = b.replace(/^v/, '').split('.').map(Number);
@@ -47,18 +70,8 @@ function compareVersions(a, b) {
 
 function getCurrentVersion() {
   try {
-    let globalNpmPath;
-    try {
-      globalNpmPath = execSync('npm root -g', { encoding: 'utf8', timeout: 3000 }).trim();
-    } catch {
-      const homeDir = os.homedir();
-      const fallbacks = [
-        '/usr/local/lib/node_modules',
-        path.join(homeDir, '.npm-global', 'lib', 'node_modules'),
-      ];
-      globalNpmPath = fallbacks.find(p => fs.existsSync(p)) || fallbacks[0];
-    }
-    const pkgPath = path.join(globalNpmPath, '@su-record', 'vibe', 'package.json');
+    // getToolsBaseUrl()이 이미 `npm root -g` 결과를 캐싱하므로 재사용 — 중복 spawn 제거
+    const pkgPath = path.join(getGlobalNpmPath(), '@su-record', 'vibe', 'package.json');
     if (fs.existsSync(pkgPath)) {
       return JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version || null;
     }
@@ -77,7 +90,7 @@ async function main() {
       memoryModule.startSession({ projectPath: PROJECT_DIR }),
       timeModule.getCurrentTime({ format: 'human', timezone: 'Asia/Seoul' }),
       memoryModule.listMemories({ limit: 5, projectPath: PROJECT_DIR }),
-      fetchLatestVersion(),
+      getLatestVersionCached(),
     ]);
 
     console.log(session.content[0].text);

package/hooks/scripts/utils.js

@@ -75,32 +75,44 @@ export function projectMemoryDir(projectDir = PROJECT_DIR) {
   return path.join(projectDir, '.vibe', 'memories');
 }
 
+// config 캐시 — 훅 스크립트는 단명 프로세스이므로 프로세스 생명주기 내에서
+// config 파일이 바뀌지 않는다고 가정한다 (llm-orchestrate처럼 한 프로세스에서
+// 3회 이상 읽는 경로의 중복 read+parse 제거).
+let _vibeConfigCache = null;
+let _projectConfigCache = null;
+
 /**
- * ~/.vibe/config.json 읽기
+ * ~/.vibe/config.json 읽기 (프로세스 내 캐시)
  * @returns {object} 파싱된 config 또는 빈 객체
  */
 export function readVibeConfig() {
+  if (_vibeConfigCache !== null) return _vibeConfigCache;
   const configPath = path.join(VIBE_HOME_DIR, 'config.json');
   try {
     if (fs.existsSync(configPath)) {
-      return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      _vibeConfigCache = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      return _vibeConfigCache;
     }
   } catch { /* ignore */ }
-  return {};
+  _vibeConfigCache = {};
+  return _vibeConfigCache;
 }
 
 /**
- * 프로젝트 설정(.vibe/config.json) 읽기 — legacy `.claude/vibe/` fallback 포함
+ * 프로젝트 설정(.vibe/config.json) 읽기 — legacy `.claude/vibe/` fallback 포함 (프로세스 내 캐시)
  * @returns {object} 파싱된 config 또는 빈 객체
  */
 export function readProjectConfig() {
+  if (_projectConfigCache !== null) return _projectConfigCache;
   const configPath = projectVibePath(PROJECT_DIR, 'config.json');
   try {
     if (fs.existsSync(configPath)) {
-      return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      _projectConfigCache = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      return _projectConfigCache;
     }
   } catch { /* ignore */ }
-  return {};
+  _projectConfigCache = {};
+  return _projectConfigCache;
 }
 
 /**
@@ -153,7 +165,7 @@ function toFileUrl(fsPath) {
 
 // 전역 npm 경로 캐시
 let _globalNpmPath = null;
-function getGlobalNpmPath() {
+export function getGlobalNpmPath() {
   if (_globalNpmPath === null) {
     try {
       _globalNpmPath = execSync('npm root -g', { encoding: 'utf8' }).trim();
@@ -190,20 +202,32 @@ function hasRuntimeDeps(packageRoot) {
  * 패키지 하위 경로의 file:// URL 반환 (크로스 플랫폼)
  * 우선순위: 로컬 빌드 → ~/.vibe/ → 전역 npm
  * 각 후보는 probeFile 존재 + 런타임 deps 해석 가능해야 채택 (dist-only 복사본 회피)
+ *
+ * 프로세스 내 메모이제이션: getToolsBaseUrl/getLibBaseUrl/getCliBaseUrl이 한 훅
+ * 프로세스에서 각각 호출되면 최악 6회 동기 stat이 반복되므로 결과를 캐싱한다.
  */
+const _packageUrlCache = new Map();
 function getPackageUrl(subpath, probeFile) {
+  const cacheKey = `${subpath}|${probeFile}`;
+  const cached = _packageUrlCache.get(cacheKey);
+  if (cached) return cached;
+
   const localRoot = VIBE_PATH;
   const vibeRoot = path.join(VIBE_HOME_DIR, 'node_modules', '@su-record', 'vibe');
   const globalRoot = path.join(getGlobalNpmPath(), '@su-record', 'vibe');
 
   const candidates = [localRoot, vibeRoot, globalRoot];
+  let result = null;
   for (const root of candidates) {
     const target = path.join(root, subpath);
     if (fs.existsSync(path.join(target, probeFile)) && hasRuntimeDeps(root)) {
-      return toFileUrl(target);
+      result = toFileUrl(target);
+      break;
     }
   }
-  return toFileUrl(path.join(globalRoot, subpath));
+  if (result === null) result = toFileUrl(path.join(globalRoot, subpath));
+  _packageUrlCache.set(cacheKey, result);
+  return result;
 }
 
 export function getToolsBaseUrl() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@su-record/vibe",
-  "version": "2.12.3",
+  "version": "2.12.5",
   "description": "AI Coding Framework for Claude Code — 56 agents, 45 skills, multi-LLM orchestration",
   "type": "module",
   "main": "dist/cli/index.js",

package/skills/arch-guard/SKILL.md

@@ -3,8 +3,8 @@ 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]
+description: "Generate import-rule tests that mechanically enforce architecture layer constraints (e.g., 'UI must not import DB') — for new modules, layer refactors, or circular dependencies."
+triggers: [arch guard, architecture test, layer test, boundary test, structural test, arch validation, layer enforcement, dependency rules, architectural boundaries, circular dependency]
 priority: 60
 ---
 

package/skills/characterization-test/SKILL.md

@@ -3,8 +3,8 @@ 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]
+description: "Lock existing behavior with characterization tests BEFORE refactoring or modifying legacy/untested code (files >200 lines without tests)."
+triggers: [legacy, characterization test, lock behavior, regression prevention, before refactor, large file, refactor, rewrite, modernize, clean up]
 priority: 65
 ---