@su-record/vibe 2.9.12 → 2.9.14

package/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "_comment": "WHY this hook ordering: SessionStart initializes state; PreToolUse runs sentinel-guard BEFORE pre-tool-guard because sentinel blocks dangerous commands while pre-tool-guard does finer-grained checks; UserPromptSubmit interrupt echo MUST precede prompt-dispatcher so cancelled tasks are not resumed; Notification thresholds (80/90/95%) trigger progressively urgent context saves.",
+  "_comment": "Dispatcher pattern — PreToolUse/PostToolUse/Stop는 단일 디스패처가 stdin을 한 번 읽어 순차 실행 (병렬 spawn 폭주 제거, cascade 격리, config.hooks.{name}.enabled 토글 지원). UserPromptSubmit은 VIBE_HOOK_DEPTH 재귀 가드 탑재된 prompt-dispatcher 사용.",
   "permissions": {
     "allow": [],
     "deny": [],
@@ -16,91 +16,55 @@
         ]
       }
     ],
-    "_comment_PreToolUse": "WHY sentinel-guard runs before pre-tool-guard: sentinel blocks catastrophic commands (rm -rf, etc.) early; pre-tool-guard handles project-specific restrictions. Order matters — fail fast on danger.",
     "PreToolUse": [
       {
         "matcher": "Bash",
         "hooks": [
           {
             "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/sentinel-guard.js Bash"
-          },
-          {
-            "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/pre-tool-guard.js Bash"
-          },
-          {
-            "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/command-log.js"
+            "command": "node {{VIBE_PATH}}/hooks/scripts/pre-tool-dispatcher.js Bash"
           }
         ]
       },
       {
-        "matcher": "mcp__github__create_pull_request",
+        "matcher": "Edit",
         "hooks": [
           {
             "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/pr-test-gate.js"
+            "command": "node {{VIBE_PATH}}/hooks/scripts/pre-tool-dispatcher.js Edit"
           }
         ]
       },
       {
-        "matcher": "Edit",
+        "matcher": "Write",
         "hooks": [
           {
             "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/sentinel-guard.js Edit"
-          },
-          {
-            "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/pre-tool-guard.js Edit"
+            "command": "node {{VIBE_PATH}}/hooks/scripts/pre-tool-dispatcher.js Write"
           }
         ]
       },
       {
-        "matcher": "Write",
+        "matcher": "mcp__github__create_pull_request",
         "hooks": [
           {
             "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/sentinel-guard.js Write"
-          },
-          {
-            "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/pre-tool-guard.js Write"
+            "command": "node {{VIBE_PATH}}/hooks/scripts/pr-test-gate.js"
           }
         ]
       }
     ],
-    "_comment_PostToolUse": "WHY ordering: format first (normalize style), then lint/check (catch issues on clean code), then test (verify behavior). This chain ensures review-ready code on every edit.",
     "PostToolUse": [
       {
         "matcher": "Write|Edit",
         "hooks": [
           {
             "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/auto-format.js"
-          },
-          {
-            "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/code-check.js"
-          },
-          {
-            "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/auto-test.js"
-          }
-        ]
-      },
-      {
-        "matcher": "Edit",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/post-edit.js"
+            "command": "node {{VIBE_PATH}}/hooks/scripts/post-edit-dispatcher.js"
           }
         ]
       }
     ],
-    "_comment_UserPromptSubmit": "WHY interrupt echo is first: It injects a cancellation signal into the context BEFORE the dispatcher processes the new prompt, preventing the LLM from resuming cancelled work.",
     "UserPromptSubmit": [
       {
         "hooks": [
@@ -153,19 +117,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/codex-review-gate.js"
-          },
-          {
-            "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/stop-notify.js"
-          },
-          {
-            "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/auto-commit.js"
-          },
-          {
-            "type": "command",
-            "command": "node {{VIBE_PATH}}/hooks/scripts/devlog-gen.js"
+            "command": "node {{VIBE_PATH}}/hooks/scripts/stop-dispatcher.js"
           }
         ]
       }

package/hooks/scripts/__tests__/pre-tool-guard.test.js

@@ -23,13 +23,14 @@ function runGuard({ args = [] } = {}) {
 }
 
 /**
- * Run pre-tool-guard.js with stdin JSON payload (using shell pipe).
+ * Run pre-tool-guard.js with stdin JSON payload.
+ * 스크립트가 fs.readSync(0, ...)로 stdin을 읽으므로 execFileSync input 옵션이 동작.
  */
 function runGuardWithStdin(payload) {
   const json = typeof payload === 'string' ? payload : JSON.stringify(payload);
-  const escaped = json.replace(/'/g, "'\\''");
   try {
-    const stdout = execSync(`echo '${escaped}' | node ${SCRIPT}`, {
+    const stdout = execFileSync('node', [SCRIPT], {
+      input: json,
       encoding: 'utf-8',
       timeout: 5000,
     });

package/hooks/scripts/__tests__/sentinel-guard.test.js

@@ -23,16 +23,14 @@ function runGuard(args = []) {
 }
 
 /**
- * Run sentinel-guard.js with stdin JSON payload (using shell pipe).
- * The script reads stdin via fs.openSync('/dev/stdin'), which requires
- * a real pipe — execFileSync input option does not work.
+ * Run sentinel-guard.js with stdin JSON payload.
+ * 스크립트가 fs.readSync(0, ...)로 stdin을 읽으므로 execFileSync input 옵션이 동작.
  */
 function runGuardWithStdin(payload) {
   const json = typeof payload === 'string' ? payload : JSON.stringify(payload);
-  // Escape single quotes in JSON for shell safety
-  const escaped = json.replace(/'/g, "'\\''");
   try {
-    const stdout = execSync(`echo '${escaped}' | node ${SCRIPT}`, {
+    const stdout = execFileSync('node', [SCRIPT], {
+      input: json,
       encoding: 'utf-8',
       timeout: 5000,
     });
@@ -194,9 +192,9 @@ describe('sentinel-guard', () => {
         tool_name: 'Write',
         tool_input: { file_path: 'src/infra/lib/autonomy/x.ts' },
       });
-      const escaped = payload.replace(/'/g, "'\\''");
       try {
-        execSync(`echo '${escaped}' | node ${SCRIPT} Read '{}'`, {
+        execFileSync('node', [SCRIPT, 'Read', '{}'], {
+          input: payload,
           encoding: 'utf-8',
           timeout: 5000,
         });

package/hooks/scripts/figma-guard.js

@@ -26,10 +26,9 @@ import os from 'os';
 function readStdinSync() {
   try {
     if (process.stdin.isTTY) return null;
-    const fd = fs.openSync('/dev/stdin', 'r');
+    // fd 0을 직접 사용 (Windows는 '/dev/stdin'이 없음)
     const buf = Buffer.alloc(1024 * 1024); // 1MB
-    const bytesRead = fs.readSync(fd, buf, 0, buf.length, null);
-    fs.closeSync(fd);
+    const bytesRead = fs.readSync(0, buf, 0, buf.length, null);
     if (bytesRead > 0) {
       return JSON.parse(buf.toString('utf-8', 0, bytesRead));
     }

package/hooks/scripts/lib/dispatcher.js

@@ -0,0 +1,83 @@
+/**
+ * Hook dispatcher library — 여러 hook script를 단일 이벤트에서 직렬 실행.
+ *
+ * 목적:
+ * - 동일 이벤트에 등록된 N개 스크립트의 **병렬 spawn 폭주**를 순차화
+ * - stdin을 한 번만 읽어 각 자식에 그대로 pipe (중복 파싱/읽기 방지)
+ * - config.hooks[name].enabled 로 개별 토글
+ * - 한 스크립트 실패가 다음 실행을 막지 않도록 cascade 격리
+ * - PreToolUse 계열: 자식이 exit 2(deny)면 즉시 상위에 전파
+ */
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SCRIPTS_DIR = path.resolve(__dirname, '..');
+
+function loadHookConfig() {
+  try {
+    const configPath = path.join(
+      process.env.CLAUDE_PROJECT_DIR || process.cwd(),
+      '.claude', 'vibe', 'config.json'
+    );
+    if (!fs.existsSync(configPath)) return {};
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8')).hooks || {};
+  } catch {
+    return {};
+  }
+}
+
+function isEnabled(hookConfig, name) {
+  const entry = hookConfig[name];
+  if (entry && typeof entry === 'object' && entry.enabled === false) return false;
+  return true;
+}
+
+async function readStdin() {
+  if (process.stdin.isTTY) return '';
+  let data = '';
+  for await (const chunk of process.stdin) data += chunk;
+  return data;
+}
+
+/**
+ * 단일 스크립트 실행. stdin을 통해 입력 전달, stdout은 메인 stdout으로 통과.
+ * @returns {Promise<number>} exit code
+ */
+function runScript(scriptName, args, stdinData, timeoutMs) {
+  return new Promise((resolve) => {
+    const scriptPath = path.join(SCRIPTS_DIR, scriptName);
+    const proc = spawn(process.execPath, [scriptPath, ...args], {
+      stdio: ['pipe', 'inherit', 'inherit'],
+      timeout: timeoutMs,
+    });
+    if (stdinData) proc.stdin.end(stdinData);
+    else proc.stdin.end();
+    proc.on('close', (code) => resolve(code ?? 0));
+    proc.on('error', () => resolve(1));
+  });
+}
+
+/**
+ * 디스패처 실행.
+ * @param {Array<{name: string, script: string, args?: string[], denyOnExit2?: boolean, timeoutMs?: number}>} steps
+ */
+export async function dispatch(steps) {
+  const stdinData = await readStdin();
+  const hookConfig = loadHookConfig();
+
+  for (const step of steps) {
+    if (!isEnabled(hookConfig, step.name)) continue;
+    const code = await runScript(
+      step.script,
+      step.args || [],
+      stdinData,
+      step.timeoutMs || 30000
+    );
+    if (step.denyOnExit2 && code === 2) {
+      process.exit(2);
+    }
+  }
+}

package/hooks/scripts/llm-orchestrate.js

@@ -1,11 +1,11 @@
 /**
- * UserPromptSubmit Hook - LLM 오케스트레이션 (GPT/Gemini)
+ * UserPromptSubmit Hook - LLM 오케스트레이션 (GPT/Gemini/Claude)
  *
  * Usage:
  *   node llm-orchestrate.js <provider> <mode> "prompt"
  *   node llm-orchestrate.js <provider> <mode> "systemPrompt" "prompt"
  *
- *   provider: gpt | gemini
+ *   provider: gpt | gemini | claude
  *   mode: orchestrate | orchestrate-json | image | analyze-image
  *
  * Image Mode:
@@ -13,7 +13,7 @@
  *   node llm-orchestrate.js gemini image "prompt" --output "./image.png" --size "1920x1080"
  *
  * Features:
- *   - CLI-based: GPT → codex exec, Gemini → gemini -p
+ *   - CLI-based: GPT → codex exec, Gemini → gemini -p, Claude → claude --print
  *   - Exponential backoff retry (3 attempts)
  *   - Auto fallback: gpt ↔ gemini
  *   - Overload/rate-limit detection
@@ -103,9 +103,31 @@ function resolveModel(providerName, config) {
   if (providerName === 'gpt-codex') return config.models?.gptCodex || 'gpt-5.3-codex';
   if (providerName === 'gpt') return config.models?.gpt || 'gpt-5.4';
   if (providerName === 'gemini') return config.models?.gemini || 'gemini-3.1-pro-preview';
+  if (providerName === 'claude') return 'claude';
   return providerName;
 }
 
+/**
+ * 주관 LLM 자동 감지 — Claude가 보조로 사용되어야 하는 환경인지 판별
+ *
+ * true인 경우:
+ * - vibe-codex: ANTHROPIC_BASE_URL이 localhost (프록시 모드)
+ * - coco: ~/.coco/ 존재 또는 COCO_HOME 설정
+ * - 명시적: VIBE_SECONDARY_LLM=claude
+ */
+function useClaudeAsSecondary() {
+  // 1. 명시적 환경변수
+  if (process.env.VIBE_SECONDARY_LLM === 'claude') return true;
+  // 2. vibe-codex 프록시 모드
+  const baseUrl = process.env.ANTHROPIC_BASE_URL || '';
+  if (baseUrl.includes('localhost') || baseUrl.includes('127.0.0.1')) return true;
+  // 3. coco 환경
+  if (process.env.COCO_HOME) return true;
+  const cocoDir = path.join(os.homedir(), '.coco');
+  if (fs.existsSync(cocoDir)) return true;
+  return false;
+}
+
 // Errors that should skip retry and go to fallback immediately
 const SKIP_RETRY_PATTERNS = [
   /rate.?limit/i,
@@ -283,6 +305,43 @@ function callGeminiCli(prompt, sysPrompt, jsonMode, model, timeoutMs) {
   });
 }
 
+function callClaudeCli(prompt, sysPrompt, jsonMode, timeoutMs) {
+  const fullPrompt = buildCliPrompt(prompt, sysPrompt, jsonMode);
+  const args = ['--print', '--dangerously-skip-permissions'];
+  const effectiveTimeout = timeoutMs || CLI_TIMEOUT_MS;
+
+  // 재귀 가드 — 자식 Claude 세션의 UserPromptSubmit hook이 또 claude CLI를
+  // spawn하는 포크 폭탄을 차단 (prompt-dispatcher.js가 이 env를 보고 즉시 종료).
+  const currentDepth = parseInt(process.env.VIBE_HOOK_DEPTH || '0', 10);
+  const childEnv = { ...process.env, VIBE_HOOK_DEPTH: String(currentDepth + 1) };
+
+  return new Promise((resolve, reject) => {
+    const proc = spawnCli('claude', args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: effectiveTimeout,
+      env: childEnv,
+    });
+    proc.stdin.end(fullPrompt);
+
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => { stdout += d.toString(); });
+    proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+    proc.on('close', (code) => {
+      if (code === 0 && stdout.trim()) {
+        resolve(stdout.trim());
+      } else {
+        reject(new Error(`claude cli failed (code ${code}): ${(stderr || stdout).slice(0, 500)}`));
+      }
+    });
+
+    proc.on('error', (err) => {
+      reject(new Error(`claude cli spawn error: ${err.message}`));
+    });
+  });
+}
+
 async function callProvider(providerName, prompt, sysPrompt, jsonMode, timeoutMs) {
   const vibeConfig = readVibeConfig();
 
@@ -303,6 +362,10 @@ async function callProvider(providerName, prompt, sysPrompt, jsonMode, timeoutMs
     return await callGeminiCli(prompt, sysPrompt, jsonMode, model, timeoutMs);
   }
 
+  if (providerName === 'claude') {
+    return await callClaudeCli(prompt, sysPrompt, jsonMode, timeoutMs);
+  }
+
   throw new Error(`Unknown provider: ${providerName}`);
 }
 
@@ -526,14 +589,24 @@ async function main() {
   }
 
   // Provider chain: primary → cross fallback
-  // WHY GPT → Gemini (not reverse): GPT is the primary code/reasoning model;
-  // Gemini serves as cross-vendor fallback so a single vendor outage never
-  // blocks the user. When Gemini is primary (e.g. web-search), GPT is fallback.
-  const providerLabels = { gpt: 'GPT', 'gpt-codex': 'GPT Codex', gemini: 'Gemini' };
-  const isGpt = provider === 'gpt' || provider === 'gpt-codex';
-  const providerChain = isGpt
-    ? [provider, 'gemini']
-    : ['gemini', 'gpt'];
+  // 프록시 모드 (주관=GPT): 보조로 Claude CLI 사용
+  // 직접 모드 (주관=Claude): 보조로 GPT/Gemini 사용
+  const providerLabels = { gpt: 'GPT', 'gpt-codex': 'GPT Codex', gemini: 'Gemini', claude: 'Claude' };
+  const isGpt = provider === 'gpt' || provider === 'gpt-codex' || provider === 'gpt-spark';
+  const isClaude = provider === 'claude';
+  const claudeSecondary = useClaudeAsSecondary();
+
+  let providerChain;
+  if (isClaude) {
+    // 명시적 claude 호출
+    providerChain = ['claude', 'gemini'];
+  } else if (isGpt) {
+    // GPT 주관 → claude fallback (vibe-codex/coco), gemini fallback (직접 모드)
+    providerChain = claudeSecondary ? [provider, 'claude'] : [provider, 'gemini'];
+  } else {
+    // gemini 주관 → claude fallback (vibe-codex/coco), gpt fallback (직접 모드)
+    providerChain = claudeSecondary ? ['gemini', 'claude'] : ['gemini', 'gpt'];
+  }
 
   const vibeConfig = readVibeConfig();
 

package/hooks/scripts/post-edit-dispatcher.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse dispatcher — Write/Edit 이후 순차 실행.
+ *
+ * 기존: PostToolUse.Write|Edit 배열에 3개 스크립트가 병렬 spawn (프로세스 피크 3배)
+ *       + PostToolUse.Edit 추가로 post-edit.js 1개 더
+ * 현재: 단일 디스패처에서 순차 실행. config.hooks.{name}.enabled로 개별 토글.
+ *
+ * 실행 순서:
+ *   1. auto-format — 코드 스타일 정규화
+ *   2. code-check — 린트/품질 검사
+ *   3. auto-test — 관련 테스트 실행
+ *   4. post-edit — Edit 전용 후처리 (Write에서는 스크립트 내부에서 스킵)
+ *
+ * 실패 격리: 한 스크립트 실패해도 다음은 계속 진행.
+ */
+import { dispatch } from './lib/dispatcher.js';
+
+await dispatch([
+  { name: 'auto-format', script: 'auto-format.js' },
+  { name: 'code-check',  script: 'code-check.js'  },
+  { name: 'auto-test',   script: 'auto-test.js'   },
+  { name: 'post-edit',   script: 'post-edit.js'   },
+]);

package/hooks/scripts/pre-tool-dispatcher.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/**
+ * PreToolUse dispatcher — Bash/Edit/Write 공용.
+ *
+ * 기존: matcher별로 2~3개 스크립트가 병렬 spawn.
+ *       - Bash: sentinel-guard + pre-tool-guard + command-log
+ *       - Edit: sentinel-guard + pre-tool-guard
+ *       - Write: sentinel-guard + pre-tool-guard
+ * 현재: 단일 디스패처가 tool name을 인자로 받아 순차 실행.
+ *
+ * Deny 시맨틱 보존:
+ *   sentinel-guard / pre-tool-guard가 exit 2(deny)를 반환하면 dispatcher도
+ *   즉시 exit 2로 상위에 전파 → Claude Code가 도구 실행을 차단.
+ *
+ * 사용법: node pre-tool-dispatcher.js <Bash|Edit|Write>
+ */
+import { dispatch } from './lib/dispatcher.js';
+
+const toolName = process.argv[2] || '';
+
+const steps = [
+  { name: 'sentinel-guard', script: 'sentinel-guard.js', args: [toolName], denyOnExit2: true },
+  { name: 'pre-tool-guard', script: 'pre-tool-guard.js', args: [toolName], denyOnExit2: true },
+];
+
+// command-log은 Bash 전용
+if (toolName === 'Bash') {
+  steps.push({ name: 'command-log', script: 'command-log.js' });
+}
+
+await dispatch(steps);

package/hooks/scripts/pre-tool-guard.js

@@ -160,10 +160,9 @@ function formatOutput(toolName, validation) {
 function readStdinSync() {
   try {
     if (process.stdin.isTTY) return null;
-    const fd = fs.openSync('/dev/stdin', 'r');
+    // fd 0을 직접 사용 (Windows는 '/dev/stdin'이 없음)
     const buf = Buffer.alloc(65536);
-    const bytesRead = fs.readSync(fd, buf, 0, buf.length, null);
-    fs.closeSync(fd);
+    const bytesRead = fs.readSync(0, buf, 0, buf.length, null);
     if (bytesRead > 0) {
       return JSON.parse(buf.toString('utf-8', 0, bytesRead));
     }

package/hooks/scripts/prompt-dispatcher.js

@@ -16,6 +16,11 @@ import path from 'path';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
+// 재귀 가드 — 자식 Claude 세션에서 이 hook이 다시 실행되는 것 차단.
+// llm-orchestrate.js의 callClaudeCli가 VIBE_HOOK_DEPTH=1을 주입하므로,
+// 값이 있으면 즉시 종료해 프로세스 폭탄을 막는다.
+if (process.env.VIBE_HOOK_DEPTH) process.exit(0);
+
 // stdin에서 prompt 읽기
 let inputData = '';
 for await (const chunk of process.stdin) {

package/hooks/scripts/sentinel-guard.js

@@ -98,10 +98,9 @@ import fs from 'fs';
 function readStdinSync() {
   try {
     if (process.stdin.isTTY) return null;
-    const fd = fs.openSync('/dev/stdin', 'r');
+    // fd 0을 직접 사용 (Windows는 '/dev/stdin'이 없음)
     const buf = Buffer.alloc(65536);
-    const bytesRead = fs.readSync(fd, buf, 0, buf.length, null);
-    fs.closeSync(fd);
+    const bytesRead = fs.readSync(0, buf, 0, buf.length, null);
     if (bytesRead > 0) {
       return JSON.parse(buf.toString('utf-8', 0, bytesRead));
     }

package/hooks/scripts/stop-dispatcher.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+/**
+ * Stop dispatcher — Claude 응답 종료 시 4개 스크립트 순차 실행.
+ *
+ * 기존: Stop 배열에 4개 병렬 spawn (codex-review-gate + stop-notify + auto-commit + devlog-gen)
+ *       → auto-commit의 git cascade와 겹쳐 프로세스 폭주 유발 가능.
+ * 현재: 단일 디스패처에서 순차 실행.
+ *
+ * 실행 순서:
+ *   1. codex-review-gate — 리뷰 필요 여부 판단 (stdout → Claude 지시 주입)
+ *   2. stop-notify       — 완료 알림
+ *   3. auto-commit       — 변경 자동 커밋 (git hook cascade 주의)
+ *   4. devlog-gen        — 개발 로그 기록
+ *
+ * 재귀 가드 상속: callClaudeCli가 VIBE_HOOK_DEPTH=1 env를 자식에 주입했다면
+ * 이 Stop dispatcher도 건너뛴다 (자식 세션에서 auto-commit 등이 돌 이유 없음).
+ */
+import { dispatch } from './lib/dispatcher.js';
+
+if (process.env.VIBE_HOOK_DEPTH) process.exit(0);
+
+await dispatch([
+  { name: 'codex-review-gate', script: 'codex-review-gate.js' },
+  { name: 'stop-notify',       script: 'stop-notify.js'       },
+  { name: 'auto-commit',       script: 'auto-commit.js'       },
+  { name: 'devlog-gen',        script: 'devlog-gen.js'        },
+]);

package/package.json

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

package/skills/rob-pike/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: rob-pike
+tier: core
+description: "Rob Pike's 5 Rules — block premature optimization. Auto-activates on optimize, slow, performance, cache, parallelize keywords."
+triggers: [optimize, slow, performance, cache, parallelize, bottleneck, speed up, faster, latency, benchmark]
+priority: 90
+---
+
+# Rob Pike's 5 Rules of Programming
+
+## The Rules
+
+1. **You can't tell where a program is going to spend its time.** Bottlenecks occur in surprising places. Don't guess — prove it.
+2. **Measure.** Don't tune for speed until you've measured. Even then, don't unless one part of the code overwhelms the rest.
+3. **Fancy algorithms are slow when n is small, and n is usually small.** Big-O doesn't matter when constants dominate. Use Rule 2 first.
+4. **Fancy algorithms are buggier than simple ones.** Use simple algorithms and simple data structures.
+5. **Data dominates.** Choose the right data structures and the algorithms become self-evident. "Write stupid code that uses smart objects."
+
+## Before Any Optimization
+
+### Step 0: Check for Existing Instrumentation
+
+Before asking "have you measured?", determine whether measurement is even **possible** right now.
+
+**Scan the codebase** for signs of existing instrumentation:
+- Logging: logger imports, log calls, structured logging libraries
+- Profiling: profiler imports, benchmark files, tracing setup
+- Timing: duration measurements, stopwatch patterns, timing decorators
+- APM/Observability: metrics exports, spans, trace contexts
+
+**Then ask the user:**
+
+1. If instrumentation **exists**: "I found logging/profiling in [locations]. Are there specific areas you suspect are slow, or should we look at what the existing measurements tell us?"
+2. If instrumentation is **missing**: "There's no measurement in place. Before optimizing anything — where do you suspect the bottleneck is? Let's add measurement there first, then let the data decide."
+
+### Step 1: Ask the Measurement Questions
+
+Stop and ask these questions in order:
+
+1. **"Have I measured?"** — If no, measure first.
+2. **"Does one part overwhelm the rest?"** — If no single area dominates, nothing worth optimizing.
+3. **"What's n?"** — If n is small (and it usually is), the simple O(n^2) approach likely beats the clever O(n log n) one.
+4. **"Is this a data structure problem?"** — Before changing the algorithm, consider whether a different data structure makes the problem trivial.
+5. **"Is the added complexity worth it?"** — Simple code that is 10% slower is almost always preferable to clever code that is fragile.
+
+## Anti-Patterns to Block
+
+| Impulse | Rule violated | Response |
+|---|---|---|
+| "This loop looks slow, let me optimize it" | Rule 1 | Have you profiled? The bottleneck may be elsewhere entirely. |
+| "Let me add a cache here" | Rule 2 | Measure first. Does this path actually dominate runtime? |
+| "Let me use a B-tree / trie / skip list" | Rule 3 | What's n? If small, a sorted slice + binary search wins. |
+| "Let me implement a custom allocator" | Rule 4 | Start simple. Measure. Only get fancy if data forces you. |
+| "The algorithm is O(n^2), needs fixing" | Rule 3 | What's n? O(n^2) with n=100 is 10us. Measure first. |
+| "Let me parallelize this" | Rule 2 | Is this actually CPU-bound? Measure. Often it's I/O. |
+
+## When Optimization IS Justified
+
+Proceed only when ALL of these are true:
+
+- You have measurement data showing a specific bottleneck
+- That bottleneck dominates overall runtime (not just 5-10% of it)
+- The proposed fix is the simplest change that addresses the measured problem
+- You will re-measure after the change to confirm improvement