@su-record/vibe 2.12.5 → 2.13.0

package/skills/vibe.run/references/ralph-loop.md

@@ -0,0 +1,172 @@
+# Ralph Loop — Full Reference
+
+> Loaded by vibe.run SKILL.md when Ralph Loop or ULTRAWORK is active (coverage verification).
+
+## Ralph Loop (Completion Verification)
+
+> **Inspired by [ghuntley.com/ralph](https://ghuntley.com/ralph)**: "Deterministically bad in an undeterministic world" — Keep iterating until TRULY complete.
+
+**Problem**: AI often claims "complete" when implementation is partial.
+
+**Solution**: RTM-based automated coverage verification with iteration tracking.
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    RALPH LOOP (Mandatory)                        │
+│                                                                  │
+│   After ALL phases complete:                                     │
+│                                                                  │
+│   ┌──────────────────────────────────────────────────────────┐  │
+│   │  RTM COVERAGE VERIFICATION [Iteration {{ITER}}/{{MAX}}]   │  │
+│   │                                                           │  │
+│   │  Generate RTM via core tools:                             │  │
+│   │  → generateTraceabilityMatrix("{feature-name}")           │  │
+│   │                                                           │  │
+│   │  Coverage Metrics (automated):                            │  │
+│   │  □ Requirements coverage: {coveragePercent}%              │  │
+│   │  □ SPEC → Feature mapping: {featureCovered}/{total}       │  │
+│   │  □ Feature → Test mapping: {testCovered}/{total}          │  │
+│   │  □ Build successful?                                      │  │
+│   │  □ Tests passing?                                         │  │
+│   │                                                           │  │
+│   │  UNCOVERED: {uncoveredRequirements[]}                     │  │
+│   └──────────────────────────────────────────────────────────┘  │
+│                              │                                   │
+│                   ┌──────────┴──────────┐                       │
+│                   │  Coverage == 100%?  │                       │
+│                   └──────────┬──────────┘                       │
+│                       │              │                          │
+│                      NO            YES                          │
+│                       │              │                          │
+│                       ↓              ↓                          │
+│              ┌────────────────┐  ┌────────────────┐             │
+│              │ IMPLEMENT      │  │ TRULY DONE     │             │
+│              │ UNCOVERED      │  │                │             │
+│              │ REQUIREMENTS   │  │ Report final   │             │
+│              │ (auto-extract) │  │ RTM coverage   │             │
+│              └───────┬────────┘  └────────────────┘             │
+│                      │                                          │
+│                      └──────────→ [Re-generate RTM]             │
+│                                                                  │
+│                      │                                          │
+│                      ↓                                          │
+│              Stuck? (coverage unchanged from prev iteration)    │
+│                      │                                          │
+│                      ├─ Interactive: Ask user                   │
+│                      │     1. Provide resolution → retry        │
+│                      │     2. "proceed" → TODO + done           │
+│                      │     3. "abort" → stop                    │
+│                      └─ ultrawork: TODO + done                  │
+│                                                                  │
+│   NO iteration cap — loop until 100% OR stuck                   │
+│   ZERO TOLERANCE for silent scope reduction                     │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## RTM Invocation
+
+```bash
+# Generate RTM for coverage verification (generateTraceabilityMatrix is synchronous — no .then())
+node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index.js').then(t => { const r = t.generateTraceabilityMatrix('{feature-name}', {projectPath: process.cwd()}); console.log(JSON.stringify(r, null, 2)); })"
+```
+
+> **Note:** Default SPEC path is `.vibe/specs/<feature>.md` (falls back to `.claude/vibe/specs/` then `.claude/specs/` for legacy projects).
+> `status === 'empty'` means the gate MUST be treated as failed/not-applicable, never as 100% pass.
+
+## RTM Metrics
+
+| Metric | Description |
+|--------|-------------|
+| `totalRequirements` | Total REQ-* items in SPEC |
+| `specCovered` | Requirements with SPEC mapping |
+| `featureCovered` | Requirements with Feature scenarios |
+| `testCovered` | Requirements with test files |
+| `coveragePercent` | Overall coverage percentage |
+| `uncoveredRequirements` | List of missing REQ-* IDs |
+
+## Ralph Loop Rules
+
+| Rule | Description |
+|------|-------------|
+| **No Scope Reduction** | Never say "simplified" or "basic version" — implement FULL request |
+| **Iteration Tracking** | Display `[{{ITER}}]` to show progress (no max — loop until done) |
+| **RTM-Based Gap List** | Use `uncoveredRequirements` array — no manual comparison |
+| **Coverage Threshold** | Must reach 100% coverage to complete |
+| **No Iteration Cap** | Loop until 100% coverage OR stuck (convergence detected) |
+| **Stuck Handling** | If coverage % unchanged between iterations → ask user (proceed/abort/fix), or ultrawork → TODO + done |
+| **Diminishing Returns** | Iteration 3+ → focus on core requirements (REQ-*-001~003) first; P2/P3 continue but lower priority |
+
+## Ralph Loop Output Format
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+RALPH VERIFICATION [Iteration 1]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+RTM Coverage Report: login
+
+Requirements Traceability:
+  Total Requirements: 9
+  SPEC Covered: 9/9 (100%)
+  Feature Covered: 5/9 (55%)
+  Test Covered: 4/9 (44%)
+
+  REQ-login-001: Login form UI → Scenario 1 → login.test.ts
+  REQ-login-002: Email validation → Scenario 2 → validation.test.ts
+  REQ-login-003: Password validation → Scenario 2 → validation.test.ts
+  REQ-login-004: Remember me checkbox → NOT IMPLEMENTED
+  REQ-login-005: Forgot password link → NOT IMPLEMENTED
+  REQ-login-006: API integration → Scenario 3 → api.test.ts
+  REQ-login-007: Loading state → NOT IMPLEMENTED
+  REQ-login-008: Error toast → NOT IMPLEMENTED
+  REQ-login-009: Session storage → Scenario 4 → (no test)
+
+Overall Coverage: 55% BELOW 100% TARGET
+
+UNCOVERED REQUIREMENTS (auto-extracted from RTM):
+  1. REQ-login-004: Remember me checkbox
+  2. REQ-login-005: Forgot password link
+  3. REQ-login-007: Loading state
+  4. REQ-login-008: Error toast notifications
+
+NOT COMPLETE — Implementing uncovered requirements...
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+RALPH VERIFICATION [Iteration 2]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+RTM Coverage Report: login
+
+Requirements Traceability:
+  Total Requirements: 9
+  SPEC Covered: 9/9 (100%)
+  Feature Covered: 9/9 (100%)
+  Test Covered: 9/9 (100%)
+
+Overall Coverage: 100% TARGET REACHED
+
+Build: Passed
+Tests: 12/12 Passed
+Type Check: No errors
+
+RALPH VERIFIED COMPLETE!
+
+RTM saved: .vibe/rtm/login-rtm.md
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## When to Trigger Ralph Loop
+
+1. After all phases complete
+2. Before final quality report
+3. Whenever user says "ultrawork" or "ralph"
+
+## Forbidden Responses (VIOLATIONS)
+
+| NEVER Say | Instead |
+|-----------|---------|
+| "I've implemented a basic version" | Implement the FULL version |
+| "This is a simplified approach" | Implement as specified |
+| "You can add X later" | Add X now |
+| "For demonstration purposes" | Implement production-ready |
+| "The core functionality is done" | ALL functionality must be done |

package/skills/vibe.run/references/ultrawork-mode.md

@@ -0,0 +1,148 @@
+# ULTRAWORK Mode — Full Reference
+
+> Loaded by vibe.run SKILL.md when user includes `ultrawork` or `ulw` keyword.
+
+## What ULTRAWORK Enables
+
+When you include `ultrawork` (or `ulw`), ALL of these activate automatically:
+
+| Feature | Description |
+|---------|-------------|
+| **Parallel Exploration** | 3+ Task(haiku) agents run simultaneously |
+| **Boulder Loop** | Auto-continues until ALL phases complete |
+| **Context Compression** | Aggressive auto-save at 70%+ context |
+| **No Pause** | Doesn't wait for confirmation between phases |
+| **External LLMs** | Auto-consults GPT/Antigravity if enabled |
+| **Error Recovery** | Loops until 100% or stuck; on stuck auto-records TODO and proceeds (no user prompt) |
+| **Race Review (v2.6.9)** | Multi-LLM review (GPT+Antigravity) with cross-validation |
+
+## Boulder Loop (Inspired by Sisyphus)
+
+Like Sisyphus rolling the boulder, ULTRAWORK **keeps going until done**:
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    BOULDER LOOP (ultrawork)                      │
+│                                                                  │
+│   ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐  │
+│   │ Phase 1  │───→│ Phase 2  │───→│ Phase 3  │───→│ Phase N  │  │
+│   └──────────┘    └──────────┘    └──────────┘    └──────────┘  │
+│        │               │               │               │         │
+│        ↓               ↓               ↓               ↓         │
+│   [Parallel]      [Parallel]      [Parallel]      [Parallel]    │
+│   [Implement]     [Implement]     [Implement]     [Implement]   │
+│   [Test]          [Test]          [Test]          [Test]        │
+│        │               │               │               │         │
+│        └───────────────┴───────────────┴───────────────┘         │
+│                              │                                   │
+│                              ↓                                   │
+│                     ┌──────────────┐                             │
+│                     │  ALL DONE?   │                             │
+│                     └──────────────┘                             │
+│                       │         │                                │
+│                      NO        YES                               │
+│                       │         │                                │
+│                       ↓         ↓                                │
+│                   [Continue]  [Complete!]                        │
+│                                                                  │
+│   NO STOPPING until acceptance criteria met or error limit hit   │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## ULTRAWORK Example Session
+
+```
+User: /vibe.run "brick-game" ultrawork
+
+Claude:
+ULTRAWORK MODE ACTIVATED
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+SPEC: .vibe/specs/brick-game.md
+4 Phases detected
+Boulder Loop: ENABLED (will continue until all phases complete)
+Auto-retry: ON (loop until 100% or stuck → auto-TODO)
+Context compression: AGGRESSIVE
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+BOULDER ROLLING... Phase 1/4
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+[PARALLEL] Launching 3 exploration agents...
+Exploration complete (7.2s)
+Implementing...
+Phase 1 complete
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+BOULDER ROLLING... Phase 2/4
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+[PARALLEL] Launching 3 exploration agents...
+Exploration complete (6.8s)
+Implementing...
+Test failed: collision detection
+Auto-retry [iteration 1]...
+Fixing...
+Phase 2 complete
+
+[...continues automatically...]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+BOULDER REACHED THE TOP!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+All 4 phases complete
+All acceptance criteria passed
+Build succeeded
+Tests passed
+
+Total: 8m 24s
+Retries: 2
+Context saved: 3 checkpoints
+```
+
+## Normal vs ULTRAWORK Comparison
+
+| Aspect | Normal | ULTRAWORK |
+|--------|--------|-----------|
+| Phase transition | May pause | Auto-continues |
+| On error | Reports and stops | Auto-retries (3x) |
+| Context 70%+ | Warning only | Auto-compress + save |
+| Exploration | Sequential possible | FORCED parallel |
+| Completion | Phase-by-phase | Until ALL done |
+
+## Automation Level System
+
+Magic keywords in the user input automatically set the **AutomationLevel**, which controls how much the AI self-advances vs. pausing for confirmation.
+
+### Level Definitions
+
+| Level | Name | Keyword(s) | Auto-advance | Auto-retry | Stuck Behavior | Parallel Agents | Checkpoints |
+|-------|------|------------|--------------|------------|----------------|-----------------|-------------|
+| L0 | Manual | `manual` | No | No | Ask user every step | No | All |
+| L1 | Guided | `guided`, `verify` | No | No | Ask user on stuck | No | All |
+| L2 | Semi-auto | `quick` (default) | Yes | Yes (low cap: 2) | Ask user after 2 retries | No | Key points |
+| L3 | Auto | `ultrawork`, `ulw` | Yes | Yes (no cap) | Auto-TODO + proceed | Yes | Checkpoint-only |
+| L4 | Full-auto | `ralph`, `ralplan` | Yes | Yes (no cap) | Auto-TODO + proceed | Yes | None |
+
+### Detection Rule
+
+```
+/vibe.run "login"              → L2 Semi-auto (default)
+/vibe.run "login" ultrawork    → L3 Auto
+/vibe.run "login" ralph        → L4 Full-auto
+/vibe.run "login" verify       → L1 Guided
+```
+
+### Confirmation Matrix
+
+| Action | L0 | L1 | L2 | L3 | L4 |
+|--------|----|----|----|----|-----|
+| `destructive` | confirm | confirm | confirm | confirm | auto |
+| `architecture_choice` | confirm | confirm | confirm | auto | auto |
+| `implementation_scope` | confirm | confirm | confirm | auto | auto |
+| `phase_advance` | confirm | confirm | auto | auto | auto |
+| `fix_strategy` | confirm | confirm | auto | auto | auto |
+| `retry` | confirm | auto | auto | auto | auto |
+
+**Rule**: When confirmation is required, pause and display a checkpoint before proceeding.

package/skills/vibe.trace/SKILL.md

@@ -187,63 +187,50 @@ Loading files:
 The RTM generation uses core tools:
 
 ```bash
-# Generate RTM
-node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index.js').then(t => t.generateTraceabilityMatrix('login').then(m => console.log(t.formatMatrixAsMarkdown(m))))"
+# Generate RTM (generateTraceabilityMatrix is synchronous — no .then())
+node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index.js').then(t => { const m = t.generateTraceabilityMatrix('login', {projectPath: process.cwd()}); console.log(t.formatMatrixAsMarkdown(m)); })"
 
 # Generate HTML
-node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index.js').then(t => t.generateTraceabilityMatrix('login').then(m => console.log(t.formatMatrixAsHtml(m))))"
+node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index.js').then(t => { const m = t.generateTraceabilityMatrix('login', {projectPath: process.cwd()}); console.log(t.formatMatrixAsHtml(m)); })"
 ```
 
-## VerificationLoop Integration
+> **Note:** Default SPEC path is `.vibe/specs/<feature>.md` (falls back to `.claude/vibe/specs/` then `.claude/specs/` for legacy projects).
+> `status === 'empty'` means the gate MUST be treated as failed/not-applicable, never as 100% pass.
 
-`/vibe.trace` results feed directly into the **VerificationLoop** module, which quantifies achievement rate and drives automatic re-iteration.
+## Post-Trace Gates
 
-### Key Functions
+After `/vibe.trace` completes and the RTM is displayed, two downstream mechanisms consume the result.
 
-| Function | Purpose |
-|----------|---------|
-| `createLoop(feature, config?)` | Initialize a new verification loop for a feature |
-| `recordVerification(state, requirements)` | Record RTM results and determine next action |
-| `formatVerificationResult(result, config)` | Format a single iteration result for display |
-| `formatLoopSummary(state)` | Format the full loop history as readable text |
-| `getUnmetRequirements(result)` | Extract failed/partial requirements for targeted fixing |
-| `isImproving(state)` | Detect whether achievement rate is increasing across iterations |
+### Empty-result gate
 
-### Loop Configuration
+`generateTraceabilityMatrix` returns `status: 'empty'` when no `REQ-<feature>-NNN` IDs are found in the SPEC. This state **must be treated as a gate failure**, not as 100% coverage. When the matrix status is `empty`, report it explicitly and do not proceed as if the feature is verified.
 
 ```
-threshold:      90    — Minimum achievement rate (%) to pass (default)
-maxIterations:  3     — Max re-verification attempts before stopping
-autoRetry:      false — Whether to auto-trigger re-implementation
+RTM status === 'empty'
+  → Coverage gate: FAILED (no requirements to trace)
+  → Action: run /vibe.spec to add REQ-IDs before re-running /vibe.trace
 ```
 
-### Action Types
+### Run-ledger flow
 
-After each `recordVerification` call, the loop returns one of:
+`/vibe.verify` records its outcome via `hooks/scripts/verify-ledger.js pass|fail`. This writes `verifyPassed` and `verifyAt` into `.vibe/metrics/run-ledger.json`. Downstream gates consume this record:
 
-| Action | Condition | Meaning |
-|--------|-----------|---------|
-| `passed` | rate >= threshold | All requirements met — done |
-| `retry` | rate < threshold AND iterations remaining | Fix unmet requirements and re-run |
-| `max_iterations` | rate < threshold AND no iterations left | Report remaining gaps as TODO |
+| Gate | Behavior |
+|------|----------|
+| `auto-commit` | Commits only when `verifyPassed === true` AND `verifyAt > runStarted` |
+| Stop hook | Warns when `runStarted && !verifyPassed`; blocks once if `verifyGate.mode === 'block'` |
 
-### Convergence Detection
-
-If the achievement rate does not improve between iterations (`isImproving` returns false), the loop stops early to avoid wasted cycles.
-
-### Example Flow
+**To register a passing trace as verified**, run `/vibe.verify` after `/vibe.trace` reports acceptable coverage. The verify skill calls `verify-ledger.js pass` internally — you do not invoke it manually.
 
 ```
-/vibe.trace "login"
-  → RTM generated: 7/9 requirements covered (78%)
-  → createLoop("login", { threshold: 90, maxIterations: 3 })
-  → recordVerification(...) → action: retry (iteration 1, 3 unmet)
-  → [fix unmet requirements]
-  → /vibe.trace "login"
-  → recordVerification(...) → action: passed (rate: 100%)
-  → formatVerificationResult → display final report
+/vibe.trace "login"         → RTM: 9/9 (100%)
+/vibe.verify "login"        → runs checks → calls verify-ledger.js pass
+                            → .vibe/metrics/run-ledger.json updated
+auto-commit / Stop gate     → verifyPassed=true, gate clears
 ```
 
+If `/vibe.verify` is skipped, `auto-commit` will log the skip reason and abort the commit.
+
 ## Options
 
 | Option | Description |

package/skills/vibe.verify/SKILL.md

@@ -465,6 +465,21 @@ Load skill `contract` with: check "{feature-name}"
 - **P1 drift** → demote verify to fail; auto-call `/vibe.regress register --from-contract`
 - P2 / P3 drift → warning only; verify still passes
 
+## Ledger Update (MANDATORY final step)
+
+After producing the verification report, record the result to the run ledger:
+
+```bash
+# pass 또는 fail — 시나리오 전체 통과 여부에 따라 선택
+HOOKS_DIR="${VIBE_PATH:-$(npm root -g 2>/dev/null)/@su-record/vibe}/hooks/scripts"
+if [ -f "$HOOKS_DIR/verify-ledger.js" ]; then
+  node "$HOOKS_DIR/verify-ledger.js" pass   # 전체 통과 시
+  # node "$HOOKS_DIR/verify-ledger.js" fail  # 실패 시
+fi
+```
+
+Replace `pass` with `fail` when any scenario fails. This step enables the Stop-hook verify-skip gate and auto-commit verify gate.
+
 ## Next Step
 
 On verification pass:

package/hooks/scripts/figma-guard.js

@@ -1,219 +0,0 @@
-#!/usr/bin/env node
-/**
- * Figma Guard — vibe.figma 작업 시 스킬 우회 차단
- *
- * 차단 대상:
- *   1. /tmp/{feature}/ 하위에 자체 정제/생성 스크립트(.mjs/.js) 작성
- *      → figma-refine.js / figma-to-scss.js 호출하라고 차단
- *   2. SCSS 파일을 직접 작성 (figma-to-scss.js 호출 흔적 없이)
- *   3. Vue/React <style> 블록에 figma 관련 SCSS 클래스 직접 작성
- *
- * 작동 조건:
- *   - tool: Write 또는 Edit
- *   - file_path가 figma 작업 컨텍스트에 해당
- *
- * Exit codes:
- *   0 — 통과
- *   2 — 차단
- */
-
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-
-// ─── stdin 읽기 ─────────────────────────────────────────────────────
-
-function readStdinSync() {
-  try {
-    if (process.stdin.isTTY) return null;
-    // fd 0을 직접 사용 (Windows는 '/dev/stdin'이 없음)
-    const buf = Buffer.alloc(1024 * 1024); // 1MB
-    const bytesRead = fs.readSync(0, buf, 0, buf.length, null);
-    if (bytesRead > 0) {
-      return JSON.parse(buf.toString('utf-8', 0, bytesRead));
-    }
-  } catch { /* fallback */ }
-  return null;
-}
-
-// ─── 검사 1: /tmp/{feature}/ 자체 작성 스크립트 ─────────────────────
-
-const FORBIDDEN_TMP_SCRIPT_PATTERNS = [
-  /\/tmp\/[^/]+\/refine[\w-]*\.(mjs|js)$/i,
-  /\/tmp\/[^/]+\/.*sections.*\.(mjs|js)$/i,
-  /\/tmp\/[^/]+\/.*to-scss.*\.(mjs|js)$/i,
-  /\/tmp\/[^/]+\/.*generate-scss.*\.(mjs|js)$/i,
-  /\/tmp\/[^/]+\/analyze-tree\.(mjs|js)$/i,
-  /\/tmp\/[^/]+\/analyze-section\.(mjs|js)$/i,
-];
-
-function checkForbiddenTmpScript(filePath) {
-  if (!filePath) return null;
-  for (const pattern of FORBIDDEN_TMP_SCRIPT_PATTERNS) {
-    if (pattern.test(filePath)) {
-      return {
-        block: true,
-        reason: `자체 작성 figma 스크립트 금지: ${path.basename(filePath)}`,
-        suggestion: 'figma-refine.js / figma-to-scss.js / figma-validate.js 사용. ' +
-                    '결과가 마음에 안 들면 ~/.vibe/hooks/scripts/figma-*.js 자체를 수정하세요.'
-      };
-    }
-  }
-  return null;
-}
-
-// ─── 검사 2: SCSS 직접 작성 ─────────────────────────────────────────
-
-/**
- * Figma 작업 컨텍스트인지 판단:
- *   - 현재 작업 디렉토리 또는 file_path에 figma 관련 흔적이 있어야 함
- *   - /tmp/ 하위에 sections.json이 존재 → 활성 figma 작업으로 판단
- */
-function isFigmaContext() {
-  try {
-    const tmpDirs = fs.readdirSync('/tmp', { withFileTypes: true });
-    for (const entry of tmpDirs) {
-      if (!entry.isDirectory()) continue;
-      const moSections = path.join('/tmp', entry.name, 'mo-main', 'sections.json');
-      const pcSections = path.join('/tmp', entry.name, 'pc-main', 'sections.json');
-      if (fs.existsSync(moSections) || fs.existsSync(pcSections)) {
-        return { active: true, feature: entry.name };
-      }
-    }
-  } catch { /* ignore */ }
-  return { active: false };
-}
-
-/**
- * SCSS 파일 작성 시도 검사
- */
-function checkScssWrite(filePath, content) {
-  if (!filePath) return null;
-  if (!filePath.endsWith('.scss')) return null;
-
-  // figma 컨텍스트가 아니면 통과
-  const ctx = isFigmaContext();
-  if (!ctx.active) return null;
-
-  // 자동 생성 표시 코멘트 있으면 통과
-  if (typeof content === 'string' && content.includes('Auto-generated from sections.json')) {
-    return null;
-  }
-
-  // 빈 파일 또는 @import만 있는 경우 통과
-  if (typeof content === 'string') {
-    const meaningfulLines = content
-      .split('\n')
-      .map(l => l.trim())
-      .filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
-    const hasOnlyImports = meaningfulLines.every(l =>
-      l.startsWith('@import') || l.startsWith('@use') || l.startsWith('@forward')
-    );
-    if (hasOnlyImports) return null;
-  }
-
-  return {
-    block: true,
-    reason: `SCSS 직접 작성 금지: ${filePath}`,
-    suggestion: `figma-to-scss.js로 생성하세요:\n` +
-                `  node ~/.vibe/hooks/scripts/figma-to-scss.js \\\n` +
-                `    /tmp/${ctx.feature}/{bp}-main/sections.json \\\n` +
-                `    --out=$(dirname ${filePath})`
-  };
-}
-
-// ─── 검사 3: Vue/React <style> 블록에 CSS 값 작성 ───────────────────
-
-function checkVueStyleBlock(filePath, content) {
-  if (!filePath) return null;
-  if (!/\.(vue|jsx|tsx)$/.test(filePath)) return null;
-
-  const ctx = isFigmaContext();
-  if (!ctx.active) return null;
-
-  // 파일 경로에 feature 이름이 있는지 확인
-  if (!filePath.includes(ctx.feature)) return null;
-
-  if (typeof content !== 'string') return null;
-
-  // <style ...> ... </style> 블록 추출
-  const styleBlocks = content.match(/<style[^>]*>([\s\S]*?)<\/style>/g);
-  if (!styleBlocks || styleBlocks.length === 0) return null;
-
-  for (const block of styleBlocks) {
-    const inner = block.replace(/<style[^>]*>/, '').replace(/<\/style>/, '');
-    const meaningfulLines = inner
-      .split('\n')
-      .map(l => l.trim())
-      .filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
-
-    // @import / @use 만 있으면 통과
-    const hasOnlyImports = meaningfulLines.every(l =>
-      l.startsWith('@import') || l.startsWith('@use') || l.startsWith('@forward')
-    );
-    if (hasOnlyImports) continue;
-
-    // CSS 값으로 보이는 라인 검출 (px, rem, color, flex 등)
-    const hasCssValue = meaningfulLines.some(l =>
-      /:\s*[^;]*(?:px|rem|em|%|vh|vw|#[0-9a-fA-F]|rgba?\(|flex|grid|absolute|relative|inherit)/.test(l)
-    );
-    if (hasCssValue) {
-      return {
-        block: true,
-        reason: `Vue/React <style> 블록에 CSS 직접 작성 금지: ${path.basename(filePath)}`,
-        suggestion: `<style> 블록은 @import만 허용:\n` +
-                    `  <style lang="scss" scoped>\n` +
-                    `  @import '~/assets/scss/${ctx.feature}/index.scss';\n` +
-                    `  </style>`
-      };
-    }
-  }
-
-  return null;
-}
-
-// ─── 메인 ───────────────────────────────────────────────────────────
-
-const stdinPayload = readStdinSync();
-if (!stdinPayload) {
-  process.exit(0);
-}
-
-const toolName = stdinPayload.tool_name || '';
-const toolInput = stdinPayload.tool_input || {};
-
-// Write 또는 Edit만 검사
-if (toolName !== 'Write' && toolName !== 'Edit') {
-  process.exit(0);
-}
-
-const filePath = toolInput.file_path || '';
-const content = toolInput.content || toolInput.new_string || '';
-
-// 3단계 검사
-const checks = [
-  checkForbiddenTmpScript(filePath),
-  checkScssWrite(filePath, content),
-  checkVueStyleBlock(filePath, content),
-];
-
-const violations = checks.filter(c => c !== null);
-
-if (violations.length === 0) {
-  process.exit(0);
-}
-
-// 차단
-const messages = ['🚫 FIGMA GUARD: 스킬 규칙 위반'];
-for (const v of violations) {
-  messages.push('');
-  messages.push(`  ${v.reason}`);
-  messages.push(`  💡 ${v.suggestion}`);
-}
-messages.push('');
-messages.push('⛔ vibe.figma 작업 중에는 스크립트 파이프라인을 우회하지 마세요.');
-messages.push('   ~/.vibe/hooks/scripts/figma-{refine,to-scss,validate}.js만 사용.');
-
-// PreToolUse hook은 stderr 출력 + exit 2로 차단
-console.error(messages.join('\n'));
-process.exit(2);