@su-record/vibe 3.1.0 → 3.2.1

package/skills/vibe.review/references/race-mode.md

@@ -0,0 +1,117 @@
+# Race Mode — Full Reference
+
+> Loaded by vibe.review SKILL.md when Race Mode (`--race`, Multi-LLM competitive review) is invoked.
+
+### How It Works
+
+```
+/vibe.review --race
+
+security-review:
+├─ GPT Codex  → [SQL injection, XSS]
+└─ Antigravity     → [SQL injection, CSRF]
+         ↓
+   Cross-validation:
+   - SQL injection (2/2) → 🔴 P1 (100% confidence)
+   - XSS (1/2) → 🟡 P2 (50% confidence)
+   - CSRF (1/2) → 🟡 P2 (50% confidence)
+```
+
+### Confidence-Based Priority
+
+| Confidence | Priority | Meaning |
+|------------|----------|---------|
+| 100% (2/2) | P1 | Both models agree - high confidence |
+| 50% (1/2) | P2 | One model found - needs verification |
+
+### Race Mode Options
+
+```
+/vibe.review --race                  # All review types
+/vibe.review --race security         # Security only
+/vibe.review --race performance      # Performance only
+/vibe.review --race architecture     # Architecture only
+```
+
+### Race Mode Output
+
+```
+## SECURITY Review (Race Mode)
+
+**Duration**: 3420ms
+**Models**: GPT Codex, Antigravity
+
+### Model Results
+
+| Model | Issues Found | Duration | Status |
+|-------|--------------|----------|--------|
+| gpt | 3 | 1823ms | OK |
+| antigravity | 2 | 2156ms | OK |
+
+### Cross-Validated Issues
+
+**Summary**: 3 issues (P1: 1, P2: 2)
+**Consensus Rate**: 67%
+
+#### 🔴 P1 - SQL Injection in user query
+
+- **Confidence**: 100% (gpt, antigravity)
+- **Severity**: critical
+- **Location**: `src/api/users.ts:42`
+- **Suggestion**: Use parameterized queries
+
+#### 🟡 P2 - XSS vulnerability in render
+
+- **Confidence**: 50% (gpt)
+- **Severity**: high
+- **Location**: `src/components/Comment.tsx:15`
+```
+
+### Codex Review (Codex 플러그인 활성화 시)
+
+Race Mode에서 GPT+Antigravity와 **동시에** Codex review 실행하여 3중 교차 검증:
+
+```
+/codex:review
+```
+
+교차 검증 테이블:
+
+```markdown
+| Issue | GPT | Antigravity | Codex | Confidence |
+|-------|-----|--------|-------|------------|
+| {이슈} | ✅/❌ | ✅/❌ | ✅/❌ | {%} |
+```
+
+- 3개 모델 중 2개 이상 동의 → **High Confidence** (P1 자동 수정)
+- Codex만 발견 → **Medium Confidence** (P2 수동 검토)
+
+### When to Use Race Mode
+
+| Scenario | Recommended |
+|----------|-------------|
+| Critical security review | ✅ `--race security` |
+| Pre-production audit | ✅ `--race` |
+| Quick iteration | ❌ Standard review |
+| API cost concerns | ❌ Standard review |
+
+### Tool Invocation (Race Mode - GPT + Antigravity in parallel via Bash)
+
+**🚨 Use --input file to avoid CLI argument length limits and Windows pipe issues.**
+
+1. Save code to review into `[SCRATCHPAD]/review-code.txt` (using Write tool)
+2. Write JSON input file `[SCRATCHPAD]/review-input.json` (using Write tool):
+   - `{"prompt": "Review this code for [REVIEW_TYPE]. Return JSON: {issues: [{id, title, description, severity, suggestion}]}. Code: [CODE_CONTENT]"}`
+   - Where `[CODE_CONTENT]` is the code text (properly JSON-escaped inside the prompt string)
+3. Script path: `[LLM_SCRIPT]` = `{{VIBE_PATH}}/hooks/scripts/llm-orchestrate.js`
+4. Run GPT + Antigravity in PARALLEL (two Bash tool calls at once):
+
+```bash
+# GPT review (Bash tool call 1)
+node "[LLM_SCRIPT]" gpt orchestrate-json --input "[SCRATCHPAD]/review-input.json"
+```
+
+```bash
+# Antigravity review (Bash tool call 2 - run in parallel)
+node "[LLM_SCRIPT]" antigravity orchestrate-json --input "[SCRATCHPAD]/review-input.json"
+```

package/skills/vibe.review/references/worked-examples.md

@@ -0,0 +1,94 @@
+# Review Worked Examples — Full Reference
+
+> Loaded by vibe.review SKILL.md for Tech Stack Detection, Review Debate output, Auto-Fix output, Todo file naming, and Core Tool usage examples.
+
+## Phase 1 Tech Stack Detection — Full Detection List
+
+```
+Read package.json      -> TypeScript, React, Node.js
+Read pyproject.toml    -> Python, FastAPI, Django
+Read Gemfile           -> Ruby, Rails
+Read pubspec.yaml      -> Flutter, Dart
+Read go.mod            -> Go
+Read CLAUDE.md         -> Explicit tech stack declaration
+```
+
+## Phase 4.5 Review Debate — Example Output
+
+**토론 결과 예시:**
+
+```
+🤝 REVIEW DEBATE RESULTS
+
+Consensus (4 parallel reviewers):
+
+✅ Validated P1 (unanimous):
+  1. [SECURITY] SQL Injection — 4/4 agree critical
+
+⬆️ Upgraded P2→P1 (debate result):
+  2. [PERF] Unbounded query — code-reviewer (focus: architecture) pointed out
+     cascading failure risk under load → agreed P1
+
+⬇️ Downgraded P1→P2 (debate result):
+  3. [SECURITY] CSRF on read-only endpoint — code-reviewer (focus: complexity)
+     noted endpoint has no side effects → agreed P2
+
+❌ Removed (false positive):
+  4. [ARCH] "Circular dependency" — code-reviewer (focus: architecture) confirmed
+     this is intentional bi-directional reference, not a cycle
+
+🆕 New findings (cross-review discussion):
+  5. [DATA] Race condition in concurrent updates — emerged from
+     security + performance cross-review
+```
+
+## Phase 5 Auto-Fix — Example Output
+
+```
+🔧 AUTO-FIX Starting...
+
+P1 Critical:
+  1. [SECURITY] SQL Injection → Fixed with parameterized query ✅
+  2. [DATA] Missing transaction rollback → Added try-finally ✅
+
+P2 Important:
+  3. [PERF] N+1 query → Added select_related ✅
+  4. [ARCH] Circular dependency → Separated dependencies ✅
+  5. [TEST] Missing edge case → Added test ✅
+
+🔍 Re-validating...
+  ✅ Build successful
+  ✅ Tests passed
+
+✅ 5 issues auto-fixed!
+```
+
+## Phase 6 Todo File Creation — Naming Examples
+
+```
+{priority}-{category}-{short-desc}.md
+
+Examples:
+- P2-arch-large-refactor.md  (Cannot be auto-fixed)
+- P3-style-extract-helper.md (Backlog)
+```
+
+## Core Tools — Example Tool Usage in Review
+
+**1. Validate code quality before review:**
+
+```bash
+node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index.js').then(t => t.validateCodeQuality({targetPath: 'src/', projectPath: process.cwd()}).then(r => console.log(r.content[0].text)))"
+```
+
+**2. Analyze complexity of changed files:**
+
+```bash
+node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index.js').then(t => t.analyzeComplexity({targetPath: 'src/api/users.ts', projectPath: process.cwd()}).then(r => console.log(r.content[0].text)))"
+```
+
+**3. Save critical finding for reference:**
+
+```bash
+node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index.js').then(t => t.saveMemory({key: 'review-pr123-critical', value: 'SQL injection in users.py:42', category: 'review', projectPath: process.cwd()}).then(r => console.log(r.content[0].text)))"
+```

package/skills/vibe.run/SKILL.md

@@ -201,18 +201,41 @@ Step 3: If neither → Error: "Run /vibe.spec first"
 
 **Split structure:** Load `_index.md` first, then phase files in order. Execute phases sequentially (or per `--phase` flag).
 
+### 1-0. Compile + validate execution packet (MANDATORY)
+
+For a monolithic SPEC, compile it after resolving the canonical path. For a split SPEC, do not compile `_index.md`; defer this step until each active phase file is loaded in Phase Isolation Step B. Compile with `writeExecutionPacket`, then immediately verify the saved artifact with `validateExecutionPacket`.
+
+```bash
+node -e "import('file://{{VIBE_PATH}}/dist/tools/index.js').then(t => {
+  const projectPath=process.cwd(), specPath='.vibe/specs/{feature-name}.md';
+  const profile='{codex-or-claude-code}';
+  const written=t.writeExecutionPacket({projectPath,specPath,profile});
+  if(!written.ok){console.error(JSON.stringify(written.errors));process.exit(1)}
+  const checked=t.validateExecutionPacket({projectPath,specPath,packetPath:written.packetPath});
+  if(!checked.valid){console.error(checked.code);process.exit(1)}
+  console.log(written.packetPath);
+})"
+```
+
+- Codex uses profile `codex`; Claude Code uses `claude-code`.
+- Split SPECs compile each active `phase-N-*.md` immediately before that phase runs; `_index.md` remains the overview ANCHOR and is not treated as a phase contract.
+- Use the packet only when validation returns `valid: true`.
+- `STALE_PACKET`, invalid packet, preservation-audit failure, or budget failure is blocking: recompile from the canonical SPEC and never silently fall back to an unvalidated packet.
+- The packet is a derived execution view. The canonical SPEC remains the ANCHOR and source of truth.
+
 ### 1-1. Phase Isolation Protocol (Large SPEC Guard, MANDATORY for 3+ phases)
 
 ```
 Step A: Read _index.md (overview only — phase list, REQ IDs)
 Step B: For each Phase N:
   1. RE-READ Phase N SPEC section (every time, no memory)
-  2. RE-READ Phase N Feature scenarios
-  3. Extract Phase N scope: files, scenarios, requirements
-  4. Implement Phase N scenarios
-  5. Verify Phase N
-  6. Write Phase Checkpoint → .vibe/checkpoints/
-  7. DISCARD Phase N details from working memory
+  2. Compile + validate Phase N execution packet using the phase file path
+  3. RE-READ Phase N Feature scenarios
+  4. Extract Phase N scope: files, scenarios, requirements
+  5. Implement Phase N scenarios
+  6. Verify Phase N
+  7. Write Phase Checkpoint → .vibe/checkpoints/
+  8. DISCARD Phase N details from working memory
 Step C: Next Phase
 ```
 

package/skills/vibe.trace/SKILL.md

@@ -213,18 +213,18 @@ RTM status === 'empty'
 
 ### Run-ledger flow
 
-`/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:
+`/vibe.verify` records its outcome through `hooks/scripts/verify-ledger.js`, binding the current run ID and command-result evidence. This writes `verifyPassed` and `verifyAt` into `.vibe/metrics/run-ledger.json`. Downstream gates consume this record:
 
 | Gate | Behavior |
 |------|----------|
 | `auto-commit` | Commits only when `verifyPassed === true` AND `verifyAt > runStarted` |
 | Stop hook | Warns when `runStarted && !verifyPassed`; blocks once if `verifyGate.mode === 'block'` |
 
-**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.
+**To register a passing trace as verified**, run `/vibe.verify` after `/vibe.trace` reports acceptable coverage. The verify skill records the current run ID and command evidence internally — you do not invoke the ledger CLI manually.
 
 ```
 /vibe.trace "login"         → RTM: 9/9 (100%)
-/vibe.verify "login"        → runs checks → calls verify-ledger.js pass
+/vibe.verify "login"        → runs checks → records pass + run ID + command results
                             → .vibe/metrics/run-ledger.json updated
 auto-commit / Stop gate     → verifyPassed=true, gate clears
 ```

package/skills/vibe.verify/SKILL.md

@@ -104,7 +104,7 @@ Load skill `contract` with: check "{feature}"
 
 ### 7. Metrics + Ledger update (MANDATORY final step)
 
-Record run metrics, then write the verify result to the run ledger. This is the machine-readable JUDGE record consumed by the Stop-hook verify gate, auto-commit verify gate, and loop-contract gates.
+Record run metrics, then write the verify result to the run ledger. This is the machine-readable deterministic JUDGE record consumed by the Stop-hook verify gate, auto-commit verify gate, and loop-contract gates. `recordVerify` also writes `.vibe/runs/{run-id}/evidence.json`; Model Judge findings remain advisory-only and Human Taste remains release-only.
 
 ```bash
 # Append step-count history (ok if current-run.json missing)
@@ -113,15 +113,21 @@ const fs=require('fs'),p='.vibe/metrics';
 try{const c=JSON.parse(fs.readFileSync(p+'/current-run.json','utf-8'));
 fs.appendFileSync(p+'/history.jsonl',JSON.stringify({verifiedAt:new Date().toISOString(),feature:c.feature,startedAt:c.startedAt,steps:c.steps||0})+'\n');}catch{}"
 
-# Record verify result — pass | fail (calls recordVerify on the run ledger)
+# Write the exact commands run in steps 2-3 and their exit codes.
+mkdir -p .vibe/metrics
+# Write `.vibe/metrics/verification-results.json` as:
+# [{"command":"npm test","exitCode":0}, ...]
+
+# Bind the result to the current run and its command evidence.
 HOOKS_DIR="${VIBE_PATH:-$(npm root -g 2>/dev/null)/@su-record/vibe}/hooks/scripts"
-[ -f "$HOOKS_DIR/verify-ledger.js" ] && node "$HOOKS_DIR/verify-ledger.js" pass   # or: fail
+RUN_ID=$(node -p "JSON.parse(require('fs').readFileSync('.vibe/metrics/run-ledger.json','utf8')).runId")
+[ -f "$HOOKS_DIR/verify-ledger.js" ] && node "$HOOKS_DIR/verify-ledger.js" pass "$RUN_ID" .vibe/metrics/verification-results.json   # or: fail
 
 # Recipe extraction (best-effort, silent)
 [ -f "$HOOKS_DIR/recipe-extractor.js" ] && node "$HOOKS_DIR/recipe-extractor.js" 2>/dev/null || true
 ```
 
-Use `pass` only when the summary in step 4 is PASS; otherwise `fail`. Skipping this step leaves `verifyPassed` unset and downstream gates will treat the run as unverified.
+Use `pass` only when the summary in step 4 is PASS; otherwise `fail`. A passing record requires at least one command result and every exit code must be zero. A stale run ID, missing evidence, or mismatched result leaves `verifyPassed` unset and downstream gates treat the run as unverified.
 
 ## Failure escalation (convergence-based, no retry cap)
 

package/vibe/rules/loop-contract.md

@@ -17,15 +17,19 @@
   → 루프:
       ANCHOR   디스크에서 재고정: SPEC + run-ledger + scope.json (+ 직전 인박스)
       ACT      파이프라인 실행 (스킬 체인)
-      JUDGE    결정론 판정만 인정: run-ledger verifyPassed │ 테스트 exit code │ RTM status
-               — 모델의 "완료했습니다" 자기 보고는 종료 조건이 될 수 없다
-      RECORD   run-ledger(현재 회전) + loop-history.jsonl(회전 이력, 스케줄 루프)
+      JUDGE    Deterministic Judge(blocking): run-ledger verifyPassed │ 테스트 exit code │ RTM status
+               Model Judge(advisory-only): 발견을 제안하지만 완료 권한 없음
+               Human Taste(release-only): UX·브랜드·제품 감각을 판단하지만 루프 완료 권한 없음
+      RECORD   run-ledger + `.vibe/runs/{run-id}/evidence.json` + loop-history.jsonl
   → 종료(EXIT): 게이트 전부 통과 │ stuck │ max_iterations │ 예산 상한
 ```
 
 ### ANCHOR가 컨텍스트 오염 방어인 이유
 루프 상태는 컨텍스트가 아니라 디스크에 산다. 매 회전이 아티팩트에서 다시 시작하므로 컨텍스트가 오염되거나 compact로 소실돼도 루프는 깨지지 않으며, 회전마다 fresh 컨텍스트(서브에이전트)로 돌려도 된다.
 
+### Judge 권한 경계
+종료 권한은 테스트 exit code·run-ledger·RTM 같은 **결정론적 Judge**에만 있다. Model Judge는 누락·모순·위험을 발견하는 보조 수단이며, 발견을 테스트나 관측 가능한 기준으로 내리기 전에는 차단 근거가 아니다. Human Taste는 공개·배포 시점의 사람 판단으로 남고 루프의 완료 상태를 변경하지 않는다.
+
 ### stuck (결정론)
 연속 2회 회전의 발견(discover/findings) 해시가 동일 → 중단하고 사람에게 (`loop-ledger.js check-stuck`이 판정·기록). "다시 해보면 될 것 같다"는 모델 판단으로 무시 금지.
 

package/vibe/templates/claudemd-template.md

@@ -64,7 +64,7 @@ Convergence Principle: loop until P1 = 0. Changed files only.
 
 ## Context Management
 
-At 85%+ context: `save_memory` → `/new` → `/vibe.utils --continue` (raised from 70% — `/new` discards the entire KV prefix cache, so compacting less often preserves cache reuse)
+At 85%+ context: `save_memory` → `/new` → `/vibe.continue` (raised from 70% — `/new` discards the entire KV prefix cache, so compacting less often preserves cache reuse)
 
 ## Git Commit Rules
 

package/vibe/templates/spec-template.md

@@ -10,13 +10,29 @@
 
 {What and why — 1-3 sentences.}
 
+### Context Sources
+
+- {File, document, URL, or observed system state used as input}
+
 ### Assumptions
 
 - {Default adopted without asking — e.g., session expiry 24h}
 
+### Constraints
+
+- {Invariant or implementation boundary that every execution packet must preserve}
+
+---
+
+## 2. Requirements
+
+| ID | Requirement | Done Criteria |
+|----|-------------|---------------|
+| REQ-{feature}-001 | {Observable functional requirement} | D1, D2 |
+
 ---
 
-## 2. Done Criteria (deterministic gates)
+## 3. Done Criteria (deterministic gates)
 
 > Each criterion must be judgeable by a command or observable behavior — never by self-report.
 > These are the JUDGE inputs of the loop (`vibe/rules/loop-contract.md`); `/vibe.verify` records the result in `.vibe/metrics/run-ledger.json`.
@@ -26,9 +42,18 @@
 | D1 | {e.g., all scenarios in the feature file pass} | {e.g., `npx vitest run` exit 0} |
 | D2 | {e.g., build succeeds with no type errors} | {e.g., `npm run build` exit 0} |
 
+### Evidence Required
+
+- D1 → {Command result, test report, log, screenshot, or verified code location}
+- D2 → {Evidence required for this specific criterion}
+
+### Human Taste (Non-Blocking)
+
+- {UX, brand, or product-quality review reserved for the release decision; never a loop completion gate}
+
 ---
 
-## 3. Scenarios
+## 4. Scenarios
 
 > Mirrored to `.vibe/features/{feature}.feature` (gherkin). Every scenario maps to a Done criterion.
 
@@ -46,13 +71,13 @@ Scenario: {Edge case title}           # → D1
 
 ---
 
-## 4. Out of Scope
+## 5. Out of Scope
 
 - {Explicitly not doing this time — must not be empty}
 
 ---
 
-## 5. API Contract (only if the feature exposes an API)
+## 6. API Contract (only if the feature exposes an API)
 
 > Presence of this section enables `/vibe.contract` drift detection.
 
@@ -64,8 +89,10 @@ Response: 201 {...}
 
 ---
 
-## 6. Verification
+## 7. Verification
 
 - `/vibe.run "{feature}"` implements scenario-by-scenario, verifying each immediately.
 - `/vibe.verify "{feature}"` judges the Done Criteria and sets `verifyPassed` in the run-ledger.
+- Verification writes `.vibe/runs/{run-id}/evidence.json`; only deterministic Judge results can complete the loop.
+- Model Judge findings are advisory-only. Human Taste is release-only.
 - Gate = all Done Criteria pass (exit codes / observed behavior) — loop continues until gates pass, stuck, or max iterations.

package/agents/acceptance-tester.md

@@ -1,56 +0,0 @@
-# Acceptance Tester Agent
-
-Acceptance gate for a feature: verifies that acceptance criteria are testable,
-routes changed code to the right reviews, and synthesizes one QA verdict.
-
-## Role
-
-- Verify SPEC acceptance criteria are measurable and Feature scenarios complete
-- Route changed files to the right QA focus and dispatch reviews in parallel
-- Synthesize findings into a single prioritized QA report
-
-## Model
-
-**Sonnet** — routing judgement plus criteria analysis
-
-## Goal
-
-Answer "is this feature acceptably done, and how would we know?". Two halves:
-
-**Criteria testability** — read `.vibe/specs/{feature}.md` (`<acceptance>`
-section) and `.vibe/features/{feature}.feature`. Every acceptance criterion
-needs a concrete pass/fail condition (numeric thresholds, not "fast" or
-"user-friendly"), at least one Given/When/Then scenario, and an automatable
-check. Error paths and boundary conditions must be covered, not just the
-happy path. Report untestable criteria with a concrete measurable rewrite.
-
-**QA routing** — check readiness first: if the build fails, stop and report
-build errors only. Then classify `git diff --name-only` output and dispatch
-the matching reviews in parallel (max 5), each with its explicit file list:
-
-| Change signal | Dispatch |
-|---|---|
-| API/services/controllers | code-reviewer (correctness, performance), security-reviewer |
-| UI components/pages | design-reviewer, code-reviewer (correctness) |
-| Models/migrations/schema | code-reviewer (data-integrity) |
-| Auth/session/middleware | security-reviewer, e2e-tester |
-| Multi-step flows (checkout, forms) | e2e-tester, tester (edge cases) |
-| Config/CI/infra | security-reviewer, code-reviewer (architecture) |
-
-Merge results by priority (P1/P2/P3), de-duplicate, and elevate confidence on
-findings flagged by two or more reviewers. State which QA modalities were
-*not* run and why — coverage gaps are part of the verdict.
-
-## Constraints
-
-Report-only: never modify source code, write tests, or create files — output
-is the QA report text; fixes belong to the implementer. If a dispatched
-review fails, retry once, then record it as a coverage gap rather than
-blocking. Judge completion by evidence (test exit codes, reviewer findings),
-never by the implementer's self-report.
-
-## Done
-
-- Every acceptance criterion classified: testable / needs rewrite (with proposed measurable version) / not automatable
-- Build status verified before any review dispatch
-- Unified report: P1/P2/P3 findings with locations, cross-validated findings marked, coverage gaps listed

package/agents/documenter.md

@@ -1,43 +0,0 @@
-# Documenter Agent
-
-Documentation generator for the two artifacts that go stale fastest: API docs
-and changelogs.
-
-## Role
-
-- Extract API endpoints/interfaces from source and document them with schemas and examples
-- Generate changelog entries from git diff with semantic version bump suggestion
-- Flag undocumented endpoints and missing migration guides
-
-## Model
-
-**Haiku** — fast extraction and drafting
-
-## Goal
-
-**API mode** — walk the route handlers/controllers in the given scope and
-document each endpoint: method + path, auth requirement, parameters (path/
-query/body with types, required vs optional, enum values), success and error
-responses (all status codes actually returned), and a runnable example (curl
-or fetch). List endpoints that exist in code but lack documentation — the gap
-list is as valuable as the docs.
-
-**Changelog mode** — from `git diff` and `git log`, classify changes as
-breaking / added / changed / fixed / performance / internal / dependencies.
-Recommend the semantic version bump with a one-line reason. Every breaking
-change gets migration steps; every fix states old vs new behavior.
-
-## Constraints
-
-Return documentation as text output only — never create or write files; the
-calling command decides where content lands. Descriptions are user-facing:
-what changed for the consumer, not which internal function was refactored
-(pure refactors go under Internal, briefly). Document what the code actually
-does, not what comments claim — when they disagree, flag the discrepancy
-rather than picking one silently.
-
-## Done
-
-- API mode: every endpoint in scope documented or explicitly listed as an undocumented gap
-- Changelog mode: all changes classified, version bump recommended with reason, breaking changes have migration steps
-- Output is paste-ready text; zero files created

package/agents/figma/figma-engineer.md

@@ -1,76 +0,0 @@
-# Figma Engineer Agent
-
-End-to-end Figma → production code specialist: extract, refine, design, build,
-and pixel-verify — one agent owning the whole pipeline per breakpoint.
-
-## Role
-
-- Collect and refine Figma design data (tree.json → sections.json) per breakpoint
-- Design the component tree and build HTML + script-generated SCSS
-- Verify with compile gates and pixel-level visual comparison until P1 = 0
-
-## Model
-
-**Sonnet** — structured pipeline work with strict invariants
-
-## Goal
-
-Turn a Figma file/node into components that match the design pixel-for-pixel.
-Work per breakpoint under `/tmp/{feature}/{bp}-main/`, section by section
-(sequential, never parallel), and treat visual verification as part of the
-work — code that compiles but hasn't been compared against the Figma
-screenshots is unfinished.
-
-## Pipeline Knowledge
-
-**Refine (tree.json → sections.json)** — run `figma-refine.js`. The result
-must contain the full recursive subtree (leaf nodes included) so code can be
-generated without ever re-reading tree.json. Refinement rules: drop 0px nodes,
-VECTOR decoration lines (w/h ≤ 2px), and `isMask` nodes; move BG frames out of
-children into `images.bg`; move vector-lettering GROUPs and designed TEXT
-(multi-fill/gradient/effects) into `images.content`; everything else stays in
-children with its CSS.
-
-**Image classification (blocking — settle before any code)**: TEXT child →
-HTML (exception: designed text stays an image); repeated INSTANCE → HTML
-`v-for`; interactive → HTML button/a; dynamic data → HTML text; all four no →
-image is allowed.
-
-**Component design (sections.json → component-spec.json)** — 1-depth children
-become section components; an INSTANCE repeated 2+ times is a shared-component
-candidate, used in 3+ places makes it shared. Semantic tags: top level
-`section`, headings `h1–h6` in order, copy `p`, clickable `button`/`a`, lists
-`ul/ol > li`. The spec fixes tags/structure/roles/props — build follows it, no
-ad-hoc restructuring.
-
-**Build (per section)** — run `figma-to-scss.js` for the SCSS skeleton, write
-the HTML template from the spec, add interactions (@click, v-for, state), then
-run `figma-validate.js` and fix mismatches until it passes before moving to
-the next section.
-
-**Verify** — capture a tsc/build error baseline before building (only new
-errors are yours). Gate 1: typecheck + build + dev server up. Gate 2 (visual,
-mandatory): rendered screenshots vs Figma `sections/` screenshots — pixelmatch
-diffRatio > 0.1 → P1; computed CSS vs sections.json — delta > 4px → P1,
-≤ 4px → P2; check for missing images/text. Fix and re-verify until P1 = 0;
-no iteration cap.
-
-## Constraints
-
-SCSS is never hand-written: only `figma-to-scss.js` output, imported as-is —
-no edits to its values, no custom functions/mixins, no CSS in Vue/React
-`<style>` blocks beyond `@import`, no project tokens (the script emits its
-own). Use only the installed `~/.vibe/hooks/scripts/figma-*.js` scripts; never
-write substitute refine/generate scripts in `/tmp` — if a script's output is wrong,
-report that the script needs fixing. CSS values stay Figma-original px (no
-vw/clamp/@media — this is static implementation). Image files are kebab-case
-(`hero-bg.webp`, never hash names); BG renders via CSS `background-image`,
-never `<img>`. Before building, confirm sections.json exists (run
-figma-refine.js if not) and that every SCSS file traces to a figma-to-scss.js
-invocation.
-
-## Done
-
-- Every section built per component-spec.json and passing figma-validate.js
-- Typecheck + build green (against the pre-existing baseline)
-- Visual verification executed with P1 = 0 (diffRatio ≤ 0.1, CSS deltas ≤ 4px); remaining P2s listed

package/dist/cli/postinstall/index.d.ts

@@ -1,23 +0,0 @@
-/**
- * postinstall 모듈
- *
- * 관심사별 모듈 분리:
- * - fs-utils: 파일시스템 유틸리티
- * - global-config: 전역 설정 관리
- * - constants: 상수 데이터
- * - inline-skills: 인라인 스킬 시딩
- * - cursor-rules: Cursor 룰 변환/생성
- * - cursor-agents: Cursor 에이전트 변환/설치
- * - claude-agents: Claude Code 네이티브 에이전트 변환/설치
- * - cursor-skills: Cursor 스킬 생성
- * - main: 메인 오케스트레이션
- */
-export { getCoreConfigDir, replaceTemplatesInDir } from './fs-utils.js';
-export { STACK_TO_LANGUAGE_FILE, GLOBAL_SKILLS, GLOBAL_SKILLS_CORE, GLOBAL_SKILLS_STANDARD, GLOBAL_SKILLS_OPTIONAL, STACK_TO_SKILLS, CAPABILITY_SKILLS, AVAILABLE_CAPABILITIES, resolveLocalSkills, resolveExternalSkills, CONDITIONAL_AGENT_GROUPS, STACK_TO_AGENT_GROUPS, CAPABILITY_AGENT_GROUPS, resolveLocalAgentGroups } from './constants.js';
-export { copySkillsFiltered, applyCodexSkillInvocationPolicies } from './fs-utils.js';
-export { generateCursorRules } from './cursor-rules.js';
-export { installCursorAgents } from './cursor-agents.js';
-export { installClaudeAgents } from './claude-agents.js';
-export { generateCursorSkills } from './cursor-skills.js';
-export { main } from './main.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/cli/postinstall/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/postinstall/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,aAAa,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,eAAe,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACrV,OAAO,EAAE,kBAAkB,EAAE,iCAAiC,EAAE,MAAM,eAAe,CAAC;AACtF,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC"}

package/dist/cli/postinstall/index.js

@@ -1,23 +0,0 @@
-/**
- * postinstall 모듈
- *
- * 관심사별 모듈 분리:
- * - fs-utils: 파일시스템 유틸리티
- * - global-config: 전역 설정 관리
- * - constants: 상수 데이터
- * - inline-skills: 인라인 스킬 시딩
- * - cursor-rules: Cursor 룰 변환/생성
- * - cursor-agents: Cursor 에이전트 변환/설치
- * - claude-agents: Claude Code 네이티브 에이전트 변환/설치
- * - cursor-skills: Cursor 스킬 생성
- * - main: 메인 오케스트레이션
- */
-export { getCoreConfigDir, replaceTemplatesInDir } from './fs-utils.js';
-export { STACK_TO_LANGUAGE_FILE, GLOBAL_SKILLS, GLOBAL_SKILLS_CORE, GLOBAL_SKILLS_STANDARD, GLOBAL_SKILLS_OPTIONAL, STACK_TO_SKILLS, CAPABILITY_SKILLS, AVAILABLE_CAPABILITIES, resolveLocalSkills, resolveExternalSkills, CONDITIONAL_AGENT_GROUPS, STACK_TO_AGENT_GROUPS, CAPABILITY_AGENT_GROUPS, resolveLocalAgentGroups } from './constants.js';
-export { copySkillsFiltered, applyCodexSkillInvocationPolicies } from './fs-utils.js';
-export { generateCursorRules } from './cursor-rules.js';
-export { installCursorAgents } from './cursor-agents.js';
-export { installClaudeAgents } from './claude-agents.js';
-export { generateCursorSkills } from './cursor-skills.js';
-export { main } from './main.js';
-//# sourceMappingURL=index.js.map