@su-record/vibe 2.9.1 → 2.9.3

package/hooks/scripts/figma-validate.js

@@ -0,0 +1,353 @@
+#!/usr/bin/env node
+
+/**
+ * figma-validate.js — SCSS vs sections.json 대조 검증
+ *
+ * Usage:
+ *   node figma-validate.js <scss-dir> <sections.json> [--section=<name>]
+ *
+ * 검증 항목:
+ *   1. SCSS의 모든 CSS 속성이 sections.json에 근거하는가
+ *   2. sections.json의 CSS 속성이 SCSS에 누락되지 않았는가
+ *   3. 금지 패턴 감지 (커스텀 함수, aspect-ratio 등)
+ *   4. 이미지 파일명 kebab-case 확인
+ *
+ * 출력: JSON { status, errors[], summary }
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+function camelToKebab(str) {
+  return str.replace(/([A-Z])/g, '-$1').toLowerCase();
+}
+
+function parseSCSS(scssContent) {
+  // 간이 SCSS 파서: 셀렉터 → CSS 속성 맵 추출
+  const blocks = {};
+  let currentSelector = null;
+  const lines = scssContent.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // 빈 줄, 코멘트 스킵
+    if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('/*')) continue;
+
+    // 셀렉터 열기
+    const selectorMatch = trimmed.match(/^([.&][a-zA-Z0-9_-][a-zA-Z0-9_-]*(?:__[a-zA-Z0-9_-]+(?:-[a-zA-Z0-9_-]+)*)?)\s*\{/);
+    if (selectorMatch) {
+      currentSelector = selectorMatch[1];
+      if (!blocks[currentSelector]) blocks[currentSelector] = {};
+      continue;
+    }
+
+    // 블록 닫기
+    if (trimmed === '}') {
+      currentSelector = null;
+      continue;
+    }
+
+    // CSS 속성
+    if (currentSelector && trimmed.includes(':') && trimmed.endsWith(';')) {
+      const colonIdx = trimmed.indexOf(':');
+      const prop = trimmed.slice(0, colonIdx).trim();
+      const value = trimmed.slice(colonIdx + 1).replace(/;$/, '').trim();
+      blocks[currentSelector][prop] = value;
+    }
+  }
+
+  return blocks;
+}
+
+// ─── Forbidden Pattern Detection ────────────────────────────────────
+
+const FORBIDDEN_PATTERNS = [
+  { pattern: /@function\s/, id: 'custom-function', msg: '@function 자체 정의 금지' },
+  { pattern: /@mixin\s/, id: 'custom-mixin', msg: '@mixin 자체 정의 금지 (기존 @use만 허용)' },
+  { pattern: /aspect-ratio\s*:/, id: 'aspect-ratio', msg: 'aspect-ratio는 tree.json에 없는 속성' },
+  { pattern: /clamp\s*\(/, id: 'clamp', msg: 'clamp()는 font-size 외 사용 금지' },
+  { pattern: /\d+vw/, id: 'vw-unit', msg: 'vw 단위 사용 금지 (스태틱 구현)' },
+  { pattern: /@media\s/, id: 'media-query', msg: '@media 금지 (스태틱 구현)' },
+  { pattern: /@include\s/, id: 'include', msg: '@include 사용 시 기존 프로젝트 믹스인만 허용' },
+];
+
+function detectForbidden(scssContent, filePath) {
+  const errors = [];
+  const lines = scssContent.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const { pattern, id, msg } of FORBIDDEN_PATTERNS) {
+      if (pattern.test(line)) {
+        // clamp in font-size is allowed
+        if (id === 'clamp' && line.includes('font-size')) continue;
+        errors.push({
+          priority: 'P1',
+          file: filePath,
+          line: i + 1,
+          type: `forbidden-${id}`,
+          actual: line.trim(),
+          message: msg
+        });
+      }
+    }
+  }
+
+  return errors;
+}
+
+// ─── CSS Value Comparison ───────────────────────────────────────────
+
+function collectCSSFromTree(node, sectionClass, parentPath, result) {
+  const css = node.css || {};
+  const children = node.children || [];
+  const name = node.name || '';
+  const type = node.type || '';
+
+  // BG 프레임 스킵
+  const nameLower = name.toLowerCase();
+  if (nameLower === 'bg' || nameLower.endsWith('-bg') || nameLower.startsWith('bg-')) return;
+
+  // 클래스명 재현 (figma-to-scss.js와 동일 로직)
+  let cls = name
+    .replace(/[^a-zA-Z0-9\s_-]/g, '')
+    .replace(/[\s_]+/g, '-')
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .toLowerCase()
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '') || null;
+
+  if (!cls) {
+    const idx = parentPath ? parentPath.split('-').length : 0;
+    if (type === 'TEXT') cls = `text-${idx}`;
+    else if (type === 'VECTOR') cls = `vector-${idx}`;
+    else if (type === 'RECTANGLE') cls = `rect-${idx}`;
+    else cls = `el-${idx}`;
+  }
+
+  const currentPath = parentPath ? `${parentPath}-${cls}` : cls;
+  const selector = `.${sectionClass}__${currentPath}`;
+
+  // CSS 속성 저장 (kebab 변환)
+  if (Object.keys(css).length > 0) {
+    const kebabCSS = {};
+    for (const [prop, value] of Object.entries(css)) {
+      if (prop.startsWith('_')) continue;
+      kebabCSS[camelToKebab(prop)] = String(value);
+    }
+    result[selector] = kebabCSS;
+  }
+
+  // 자식 재귀
+  const seenClasses = new Set();
+  for (const child of children) {
+    const childName = child.name || '';
+    const childLower = childName.toLowerCase();
+    if (childLower === 'bg' || childLower.endsWith('-bg') || childLower.startsWith('bg-')) continue;
+
+    let childCls = childName
+      .replace(/[^a-zA-Z0-9\s_-]/g, '')
+      .replace(/[\s_]+/g, '-')
+      .replace(/([a-z])([A-Z])/g, '$1-$2')
+      .toLowerCase()
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '') || null;
+    if (!childCls) childCls = `${child.type?.toLowerCase() || 'el'}-0`;
+
+    if (seenClasses.has(childCls)) continue;
+    seenClasses.add(childCls);
+    collectCSSFromTree(child, sectionClass, currentPath, result);
+  }
+}
+
+function compareCSSValues(scssBlocks, treeCSS, filePath) {
+  const errors = [];
+
+  // SCSS에 있지만 tree에 없는 속성 (임의 추가)
+  for (const [selector, props] of Object.entries(scssBlocks)) {
+    if (!selector.startsWith('.')) continue;
+    const treeProps = treeCSS[selector];
+
+    for (const [prop, value] of Object.entries(props)) {
+      // background-image url, background-size 등은 이미지 처리에서 추가됨
+      if (prop === 'background-image' || prop === 'background-size' ||
+          prop === 'background-position' || prop === 'background-repeat') continue;
+      // imageRef 주석 스킵
+      if (prop.startsWith('//')) continue;
+
+      if (!treeProps || !(prop in treeProps)) {
+        errors.push({
+          priority: 'P2',
+          file: filePath,
+          type: 'extra-property',
+          selector,
+          property: prop,
+          actual: value,
+          message: `SCSS에 있지만 sections.json에 없는 속성: ${prop}: ${value}`
+        });
+      } else if (treeProps[prop] !== value) {
+        errors.push({
+          priority: 'P1',
+          file: filePath,
+          type: 'value-mismatch',
+          selector,
+          property: prop,
+          expected: treeProps[prop],
+          actual: value,
+          message: `값 불일치: ${prop} expected="${treeProps[prop]}" actual="${value}"`
+        });
+      }
+    }
+  }
+
+  // tree에 있지만 SCSS에 없는 속성 (누락)
+  for (const [selector, props] of Object.entries(treeCSS)) {
+    const scssProps = scssBlocks[selector];
+    if (!scssProps) {
+      errors.push({
+        priority: 'P1',
+        file: filePath,
+        type: 'missing-selector',
+        selector,
+        message: `sections.json에 있지만 SCSS에 없는 셀렉터: ${selector}`
+      });
+      continue;
+    }
+    for (const [prop] of Object.entries(props)) {
+      if (!(prop in scssProps)) {
+        errors.push({
+          priority: 'P1',
+          file: filePath,
+          type: 'missing-property',
+          selector,
+          property: prop,
+          expected: props[prop],
+          message: `SCSS에 누락된 속성: ${selector} { ${prop}: ${props[prop]} }`
+        });
+      }
+    }
+  }
+
+  return errors;
+}
+
+// ─── Image Filename Check ───────────────────────────────────────────
+
+function checkImageFilenames(scssContent, filePath) {
+  const errors = [];
+  const urlRegex = /url\(['"]?([^'")\s]+)['"]?\)/g;
+  let match;
+
+  while ((match = urlRegex.exec(scssContent)) !== null) {
+    const imgPath = match[1];
+    const filename = path.basename(imgPath, path.extname(imgPath));
+
+    // 해시 파일명 감지 (16자 이상 hex)
+    if (/^[0-9a-f]{16,}$/.test(filename)) {
+      errors.push({
+        priority: 'P1',
+        file: filePath,
+        type: 'hash-filename',
+        actual: imgPath,
+        message: `해시 파일명 금지: ${imgPath} → kebab-case로 변경 필요`
+      });
+    }
+  }
+
+  return errors;
+}
+
+// ─── Main ───────────────────────────────────────────────────────────
+
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length < 2) {
+    console.error('Usage: node figma-validate.js <scss-dir> <sections.json> [--section=<name>]');
+    process.exit(1);
+  }
+
+  const scssDir = args[0];
+  const sectionsFile = args[1];
+  let sectionFilter = '';
+
+  for (const arg of args.slice(2)) {
+    if (arg.startsWith('--section=')) sectionFilter = arg.slice(10);
+  }
+
+  // 입력 읽기
+  const data = JSON.parse(fs.readFileSync(sectionsFile, 'utf-8'));
+  let sections = data.sections || [];
+
+  if (sectionFilter) {
+    sections = sections.filter(s => s.name === sectionFilter);
+  }
+
+  const allErrors = [];
+
+  for (const section of sections) {
+    const sectionClass = section.name
+      .replace(/[^a-zA-Z0-9\s_-]/g, '')
+      .replace(/[\s_]+/g, '-')
+      .replace(/([a-z])([A-Z])/g, '$1-$2')
+      .toLowerCase()
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '');
+
+    const scssFile = path.join(scssDir, `_${sectionClass}.scss`);
+    if (!fs.existsSync(scssFile)) {
+      allErrors.push({
+        priority: 'P1',
+        type: 'missing-file',
+        expected: scssFile,
+        message: `SCSS 파일 없음: ${scssFile}`
+      });
+      continue;
+    }
+
+    const scssContent = fs.readFileSync(scssFile, 'utf-8');
+
+    // 1. 금지 패턴 검사
+    allErrors.push(...detectForbidden(scssContent, scssFile));
+
+    // 2. 이미지 파일명 검사
+    allErrors.push(...checkImageFilenames(scssContent, scssFile));
+
+    // 3. CSS 값 대조
+    const scssBlocks = parseSCSS(scssContent);
+    const treeCSS = {};
+
+    // 루트 섹션 CSS
+    const rootSelector = `.${sectionClass}`;
+    if (section.css && Object.keys(section.css).length > 0) {
+      treeCSS[rootSelector] = {};
+      for (const [prop, value] of Object.entries(section.css)) {
+        if (!prop.startsWith('_')) treeCSS[rootSelector][camelToKebab(prop)] = String(value);
+      }
+    }
+
+    // 자식 CSS 재귀 수집
+    for (const child of (section.children || [])) {
+      collectCSSFromTree(child, sectionClass, '', treeCSS);
+    }
+
+    allErrors.push(...compareCSSValues(scssBlocks, treeCSS, scssFile));
+  }
+
+  // 결과 출력
+  const p1 = allErrors.filter(e => e.priority === 'P1').length;
+  const p2 = allErrors.filter(e => e.priority === 'P2').length;
+
+  const result = {
+    status: p1 === 0 ? 'PASS' : 'FAIL',
+    errors: allErrors,
+    summary: { p1, p2, total: allErrors.length }
+  };
+
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(p1 > 0 ? 1 : 0);
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@su-record/vibe",
-  "version": "2.9.1",
+  "version": "2.9.3",
   "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

@@ -178,4 +178,4 @@ The test generator reads this file and adds custom rules to the test suite.
 - `vibe init` → auto-detect and generate initial arch-guard tests
 - `vibe update` → refresh rules if directory structure changed
 - Pre-commit hook → run arch-guard tests before commit
-- `/vibe.review` → architecture-reviewer checks against arch-rules.json
+- `vibe.review` (skill) → architecture-reviewer checks against arch-rules.json

package/skills/capability-loop/SKILL.md

@@ -107,6 +107,92 @@ Based on classification, build the appropriate artifact:
 4. If the capability is a test, verify it FAILS without the fix
 ```
 
+**Termination branches:**
+- ✅ **Capability prevents the failure** → Step 5 PERSIST
+- ❌ **Capability does NOT prevent the failure** → Step 4.5 ESCALATE (re-diagnose or ask user)
+
+### Step 4.5: ESCALATE — When VERIFY Fails
+
+> **Problem**: The built capability didn't actually prevent the failure. This usually means the initial diagnosis was wrong (picked `Tool` when it needed `Guardrail`), or the failure has multiple missing capabilities.
+>
+> **Do NOT silently proceed** — a sub-standard capability log pollutes `.claude/vibe/capabilities-log.md` and the failure will recur.
+
+**Escalation loop:**
+
+```python
+tried = [current_diagnosis.category]  # e.g., ["Tool"]
+
+while True:
+    # Re-diagnose excluding already-tried categories
+    next_diagnosis = diagnose(failure, exclude=tried)
+
+    if next_diagnosis is None:
+        # All 5 categories (Tool/Guardrail/Abstraction/Documentation/Feedback) exhausted
+        escalate_to_user(failure, tried)
+        break
+
+    if next_diagnosis.category in tried:
+        # Stuck: diagnose keeps returning the same category
+        escalate_to_user(failure, tried)
+        break
+
+    tried.append(next_diagnosis.category)
+    capability = build(next_diagnosis)
+
+    if verify(capability, failure):
+        persist(capability)
+        return  # Success — go to Step 5
+
+    # Still failing — next iteration
+```
+
+**User escalation prompt (interactive mode):**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+⚠️ CAPABILITY LOOP STUCK
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Failure: {original failure description}
+
+Tried capabilities (all failed to prevent the failure):
+  ❌ Tool: {what was built, why it didn't work}
+  ❌ Guardrail: {what was built, why it didn't work}
+  ❌ Documentation: {what was built, why it didn't work}
+
+Automated diagnosis has run out of angles. This failure may require
+human judgment (process issue, cross-category solution, or external factor).
+
+How would you like to proceed?
+  1. Suggest a different angle (e.g., "this is a process issue", "needs Tool+Guardrail combination")
+     → Attempt custom approach per user instruction, then enter next verify
+  2. "manual" — resolve this failure via manual intervention, end capability loop
+     (record "escalated to manual" in capabilities-log.md)
+  3. "abort" — give up, record failure only
+     (record "diagnosis exhausted" in capabilities-log.md, do not halt the rest of the workflow)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+**ultrawork mode exception:**
+
+```python
+if ultrawork_mode:
+    # Skip user prompt: try all 5 categories in sequence, record final state
+    all_tried_exhausted = exhaust_all_categories(failure, tried)
+    record_failure_to_log(
+        status="diagnosis_exhausted",
+        tried=all_tried_exhausted,
+        failure=failure
+    )
+    return  # Proceed without blocking downstream workflow
+```
+
+**Rollback of failed builds:**
+
+- Each failed capability build should be rolled back before trying the next category (unless it's non-destructive documentation).
+- For code additions (tool/guardrail/abstraction): `git checkout -- {files}` or delete created files.
+- For docs-only additions: leave in place (low risk) but note in escalation prompt.
+
 ### Step 5: PERSIST — Record for Future Reference
 
 Save the capability-building decision:
@@ -126,11 +212,14 @@ Update `.claude/vibe/capabilities-log.md`:
 ```markdown
 ## {date} — {capability-name}
 
+**Status**: resolved | escalated_to_manual | diagnosis_exhausted
 **Failure**: {what happened}
 **Missing**: {what capability was absent}
-**Built**: {what was created}
+**Tried**: {list of categories attempted, e.g., [Tool, Guardrail]}
+**Built**: {what was created (if resolved)}
 **Files**: {list}
-**Prevents**: {what class of failures this prevents}
+**Prevents**: {what class of failures this prevents (if resolved)}
+**Notes**: {for escalated/exhausted — what the user decided or what remains unsolved}
 ```
 
 ## Decision Tree
@@ -152,6 +241,21 @@ Agent failed
     │
     └─ Did the agent not KNOW it was wrong?
         YES → Build feedback (types/errors/tests)
+
+    ↓
+VERIFY: Does the built capability actually prevent the failure?
+    │
+    ├─ YES → PERSIST (log as "resolved")
+    │
+    └─ NO  → ESCALATE (Step 4.5)
+              │
+              ├─ Other categories untried? → Re-diagnose with exclusion list
+              │                              → BUILD next category → VERIFY
+              │
+              └─ All categories tried OR same diagnosis loops:
+                   │
+                   ├─ Interactive: Ask user (custom angle / manual / abort)
+                   └─ ultrawork: Auto-record "diagnosis_exhausted" → continue
 ```
 
 ## Anti-patterns

package/skills/chub-usage/SKILL.md

@@ -1,86 +1,86 @@
 ---
 name: chub-usage
 tier: optional
-description: "Context Hub (chub) — 검수된 최신 API 문서 조회. 외부 API/SDK 코드 작성 시 training data 대신 최신 문서를 기반으로 정확한 코드 작성."
+description: "Context Hub (chub) — fetch vetted, up-to-date API documentation. Write accurate code based on the latest docs instead of training data when working with external APIs/SDKs."
 triggers: [chub, context hub, API docs, latest API, deprecated API, SDK documentation, api reference, 최신 문서]
 priority: 65
 ---
 
 # Context Hub (chub) Usage
 
-외부 API/SDK 코드 작성 전 검수된 최신 문서를 가져오는 스킬.
-Training data의 지식 컷오프 문제를 해결합니다.
+A skill for fetching vetted, up-to-date documentation before writing external API/SDK code.
+Solves the knowledge cutoff problem inherent in training data.
 
 ## Why?
 
 | Problem | Solution |
 |---------|----------|
-| Training data에 의존 → deprecated API 사용 | chub get → 검수된 최신 문서 기반 코드 |
-| 웹 검색 → 노이즈 섞인 결과 | chub search → 큐레이션된 문서만 |
-| 세션마다 같은 실수 반복 | chub annotate → 학습 누적 |
+| Relying on training data → using deprecated APIs | chub get → code based on vetted latest docs |
+| Web search → noisy results | chub search → curated docs only |
+| Repeating the same mistakes every session | chub annotate → accumulated learnings |
 
 ## When to Use
 
 | Situation | Example |
 |-----------|---------|
-| 외부 API 코드 작성 | "Stripe 결제 연동해줘" |
-| SDK 최신 버전 확인 | "OpenAI 최신 모델 호출" |
-| 공식 문서 필요 | "Supabase auth 설정" |
-| Deprecated 패턴 방지 | "Firebase v10 마이그레이션" |
+| Writing external API code | "Integrate Stripe payments" |
+| Checking latest SDK version | "Call the latest OpenAI model" |
+| Need official documentation | "Set up Supabase auth" |
+| Preventing deprecated patterns | "Firebase v10 migration" |
 
 ## Workflow
 
 ```
-외부 API/SDK 코드 작성 요청
+Request to write external API/SDK code
     ↓
-Step 0: chub 설치 확인 (없으면 자동 설치)
+Step 0: Check if chub is installed (auto-install if not)
     ↓
-Step 1: chub search "<라이브러리명>"
+Step 1: chub search "<library name>"
     ↓
 Step 2: chub get <id> --lang ts
     ↓
-Step 3: 문서 기반 코드 작성
+Step 3: Write code based on the docs
     ↓
-Step 4: gotcha 발견 시 chub annotate
+Step 4: chub annotate when a gotcha is discovered
 ```
 
-## Step 0 — 자동 설치 (Auto-install)
+## Step 0 — Auto-install
 
-**스킬 실행 전 반드시 먼저 수행한다.**
+**Always perform this step before running the skill.**
 
 ```bash
-# 1. chub 존재 여부 확인
+# 1. Check if chub exists
 which chub || command -v chub
 ```
 
-chub이 없으면 자동 설치를 시도한다:
+If chub is not found, attempt automatic installation:
 
 ```bash
 npm install -g @aisuite/chub
 ```
 
-설치 실패 시 `npx @aisuite/chub`로 대체 실행한다:
+If installation fails, fall back to running via `npx @aisuite/chub`:
 
 ```bash
-# search 예시
+# search example
 npx @aisuite/chub search "stripe"
-# get 예시
+# get example
 npx @aisuite/chub get stripe/api --lang ts
 ```
 
-`npx`도 실패하면 context7 또는 Web Search로 폴백한다 (Fallback Chain 참조).
+If `npx` also fails, fall back to context7 or Web Search (see Fallback Chain).
 
 ## Usage
 
-### Step 1 — 문서 검색
+### Step 1 — Search for docs
 
 ```bash
 chub search "stripe"
 chub search "openai"
-chub search ""           # 전체 목록 확인
+chub search ""           # View full list
 ```
 
-### Step 2 — 최신 문서 fetch
+### Step 2 — Fetch latest docs
 
 ```bash
 chub get stripe/api --lang ts
@@ -88,26 +88,26 @@ chub get openai/chat --lang py
 chub get supabase/auth --lang js
 ```
 
-### Step 3 — 문서 기반 코드 작성
+### Step 3 — Write code based on the docs
 
-fetch한 문서 내용을 기반으로 정확한 코드 작성.
-**절대 training data에 의존하지 않는다. 문서 먼저, 코드 나중.**
+Write accurate code based on the fetched documentation.
+**Never rely on training data. Docs first, code second.**
 
-### Step 4 — 학습 내용 기록
+### Step 4 — Record learnings
 
-작업 중 발견한 gotcha, workaround, 버전 이슈:
+Gotchas, workarounds, and version issues discovered during work:
 
 ```bash
-chub annotate stripe/api "한국 결제는 pg 파라미터 필수"
-chub annotate openai/chat "streaming에서 tool_calls는 delta로 옴"
-chub annotate firebase/auth "v10에서 getAuth() import 경로 변경"
+chub annotate stripe/api "pg parameter is required for Korean payments"
+chub annotate openai/chat "tool_calls in streaming comes as delta"
+chub annotate firebase/auth "getAuth() import path changed in v10"
 ```
 
-Annotation은 로컬 저장, 다음 세션에서 `chub get` 시 자동으로 같이 나옴.
+Annotations are stored locally and automatically included the next time you run `chub get`.
 
 ## Implementation Pattern (Subagent)
 
-컨텍스트 블로트 방지를 위해 서브에이전트에서 실행:
+Run via subagent to prevent context bloat:
 
 ```
 Task tool call:
@@ -116,24 +116,24 @@ Task tool call:
 - prompt: "Run `chub search <library>` then `chub get <id> --lang <lang>` to fetch latest API documentation for [topic]. Return only the relevant API usage examples, key changes from previous versions, and any annotations."
 ```
 
-서브에이전트가 chub 호출을 처리하고 요약만 반환 → 메인 컨텍스트 깨끗하게 유지.
+The subagent handles the chub calls and returns only a summary — keeping the main context clean.
 
 ## Supported APIs (1,000+)
 
-OpenAI, Anthropic, Stripe, Firebase, Supabase, Vercel, AWS S3, Cloudflare Workers, Auth0, Clerk 등.
+OpenAI, Anthropic, Stripe, Firebase, Supabase, Vercel, AWS S3, Cloudflare Workers, Auth0, Clerk, and more.
 
 ```bash
-chub search    # 인자 없이 실행하면 전체 목록 확인 가능
+chub search    # Run without arguments to view the full list
 ```
 
 ## Fallback Chain
 
 ```
-which chub 실패
+which chub fails
     ↓
-npm install -g @aisuite/chub (자동 시도)
+npm install -g @aisuite/chub (auto attempt)
     ↓
-실패 시 npx @aisuite/chub <command> (임시 실행)
+On failure: npx @aisuite/chub <command> (temporary execution)
     ↓
-npx도 실패 시 context7 또는 Web Search fallback
+If npx also fails: context7 or Web Search fallback
 ```