reborn-vibe4 1.0.0

package/README.md

@@ -0,0 +1,37 @@
+# reborn-vibe4 — 바이브 코딩 전에 깔 플러그인 넷 안내 스킬
+
+클로드 코드로 바이브 코딩을 시작하기 전에 깔 만한 **Supabase 플러그인 · Vercel 플러그인 · Oh My Claude Code · Chrome DevTools MCP** 의
+공식 설치 명령과, 붙이기 전에 알아야 할 것을 먼저 말해 주는 안내 스킬입니다.
+
+```
+npx --yes reborn-vibe4            # 안내 스킬을 깐다
+npx --yes reborn-vibe4 --check    # 이 PC 에 넷이 붙어 있는지 본다 (파일만 읽는다)
+```
+
+깔리는 자리 `~/.claude/skills/vibe-coding-plugins` · 사실 원장 `skill/facts.json`(확인일 2026-10-01).
+
+★**넷은 깔지도, 대신 실행하지도 않습니다.** 공식 명령을 보여 드리고 사용자가 보고 직접 칩니다.
+
+---
+
+## 먼저 아셔야 할 셋
+
+1. **Supabase 플러그인이 묶어 온 MCP 에는 `read_only` 가 없습니다.** 기본이 쓰기 가능입니다.
+   읽기전용으로 붙이는 줄(공식 문서의 URL 파라미터)을 스킬이 알려 줍니다.
+2. **플러그인과 MCP 는 안 써도 매 호출 문맥에 실립니다.** 넷을 다 켜지 말고 지금 일에 필요한 것만 켭니다.
+3. **Chrome DevTools MCP 는 연결된 크롬의 내용을 모델에 노출합니다.** 민감한 탭을 띄우지 않습니다.
+
+## 실측한 값 (2026-10-01)
+
+| 도구 | 저장소 | 라이선스 | 설치 |
+|---|---|---|---|
+| Supabase 플러그인 | supabase-community/supabase-plugin | MIT | `/plugin install supabase@claude-plugins-official` |
+| Vercel 플러그인 | vercel/vercel-plugin | Apache-2.0 | `/plugin install vercel@claude-plugins-official` |
+| Oh My Claude Code | Yeachan-Heo/oh-my-claudecode | MIT | `/plugin marketplace add https://github.com/Yeachan-Heo/oh-my-claudecode` → `/plugin install oh-my-claudecode` |
+| Chrome DevTools MCP | ChromeDevTools/chrome-devtools-mcp | Apache-2.0 | `claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest` |
+
+GitHub API · 각 저장소 README/LICENSE · Anthropic 공식 마켓플레이스 목록 · supabase.com 공식 문서로 직접 확인했습니다.
+이 PC 에서 넷을 실제로 깔아 본 것은 아닙니다.
+
+넷은 각각 다른 회사·프로젝트가 만든 것이며 **리본랩스와 제휴 관계가 없습니다.**
+이 안내 스킬과 설치기는 무료이며, 각 도구의 요금은 적지 않았습니다(바뀌는 값).

package/install.mjs

@@ -0,0 +1,475 @@
+#!/usr/bin/env node
+/**
+ * reborn-vibe4 — 바이브 코딩 전에 깔 플러그인 넷 안내 스킬 설치기
+ *
+ *   npx --yes reborn-vibe4              ~/.claude/skills/vibe-coding-plugins/ 에 안내 스킬을 깐다
+ *   npx --yes reborn-vibe4 --check      이 PC 에 넷이 붙어 있는지 본다(파일만 읽는다 · 아무것도 안 고친다)
+ *   npx --yes reborn-vibe4 --self-test  스스로 시험한다
+ *
+ * 규율:
+ *   · 사실은 skill/facts.json 에서만 온다. 여기서 짓지 않는다.
+ *   · ★넷(Supabase · Vercel · Oh My Claude Code · Chrome DevTools MCP)은 깔지도 · 덮지도 · 지우지도 않는다.
+ *     사용자 PC 에 이미 붙어 있을 수 있다. 우리는 공식 명령을 보여 줄 뿐이고, 사용자가 보고 직접 친다.
+ *   · --check 는 ~/.claude.json · ~/.claude/plugins/installed_plugins.json · 현재 폴더 .mcp.json 을 읽기만 한다.
+ */
+import { readFileSync, readdirSync, mkdirSync, existsSync, statSync, cpSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir, tmpdir } from "node:os";
+
+const 이파일 = fileURLToPath(import.meta.url);
+const HERE = dirname(이파일);
+const F = JSON.parse(readFileSync(join(HERE, "skill", "facts.json"), "utf8"));
+const 스킬이름 = "vibe-coding-plugins";
+const 표식 = "reborn-vibe4:guide";
+const 퍼널 = "vibe4";
+const 인수 = process.argv.slice(2);
+const 있나 = (f) => 인수.includes(f);
+
+const C = {
+  진: (s) => `\x1b[1m${s}\x1b[0m`,
+  흐: (s) => `\x1b[2m${s}\x1b[0m`,
+  코: (s) => `\x1b[38;5;209m${s}\x1b[0m`,
+  빨: (s) => `\x1b[38;5;203m${s}\x1b[0m`,
+  초: (s) => `\x1b[38;5;114m${s}\x1b[0m`,
+  노: (s) => `\x1b[38;5;221m${s}\x1b[0m`,
+};
+
+const 도구 = (이름) => F.도구.find((c) => c.이름 === 이름);
+
+/* ══ 이 PC 에 붙어 있나 — 파일만 읽는다 ═════════════════════════════ */
+
+function 읽기(경로) {
+  try { return { 값: JSON.parse(readFileSync(경로, "utf8")), 깨짐: false }; }
+  catch (e) { return { 값: null, 깨짐: e.code !== "ENOENT" }; }
+}
+
+/** 플러그인 키 「이름@마켓」 에서 이름이 정확히 같은 것만 센다. (vercel-deploy 가 vercel 로 잡히면 안 된다) */
+function 플러그인있나(플러그인들, 이름) {
+  return Object.keys(플러그인들 || {}).filter((k) => k.split("@")[0] === 이름);
+}
+
+/** MCP 서버를 모은다: ~/.claude.json 최상위 + projects[*] + 현재 폴더 .mcp.json */
+function MCP모으기(집, 폴더) {
+  const 목록 = [];
+  const 깨진 = [];
+  const 담기 = (서버들, 범위) => {
+    for (const [이름, s] of Object.entries(서버들 || {})) 목록.push({ 이름, 범위, 설정: s || {} });
+  };
+  const 홈 = 읽기(join(집, ".claude.json"));
+  if (홈.깨짐) 깨진.push(".claude.json");
+  if (홈.값) {
+    담기(홈.값.mcpServers, "사용자");
+    for (const [경로, p] of Object.entries(홈.값.projects || {})) 담기(p?.mcpServers, "프로젝트 " + 경로);
+  }
+  const 프로젝트 = 읽기(join(폴더, ".mcp.json"));
+  if (프로젝트.깨짐) 깨진.push(".mcp.json");
+  if (프로젝트.값) 담기(프로젝트.값.mcpServers, "이 폴더 .mcp.json");
+  return { 목록, 깨진 };
+}
+
+const 글 = (s) => JSON.stringify(s?.설정 ?? {});
+
+/**
+ * ★순수 함수 — 집·폴더를 받아 네 칸을 돌려준다. 시험이 가짜 집으로 양방향을 잰다.
+ * 읽기만 한다. 어떤 파일도 쓰지 않는다.
+ */
+export function 점검(집 = homedir(), 폴더 = process.cwd()) {
+  const 설치 = 읽기(join(집, ".claude", "plugins", "installed_plugins.json"));
+  const 플러그인들 = 설치.값?.plugins || {};
+  const { 목록: mcp, 깨진 } = MCP모으기(집, 폴더);
+  if (설치.깨짐) 깨진.push("installed_plugins.json");
+
+  const 결과 = {};
+  /* ① Supabase — 플러그인 또는 원격 MCP(mcp.supabase.com) */
+  {
+    const p = 플러그인있나(플러그인들, "supabase");
+    const m = mcp.filter((s) => /mcp\.supabase\.com/.test(글(s)));
+    const 읽기전용들 = m.map((s) => /[?&]read_only=true(&|"|$)/.test(글(s)));
+    결과["Supabase 플러그인"] = {
+      설치: p.length > 0 || m.length > 0,
+      어디: [...p.map((k) => "플러그인 " + k), ...m.map((s) => `MCP ${s.이름} (${s.범위})`)],
+      플러그인: p.length > 0,
+      MCP: m.length > 0,
+      읽기전용: m.length ? 읽기전용들.every(Boolean) : null,
+    };
+  }
+  /* ② Vercel — 플러그인 */
+  {
+    const p = 플러그인있나(플러그인들, "vercel");
+    결과["Vercel 플러그인"] = { 설치: p.length > 0, 어디: p.map((k) => "플러그인 " + k) };
+  }
+  /* ③ Oh My Claude Code — 플러그인 */
+  {
+    const p = 플러그인있나(플러그인들, "oh-my-claudecode");
+    결과["Oh My Claude Code"] = { 설치: p.length > 0, 어디: p.map((k) => "플러그인 " + k) };
+  }
+  /* ④ Chrome DevTools MCP — MCP 또는 플러그인 */
+  {
+    const p = 플러그인있나(플러그인들, "chrome-devtools-mcp");
+    const m = mcp.filter((s) => /chrome-devtools-mcp/.test(글(s)));
+    결과["Chrome DevTools MCP"] = {
+      설치: p.length > 0 || m.length > 0,
+      어디: [...p.map((k) => "플러그인 " + k), ...m.map((s) => `MCP ${s.이름} (${s.범위})`)],
+    };
+  }
+  return { 결과, 깨진 };
+}
+
+function 점검보고(집 = homedir(), 폴더 = process.cwd()) {
+  const { 결과, 깨진 } = 점검(집, 폴더);
+  console.log("");
+  console.log(C.진("이 PC 에 붙어 있나") + C.흐("  — 파일만 읽었습니다. 아무것도 깔거나 고치지 않았습니다."));
+  let 붙음 = 0;
+  for (const d of F.도구) {
+    const r = 결과[d.이름];
+    if (r.설치) {
+      붙음++;
+      console.log(`  ${C.초("✓")} ${d.이름}  ${C.흐(r.어디.join(" · "))}`);
+      if (d.이름 === "Supabase 플러그인") {
+        if (r.MCP && r.읽기전용 === true) console.log(C.흐("      MCP 주소에 read_only=true 가 있습니다."));
+        else if (r.MCP && r.읽기전용 === false) console.log("      " + C.노("! MCP 주소에 read_only=true 가 없습니다 — 쓰기가 열려 있습니다."));
+        if (r.플러그인) console.log("      " + C.노("! 플러그인이 묶어 온 MCP 에는 읽기전용 표시가 없습니다(기본이 쓰기 가능)."));
+        if (r.플러그인 || r.읽기전용 === false) {
+          console.log(C.흐("      읽기전용으로 붙이려면:"));
+          console.log("      " + C.코(d.읽기전용));
+        }
+      }
+    } else {
+      console.log(`  ${C.빨("✗")} ${d.이름}  ${C.흐("— 없음")}`);
+    }
+  }
+  if (깨진.length) console.log(C.노(`\n  ! 읽다가 깨진 파일: ${깨진.join(", ")} — 그 칸은 「없음」으로 셌습니다.`));
+  console.log(C.흐(`\n  ${붙음}/${F.도구.length} 붙어 있습니다.`));
+  console.log(C.흐("  여기서 보이는 것은 이 PC 의 사용자 설정과 현재 폴더 .mcp.json 뿐입니다. 다른 폴더의 프로젝트 설정은 그 폴더에서 다시 보세요."));
+  console.log("");
+  return 결과;
+}
+
+/* ══ 설치 ══════════════════════════════════════════════════════════ */
+
+function 깔기(집 = homedir(), { 조용히 = false } = {}) {
+  const 스킬들 = join(집, ".claude", "skills");
+  const 밖 = join(스킬들, 스킬이름);
+  const 기존 = join(밖, "SKILL.md");
+
+  /* ★남의 스킬을 덮지 않는다 — 같은 이름 폴더에 우리 표식이 없으면 멈춘다 */
+  if (existsSync(기존) && !readFileSync(기존, "utf8").includes(표식)) {
+    if (!조용히) {
+      console.log(C.빨(`\n  ✗ ${밖} 에 다른 스킬이 이미 있습니다 — 덮어쓰지 않았습니다.`));
+      console.log(C.흐("    그 폴더를 옮기거나 지운 뒤 다시 실행하세요.\n"));
+    }
+    process.exitCode = 1;
+    return false;
+  }
+
+  mkdirSync(밖, { recursive: true });
+  cpSync(join(HERE, "skill"), 밖, { recursive: true });
+
+  /* ★깔았다고 말하기 전에 실제로 읽히는지 본다. 파일 복사는 조용히 실패한다. */
+  const 확인 = [기존, join(밖, "facts.json")];
+  const 빠진 = 확인.filter((p) => !existsSync(p) || statSync(p).size < 200);
+  if (빠진.length) {
+    if (!조용히) {
+      console.log(C.빨("\n  ✗ 깔다가 말았습니다 — 다음 파일이 비었습니다:"));
+      for (const p of 빠진) console.log("    " + p);
+    }
+    process.exitCode = 1;
+    return false;
+  }
+  if (조용히) return 밖;
+
+  console.log("");
+  console.log(C.초("  ✓ 깔렸습니다") + C.흐(`  →  ${밖}`));
+  console.log("");
+  console.log("  지금 이 PC 에 뭐가 붙어 있는지부터 보세요:");
+  console.log(C.코("    npx --yes reborn-vibe4 --check"));
+  console.log("");
+  console.log("  넷의 공식 설치 명령입니다 — " + C.진("보고 직접 치세요. 대신 깔지 않습니다."));
+  console.log(C.흐("  / 로 시작하는 줄은 클로드 코드 안에서, claude mcp add 는 터미널에서 칩니다."));
+  for (const d of F.도구) {
+    console.log("");
+    console.log(`  ${C.진(d.번호 + ". " + d.이름)} ${C.흐(`${d.저장소} · ${d.라이선스}`)}`);
+    for (const 줄 of d.명령) console.log("    " + C.코(줄));
+    if (d.명령메모) console.log(C.흐("    " + d.명령메모));
+  }
+  console.log("");
+  console.log("  " + C.노("★ Supabase 는 쓰기 권한부터 막으세요") + C.흐(" — 플러그인이 묶어 온 MCP 에는 읽기전용 표시가 없습니다(기본이 쓰기 가능)."));
+  console.log(C.흐("    읽기전용으로 붙이는 줄:"));
+  console.log("    " + C.코(도구("Supabase 플러그인").읽기전용));
+  console.log("  " + C.노("★ 넷을 다 켜지 마세요") + C.흐(" — 플러그인과 MCP 는 안 써도 매 호출 문맥에 실립니다."));
+  console.log("");
+  console.log("  클로드 코드를 " + C.진("다시 켜면") + " 안내가 바로 잡힙니다. 이렇게 말해 보세요:");
+  console.log("");
+  console.log(C.코("    바이브 코딩 전에 뭘 깔아야 해?"));
+  console.log(C.코("    supabase 플러그인 붙이는데 DB 를 지울까 봐 무서워"));
+  console.log("");
+  return 밖;
+}
+
+/* ══ 끝난 뒤 한 칸 ═════════════════════════════════════════════════ */
+async function 끝한칸() {
+  try {
+    const { TAIL, 링크, 마지막 } = await import("./tail.mjs");
+    const t = TAIL[퍼널];
+    const 굵게 = (s) => s.replace(/\*\*(.+?)\*\*/g, (_, x) => `\x1b[0m\x1b[1m${x}\x1b[0m\x1b[2m`);
+    console.log(C.흐("  ────────────────────────────────────────────────"));
+    for (const 줄 of t.이음) console.log(C.흐("  " + 굵게(줄)));
+    console.log("");
+    console.log("  " + C.진(t.제목) + C.흐("  — " + t.한줄));
+    console.log("  " + C.코(링크(퍼널)));
+    console.log(C.흐("  " + 마지막));
+    console.log("");
+  } catch { /* 안내가 없어도 설치는 끝난 것이다 */ }
+}
+
+/* ══ 자가시험 ══════════════════════════════════════════════════════ */
+async function 자가시험() {
+  const 나쁨 = [];
+  let 건 = 0;
+  const T = (이름, 참) => { 건++; if (!참) 나쁨.push(이름); };
+
+  /* ① 사실 원장 */
+  T("facts.json 에 확인일이 없다", /^\d{4}-\d{2}-\d{2}$/.test(F.확인일 || ""));
+  T("도구가 4종이 아니다", Array.isArray(F.도구) && F.도구.length === 4);
+  const 이름들 = F.도구.map((c) => c.이름).join(",");
+  T(`도구 이름·순서가 샘플(Supabase→Vercel→OMC→DevTools)과 다르다 (${이름들})`, 이름들 === "Supabase 플러그인,Vercel 플러그인,Oh My Claude Code,Chrome DevTools MCP");
+  for (const [이름, 저장소, 라, 명령] of [
+    ["Supabase 플러그인", "supabase-community/supabase-plugin", "MIT", "/plugin install supabase@claude-plugins-official"],
+    ["Vercel 플러그인", "vercel/vercel-plugin", "Apache-2.0", "/plugin install vercel@claude-plugins-official"],
+    ["Oh My Claude Code", "Yeachan-Heo/oh-my-claudecode", "MIT", "/plugin install oh-my-claudecode"],
+    ["Chrome DevTools MCP", "ChromeDevTools/chrome-devtools-mcp", "Apache-2.0", "claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest"],
+  ]) {
+    const c = 도구(이름);
+    T(`${이름} 칸이 없다`, !!c);
+    T(`${이름} 저장소가 실측(${저장소})과 다르다`, c?.저장소 === 저장소);
+    T(`${이름} 라이선스가 실측(${라})과 다르다`, c?.라이선스 === 라);
+    T(`${이름} 공식 설치 명령(${명령})이 없다`, (c?.명령 || []).includes(명령));
+    T(`${이름} 별에 숫자가 없다`, Number.isFinite(c?.별));
+  }
+  T("OMC 설치가 두 줄(마켓 추가 → 설치)이 아니다", 도구("Oh My Claude Code").명령.length === 2 && 도구("Oh My Claude Code").명령[0].startsWith("/plugin marketplace add "));
+  T("OMC 에이전트 수 근거가 없다", /19명/.test(도구("Oh My Claude Code").하는일));
+  T("Supabase 읽기전용 줄에 read_only=true 가 없다", /read_only=true/.test(도구("Supabase 플러그인").읽기전용));
+  T("Supabase 읽기전용 줄에 project_ref 가 없다", /project_ref=/.test(도구("Supabase 플러그인").읽기전용));
+  T("Supabase 주의가 「읽기전용 표시 없음」을 말하지 않는다", /read_only 가 없다/.test(도구("Supabase 플러그인").주의));
+  T("귀속에 제휴 관계 없음이 없다", /제휴 관계가 없습니다/.test(F.귀속?.말 || ""));
+  T("토큰 안내가 없다", /문맥/.test(F.토큰 || ""));
+  T("확인 못한 것 칸이 비었다", Array.isArray(F.확인_못한것) && F.확인_못한것.length >= 2);
+
+  /* ② 문서 */
+  const 문서 = {};
+  for (const n of ["skill/SKILL.md", "README.md", "안내스킬.md"]) {
+    try { 문서[n] = readFileSync(join(HERE, n), "utf8"); } catch { 나쁨.push(`${n} 을 못 읽는다`); 문서[n] = ""; }
+  }
+  const S = 문서["skill/SKILL.md"];
+  T("SKILL.md name 이 폴더 이름과 다르다", new RegExp(`^name:\\s*${스킬이름}\\s*$`, "m").test(S));
+  T("SKILL.md 에 덮어쓰기 표식이 없다", S.includes(표식));
+  for (const [말, 뜻] of [
+    ["/plugin install supabase@claude-plugins-official", "Supabase 설치 줄"],
+    ["/plugin install vercel@claude-plugins-official", "Vercel 설치 줄"],
+    ["/plugin marketplace add https://github.com/Yeachan-Heo/oh-my-claudecode", "OMC 마켓 추가 줄"],
+    ["/plugin install oh-my-claudecode", "OMC 설치 줄"],
+    ["claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest", "DevTools 설치 줄"],
+    ["read_only=true", "읽기전용 파라미터"],
+    ["agents/claude/.mcp.json", "플러그인 번들 MCP 에 read_only 가 없다는 근거"],
+    ["프롬프트 인젝션", "공식 문서의 위험 안내"],
+    ["매 호출 문맥에 실린다", "토큰 비용"],
+    ["--slim", "DevTools 가벼운 모드"],
+    ["모델에 노출", "크롬 내용 노출"],
+    ["VERCEL_PLUGIN_TELEMETRY=off", "Vercel 텔레메트리 끄기"],
+    ["한 번에 붙이면 실패", "OMC 두 줄 주의"],
+    ["제휴 관계가 없다", "귀속"],
+    ["다시 켜", "재시작 안내"],
+    ["reborn-vibe4 --check", "붙은 것 확인법"],
+  ]) {
+    T(`SKILL.md 가 「${뜻}」을 말하지 않는다`, S.includes(말));
+  }
+  for (const [n, t] of Object.entries(문서)) {
+    for (const 금 of ["클로드킷", "자비스 풀스택", "자비스풀스택", "158,000", "58,000", "일감 진단"]) {
+      T(`${n} 이 「${금}」 을 말한다`, !t.includes(금));
+    }
+    for (const 금 of ["평생 무료", "완전 무료", "공식 파트너", "월 20달러"]) {
+      T(`${n} 이 확인 안 한 말 「${금}」 을 한다`, !t.includes(금));
+    }
+    T(`${n} 이 제휴 관계가 있다고 말한다`, !/제휴\s*관계(가|를)?\s*(있|입니다|이다|맺)/.test(t));
+  }
+
+  /* ③ 패키지 */
+  try {
+    const PK = JSON.parse(readFileSync(join(HERE, "package.json"), "utf8"));
+    T("package.json 이름이 reborn-vibe4 가 아니다", PK.name === "reborn-vibe4");
+    T("bin 이 install.mjs 를 가리키지 않는다", PK.bin?.["reborn-vibe4"] === "install.mjs");
+    T("package.json files 에 우리 파일 말고 다른 것이 있다", JSON.stringify(PK.files) === JSON.stringify(["install.mjs", "tail.mjs", "skill/", "README.md", "안내스킬.md"]));
+    T("homepage 에 utm_campaign=vibe4 가 없다", String(PK.homepage).includes("utm_campaign=vibe4"));
+    const 스킬파일 = readdirSync(join(HERE, "skill"));
+    T(`skill/ 에 SKILL.md·facts.json 말고 다른 파일이 있다 (${스킬파일.join(", ")})`, 스킬파일.sort().join(",") === "SKILL.md,facts.json");
+  } catch (e) { 나쁨.push("package.json 을 못 읽는다 — " + e.message); }
+
+  /* ④ 설치기가 남의 명령을 돌리지 않는다 — 자기 소스를 본다(낱말은 쪼개서 적는다: 이 줄이 걸리지 않게) */
+  const 자기 = readFileSync(이파일, "utf8");
+  for (const 금 of ["child" + "_process", "exec" + "Sync", "spa" + "wn(", "exec" + "File"]) {
+    T(`설치기가 「${금}」 을 쓴다 — 남의 명령을 돌리지 않는다`, !자기.includes(금));
+  }
+
+  /* ⑤ --check 점검 — 가짜 집으로 양방향 */
+  const 임시들 = [];
+  const 원래코드 = process.exitCode;
+  const 집만들기 = (이름, 파일들) => {
+    const 집 = mkdtempSync(join(tmpdir(), `reborn-vibe4-${이름}-`));
+    임시들.push(집);
+    for (const [상대, 값] of Object.entries(파일들)) {
+      const 경로 = join(집, ...상대.split("/"));
+      mkdirSync(dirname(경로), { recursive: true });
+      writeFileSync(경로, typeof 값 === "string" ? 값 : JSON.stringify(값));
+    }
+    return 집;
+  };
+  const 빈폴더 = mkdtempSync(join(tmpdir(), "reborn-vibe4-cwd-"));
+  임시들.push(빈폴더);
+  const 플 = (...키) => ({ version: 2, plugins: Object.fromEntries(키.map((k) => [k, [{ scope: "user" }]])) });
+  try {
+    /* 5-1 빈 집 — 넷 다 없어야 한다(「항상 ✓」인 검사기를 잡는다) */
+    const 빈 = 점검(집만들기("empty", {}), 빈폴더);
+    T("빈 집인데 설치됨으로 나온다", Object.values(빈.결과).every((r) => r.설치 === false));
+    T("빈 집에서 깨진 파일이 보고됐다", 빈.깨진.length === 0);
+
+    /* 5-2 셋을 깐 집 */
+    const 셋 = 점검(집만들기("three", {
+      ".claude/plugins/installed_plugins.json": 플("supabase@claude-plugins-official", "vercel@claude-plugins-official", "oh-my-claudecode@omc"),
+    }), 빈폴더);
+    T("Supabase 플러그인을 못 찾는다", 셋.결과["Supabase 플러그인"].설치 === true && 셋.결과["Supabase 플러그인"].플러그인 === true);
+    T("Vercel 플러그인을 못 찾는다", 셋.결과["Vercel 플러그인"].설치 === true);
+    T("OMC 를 못 찾는다", 셋.결과["Oh My Claude Code"].설치 === true);
+    T("깔지 않은 DevTools 가 있다고 나온다", 셋.결과["Chrome DevTools MCP"].설치 === false);
+    T("Supabase 플러그인만 깔렸는데 읽기전용이 참/거짓으로 단정된다(null 이어야 한다)", 셋.결과["Supabase 플러그인"].읽기전용 === null);
+
+    /* 5-3 이름만 비슷한 것은 세지 않는다 */
+    const 비슷 = 점검(집만들기("similar", {
+      ".claude/plugins/installed_plugins.json": 플("vercel-deploy@somewhere", "supabase-tools@x", "oh-my-claudecode-extras@x", "chrome-devtools-mcp-lite@x"),
+    }), 빈폴더);
+    T("이름만 비슷한 플러그인을 센다", Object.values(비슷.결과).every((r) => r.설치 === false));
+
+    /* 5-4 MCP — DevTools 와 Supabase 읽기전용/쓰기 */
+    const 쓰기 = 점검(집만들기("mcp", {
+      ".claude.json": {
+        mcpServers: {
+          "chrome-devtools": { type: "stdio", command: "npx", args: ["chrome-devtools-mcp@latest"] },
+          supabase: { type: "http", url: "https://mcp.supabase.com/mcp?project_ref=abc" },
+        },
+      },
+    }), 빈폴더);
+    T("DevTools MCP 를 못 찾는다", 쓰기.결과["Chrome DevTools MCP"].설치 === true);
+    T("Supabase MCP 를 못 찾는다", 쓰기.결과["Supabase 플러그인"].MCP === true);
+    T("read_only 없는 Supabase MCP 가 읽기전용으로 나온다", 쓰기.결과["Supabase 플러그인"].읽기전용 === false);
+    const 읽 = 점검(집만들기("ro", {
+      ".claude.json": { mcpServers: { supabase: { type: "http", url: "https://mcp.supabase.com/mcp?project_ref=abc&read_only=true" } } },
+    }), 빈폴더);
+    T("read_only=true 가 있는데 쓰기로 나온다", 읽.결과["Supabase 플러그인"].읽기전용 === true);
+    const 거짓 = 점검(집만들기("ro2", {
+      ".claude.json": { mcpServers: { supabase: { type: "http", url: "https://mcp.supabase.com/mcp?project_ref=abc&read_only=false" } } },
+    }), 빈폴더);
+    T("read_only=false 가 읽기전용으로 나온다", 거짓.결과["Supabase 플러그인"].읽기전용 === false);
+    const 둘 = 점검(집만들기("ro3", {
+      ".claude.json": { mcpServers: {
+        a: { type: "http", url: "https://mcp.supabase.com/mcp?read_only=true" },
+        b: { type: "http", url: "https://mcp.supabase.com/mcp" },
+      } },
+    }), 빈폴더);
+    T("읽기전용 하나·쓰기 하나인데 읽기전용으로 나온다(하나라도 쓰기면 거짓)", 둘.결과["Supabase 플러그인"].읽기전용 === false);
+
+    /* 5-5 프로젝트 범위·현재 폴더 .mcp.json */
+    const 프로젝트집 = 점검(집만들기("proj", {
+      ".claude.json": { projects: { "C:/x": { mcpServers: { cdt: { command: "npx", args: ["-y", "chrome-devtools-mcp@latest", "--slim"] } } } } },
+    }), 빈폴더);
+    T("프로젝트 범위 MCP 를 못 찾는다", 프로젝트집.결과["Chrome DevTools MCP"].설치 === true);
+    const 폴더 = 집만들기("folder", { ".mcp.json": { mcpServers: { supabase: { type: "http", url: "https://mcp.supabase.com/mcp?read_only=true" } } } });
+    const 폴더점검 = 점검(집만들기("empty2", {}), 폴더);
+    T("현재 폴더 .mcp.json 을 못 읽는다", 폴더점검.결과["Supabase 플러그인"].MCP === true);
+
+    /* 5-6 깨진 JSON — 던지지 않고 「없음」으로 세고 알린다 */
+    let 던짐 = false, 깨짐;
+    try { 깨짐 = 점검(집만들기("broken", { ".claude.json": "{ 깨진 json", ".claude/plugins/installed_plugins.json": "[[" }), 빈폴더); } catch { 던짐 = true; }
+    T("깨진 JSON 에서 던진다", !던짐);
+    T("깨진 JSON 을 알리지 않는다", !던짐 && 깨짐.깨진.length === 2);
+    T("깨진 JSON 인데 설치됨으로 나온다", !던짐 && Object.values(깨짐.결과).every((r) => r.설치 === false));
+
+    /* 5-7 점검은 아무것도 쓰지 않는다 */
+    const 읽기집 = 집만들기("readonly", { ".claude.json": { mcpServers: {} }, ".claude/plugins/installed_plugins.json": 플("vercel@x") });
+    const 전목록 = readdirSync(읽기집, { recursive: true }).sort().join("|");
+    const 전시각 = statSync(join(읽기집, ".claude.json")).mtimeMs;
+    점검(읽기집, 빈폴더);
+    T("점검이 파일을 만들거나 지웠다", readdirSync(읽기집, { recursive: true }).sort().join("|") === 전목록);
+    T("점검이 파일을 고쳤다", statSync(join(읽기집, ".claude.json")).mtimeMs === 전시각);
+
+    /* 5-8 깔기 — 빈 집·재설치·이웃 보존·남의 스킬 보호 */
+    const 깔집 = mkdtempSync(join(tmpdir(), "reborn-vibe4-inst-"));
+    임시들.push(깔집);
+    const 밖 = 깔기(깔집, { 조용히: true });
+    T("임시 집에 깔기가 실패했다", !!밖 && existsSync(join(밖, "SKILL.md")) && existsSync(join(밖, "facts.json")));
+    T("안내 스킬이 vibe-coding-plugins 폴더가 아닌 곳에 깔렸다", !!밖 && 밖.endsWith(스킬이름));
+    T("두 번째 깔기(우리 표식 있음)가 막혔다", !!깔기(깔집, { 조용히: true }));
+    T("깔린 facts.json 이 원본과 다르다", readFileSync(join(밖, "facts.json"), "utf8") === readFileSync(join(HERE, "skill", "facts.json"), "utf8"));
+
+    const 이웃집 = mkdtempSync(join(tmpdir(), "reborn-vibe4-nb-"));
+    임시들.push(이웃집);
+    const 이웃 = join(이웃집, ".claude", "skills", "playwright-cli");
+    mkdirSync(이웃, { recursive: true });
+    writeFileSync(join(이웃, "SKILL.md"), "---\nname: playwright-cli\n---\n이웃 스킬");
+    const 전 = { 글: readFileSync(join(이웃, "SKILL.md"), "utf8"), 시각: statSync(join(이웃, "SKILL.md")).mtimeMs };
+    T("이웃 있는 집에 깔기가 실패했다", !!깔기(이웃집, { 조용히: true }));
+    const 후 = { 글: readFileSync(join(이웃, "SKILL.md"), "utf8"), 시각: statSync(join(이웃, "SKILL.md")).mtimeMs };
+    T("이웃 스킬 폴더가 바뀌었다", 전.글 === 후.글 && 전.시각 === 후.시각);
+
+    const 남 = mkdtempSync(join(tmpdir(), "reborn-vibe4-other-"));
+    임시들.push(남);
+    mkdirSync(join(남, ".claude", "skills", 스킬이름), { recursive: true });
+    writeFileSync(join(남, ".claude", "skills", 스킬이름, "SKILL.md"), "---\nname: someone-else\n---\n다른 사람 스킬");
+    T("남의 스킬을 덮어썼다", 깔기(남, { 조용히: true }) === false && readFileSync(join(남, ".claude", "skills", 스킬이름, "SKILL.md"), "utf8").includes("다른 사람"));
+  } catch (e) { 나쁨.push("시험이 던졌다 — " + e.message); }
+  finally {
+    for (const d of 임시들) rmSync(d, { recursive: true, force: true });
+    process.exitCode = 원래코드;
+  }
+
+  /* ⑥ 끝 한 칸 — 스킬팩 한 칸만. ★찍히는 글자만 본다(주석이 걸리는 오탐 방지) */
+  try {
+    const { TAIL: TT, 마지막: M, 링크: K } = await import("./tail.mjs");
+    const t = TT[퍼널];
+    T("tail.mjs 에 vibe4 칸이 없다", !!t);
+    const 찍히는글 = [...(t?.이음 || []), t?.제목, t?.한줄, M, K(퍼널)].join(" ");
+    for (const 금 of ["클로드킷", "자비스 풀스택", "158,000", "58,000", "일감 진단"]) {
+      T(`안내 한 칸이 「${금}」 을 말한다 — 무료 설치기는 스킬팩만 말한다`, !찍히는글.includes(금));
+    }
+    T("안내 한 칸에 스킬팩 값이 없다", 찍히는글.includes("8,900"));
+    T("스킬팩 링크에 utm_campaign=vibe4 가 없다", K(퍼널).includes("utm_campaign=vibe4") && K(퍼널).includes("/skillpack?"));
+  } catch (e) { 나쁨.push("tail.mjs 를 못 읽는다 — " + e.message); }
+
+  if (나쁨.length) {
+    console.log("✗ 자가시험 " + 나쁨.length + "건 / " + 건);
+    for (const n of 나쁨) console.log("   - " + n);
+    process.exit(1);
+  }
+  console.log(`✓ 자가시험 통과 — ${건}건 · 저장소·라이선스·공식 설치 명령 4종 · Supabase 읽기전용 · 문서 필수/금지어 · --check 양방향(빈 집·셋·이름만 비슷·MCP·읽기전용/쓰기·깨진 JSON·읽기만) · 남의 명령 안 돌림 · 임시 집 설치·재설치·이웃 보존·남의 스킬 보호 · 안내 한 칸`);
+}
+
+/* ══ ══ */
+/* ★진입점 가드를 두지 않는다 — npx 셈 경로가 가드와 안 맞으면 아무것도 안 하고 exit 0 으로 끝난다. */
+if (있나("--self-test")) {
+  await 자가시험();
+} else if (있나("--check")) {
+  점검보고();
+} else if (있나("--help") || 있나("-h")) {
+  console.log(`
+  ${C.진("reborn-vibe4")} — 바이브 코딩 전에 깔 플러그인 넷 안내 스킬
+
+    npx --yes reborn-vibe4              안내 스킬을 깐다 (~/.claude/skills/${스킬이름})
+    npx --yes reborn-vibe4 --check      이 PC 에 넷이 붙어 있는지 본다(파일만 읽는다)
+    npx --yes reborn-vibe4 --self-test  스스로 시험한다
+
+  Supabase · Vercel · Oh My Claude Code · Chrome DevTools MCP 는 각각 다른 회사·프로젝트가 만든 것이며
+  저희와 제휴 관계가 없습니다. 이 패키지는 그 넷을 깔지도 대신 실행하지도 않습니다. 사실 확인일 ${F.확인일}.
+`);
+} else {
+  const 됐다 = 깔기();
+  if (됐다) await 끝한칸();
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "reborn-vibe4",
+  "version": "1.0.0",
+  "description": "클로드 코드로 바이브 코딩을 시작하기 전에 깔 만한 플러그인 넷(Supabase 플러그인 · Vercel 플러그인 · Oh My Claude Code · Chrome DevTools MCP)의 공식 설치 명령을 한국어로 안내하는 클로드 코드 스킬을 깝니다. Supabase 플러그인이 묶어 온 MCP 에는 읽기전용 표시가 없다는 점(기본이 쓰기 가능)과 읽기전용으로 붙이는 법, 플러그인·MCP 가 문맥을 먹는다는 점을 먼저 말합니다. --check 는 이 PC 에 넷이 붙어 있는지 파일만 읽어 보여 줍니다. 넷은 각각 다른 회사·프로젝트가 만든 것이며 저희와 제휴 관계가 없고, 이 패키지는 넷을 깔지도 대신 실행하지도 않습니다.",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "plugin",
+    "mcp",
+    "supabase",
+    "vercel",
+    "oh-my-claudecode",
+    "chrome-devtools",
+    "vibe-coding",
+    "skill",
+    "korean"
+  ],
+  "homepage": "https://rebornlabs.kr/vibe4?utm_source=installer&utm_medium=cli&utm_campaign=vibe4",
+  "bugs": {
+    "url": "https://mobility.rebornlabs.kr/cs"
+  },
+  "license": "MIT",
+  "author": "REBORN LABS",
+  "type": "module",
+  "bin": {
+    "reborn-vibe4": "install.mjs"
+  },
+  "files": [
+    "install.mjs",
+    "tail.mjs",
+    "skill/",
+    "README.md",
+    "안내스킬.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node install.mjs --self-test",
+    "check": "node install.mjs --check"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/skill/SKILL.md

@@ -0,0 +1,143 @@
+---
+name: vibe-coding-plugins
+description: 클로드 코드로 바이브 코딩을 시작하기 전에 깔 만한 플러그인 넷(Supabase 플러그인 · Vercel 플러그인 · Oh My Claude Code · Chrome DevTools MCP)의 공식 설치 명령과, 붙이기 전에 알아야 할 위험(Supabase 쓰기 권한 · 토큰 비용 · 크롬 내용 노출)을 말한다. 사용자가 "바이브 코딩 플러그인", "클로드 코드 플러그인 추천", "supabase 플러그인", "vercel 플러그인", "oh my claude code", "chrome devtools mcp", "/plugin install", "claude mcp add", "플러그인 뭐 깔아야 해", "DB 지울까 무서워" 같은 이야기를 할 때 쓴다. 실제 설치·DB 작업·배포는 이 스킬이 아니라 사용자가 붙인 플러그인이 한다.
+---
+
+<!-- reborn-vibe4:guide — 이 표식이 있는 폴더만 설치기가 덮어쓴다 -->
+
+# 바이브 코딩 전에 깔 플러그인 넷 — 붙이기 전에 알아야 할 것
+
+Supabase · Vercel · Oh My Claude Code · Chrome DevTools MCP 는 **각각 다른 회사·프로젝트**가 만든 것이며
+**리본랩스와 제휴 관계가 없다.** 이 스킬은 그 넷을 깔지도, 대신 실행하지도 않는다 —
+**공식 설치 명령과, 붙이기 전에 알아야 할 것**만 말한다.
+
+사실은 전부 같은 폴더의 `facts.json` 에 있다(확인일 2026-10-01). **거기 없는 건 말하지 않는다.**
+
+---
+
+## 0. 먼저 — 지금 뭐가 붙어 있나 본다
+
+```
+npx --yes reborn-vibe4 --check
+```
+
+붙은 것은 `✓`, 없는 것은 `✗` 로 나온다. **이미 붙은 걸 또 붙이자고 하지 않는다.**
+(`--check` 는 파일만 읽는다 — 아무것도 깔거나 고치지 않는다.)
+
+---
+
+## 1. 넷이 서로 다른 몫을 한다
+
+| | 도구 | 몫 |
+|---|---|---|
+| 1 | **Supabase 플러그인** | DB — SQL · 마이그레이션 · 타입 생성 · 보안 점검 |
+| 2 | **Vercel 플러그인** | 배포 — 빌드 상태 · 로그 · 환경변수 · 도메인 |
+| 3 | **Oh My Claude Code** | 팀 — 역할 나뉜 에이전트 19명을 `/team` 으로 굴린다 |
+| 4 | **Chrome DevTools MCP** | 눈 — 실제 크롬의 콘솔 · 네트워크 · 스크린샷 · 성능 |
+
+---
+
+## 2. 설치 명령 — 사용자가 보고 직접 친다
+
+`/` 로 시작하는 줄은 **클로드 코드 안에서** 치는 슬래시 명령이고, `claude mcp add` 는 **터미널**(또는 `!` 뒤)에서 친다.
+OMC 는 두 줄을 **한 번에 붙이면 실패**한다 — 하나씩 입력한다.
+
+### ① Supabase 플러그인 (`supabase-community/supabase-plugin` · MIT)
+
+```
+/plugin install supabase@claude-plugins-official
+```
+
+### ② Vercel 플러그인 (`vercel/vercel-plugin` · Apache-2.0)
+
+```
+/plugin install vercel@claude-plugins-official
+```
+
+저장소 README 가 안내하는 다른 길: `npx plugins add vercel/vercel-plugin` (Node 18+ · Bun 필요). 같은 것을 두 길로 까는 것이니 하나만 쓴다.
+
+### ③ Oh My Claude Code (`Yeachan-Heo/oh-my-claudecode` · MIT)
+
+```
+/plugin marketplace add https://github.com/Yeachan-Heo/oh-my-claudecode
+```
+
+```
+/plugin install oh-my-claudecode
+```
+
+호출은 `/team 3:executor "fix all TypeScript errors"` 모양이다. 에이전트 19명은 저장소 `agents/` 폴더의 파일을 오늘 직접 센 값이다.
+
+### ④ Chrome DevTools MCP (`ChromeDevTools/chrome-devtools-mcp` · Apache-2.0)
+
+```
+claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest
+```
+
+Node.js LTS 와 최신 안정판 크롬이 필요하다. 스킬까지 같이 받는 플러그인판은 `facts.json` 의 `다른길`.
+
+깔고 나면 클로드 코드를 **다시 켜거나** `/reload-plugins` 를 친다.
+
+---
+
+## 3. ★★Supabase 는 쓰기 권한부터 막는다
+
+**플러그인이 묶어 온 MCP 설정에는 `read_only` 가 없다** (저장소 `agents/claude/.mcp.json` 을 직접 확인).
+즉 기본이 **쓰기 가능**이다 — 클로드가 잘못 판단하면 테이블을 지우고 바꿀 수 있다.
+
+Supabase 공식 문서가 권하는 방식은 URL 파라미터다:
+
+| 파라미터 | 뜻 |
+|---|---|
+| `read_only=true` | 모든 쿼리를 읽기전용 Postgres 사용자로 실행 |
+| `project_ref=<id>` | 한 프로젝트로 한정(계정 단위 도구가 꺼진다) |
+| `features=<그룹>` | 필요한 도구 그룹만 켠다 |
+
+읽기전용으로 따로 붙이는 줄:
+
+```
+claude mcp add --scope project --transport http supabase "https://mcp.supabase.com/mcp?project_ref=<프로젝트ID>&read_only=true"
+```
+
+공식 문서는 **프로덕션 프로젝트**에는 project_ref 한정 · read_only · features 제한을 권하고, 프롬프트 인젝션 위험을 따로 적는다.
+쓰기가 꼭 필요하면 **개발용 프로젝트**에서만 연다. 쓰기를 막으려는 사람은 플러그인의 번들 MCP 에 기대지 말고 위 한 줄만 쓰는 쪽이 확실하다.
+
+---
+
+## 4. ★토큰 비용 — 넷을 다 켜지 않는다
+
+MCP 서버와 플러그인은 **도구 스키마·스킬 설명이 쓰든 안 쓰든 매 호출 문맥에 실린다.**
+Chrome DevTools MCP 는 도구가 59개다(공식 문서의 도구 제목 수) — 기본 브라우저 작업만 필요하면 문서의 `--slim` 모드가 있다.
+**지금 일에 필요한 것만 켜고, 안 쓰는 것은 `/plugin` 이나 `/mcp` 에서 끈다.**
+
+---
+
+## 5. 그 밖에 알아 둘 것
+
+- **Chrome DevTools MCP**: 연결된 크롬의 내용이 모델에 노출된다(README Disclaimers). 모델에 보이면 안 되는 개인·민감 정보는 그 크롬에 띄우지 않는다.
+- **Vercel 플러그인**: 텔레메트리가 기본 켜짐(끄기 `VERCEL_PLUGIN_TELEMETRY=off`), 훅이 같이 설치된다.
+- **OMC**: README 가 CI 같은 무인 환경에서는 `/team` 같은 슬래시 명령에 기대지 말라고 적는다.
+
+---
+
+## 6. 붙었는지 확인하고, 안 되면 지운다
+
+```
+npx --yes reborn-vibe4 --check     이 PC 에 넷이 붙어 있는지 (파일만 읽는다)
+claude mcp list                     MCP 가 connected 인지
+claude mcp remove <이름>            MCP 되돌리기
+/plugin                             플러그인 목록·끄기·지우기
+```
+
+**「설치했는데 안 뜬다」** 는 보통 이렇다: ① 클로드 코드를 다시 안 켰다 ② 슬래시 명령을 터미널에 쳤다(`claude mcp add` 는 터미널, `/plugin …` 은 클로드 코드 안) ③ OMC 두 줄을 한 번에 붙였다.
+
+---
+
+## 7. 확인하지 않은 것 (말하지 않는다)
+
+- Vercel 의 「deploy my app」 같은 자연어가 어느 스킬로 이어지는지
+- 이 PC 에서 넷을 **실제로 깔아 보지는 않았다** — 명령은 각 공식 문서·README 원문 기준이다
+- Vercel 플러그인의 릴리스 태그(저장소에 릴리스가 없다)
+- 각 서비스의 요금 — 바뀌는 값이라 일부러 안 적었다
+
+모르면 모른다고 말한다. 지어내서 말하지 않는다.

package/skill/facts.json

@@ -0,0 +1,68 @@
+{
+  "_doc": "퍼널 vibe4 가 말하는 모든 사실의 원장. 스킬·README·설치기는 여기서만 값을 읽는다. 여기에 없는 수치·값은 말하지 않는다. 실측은 GitHub API · 각 저장소 README/LICENSE · Anthropic 공식 마켓플레이스 marketplace.json · supabase.com 공식 문서로 2026-10-01 에 했다.",
+  "확인일": "2026-10-01",
+  "공식마켓": "claude-plugins-official",
+  "도구": [
+    {
+      "번호": 1,
+      "이름": "Supabase 플러그인",
+      "저장소": "supabase-community/supabase-plugin",
+      "주소": "https://github.com/supabase-community/supabase-plugin",
+      "라이선스": "MIT",
+      "별": 28,
+      "플러그인": "supabase",
+      "명령": ["/plugin install supabase@claude-plugins-official"],
+      "하는일": "SQL·마이그레이션·타입 생성·보안 점검 같은 슈파베이스 작업을 클로드 코드가 직접 한다(스킬 + 공식 MCP).",
+      "읽기전용": "claude mcp add --scope project --transport http supabase \"https://mcp.supabase.com/mcp?project_ref=<프로젝트ID>&read_only=true\"",
+      "읽기전용근거": "supabase.com/docs/guides/getting-started/mcp 의 URL 파라미터 표 — read_only=true 는 모든 쿼리를 읽기전용 Postgres 사용자로 실행, project_ref 는 한 프로젝트로 한정",
+      "주의": "플러그인이 묶어 온 MCP 설정(agents/claude/.mcp.json)에는 read_only 가 없다 — 기본이 쓰기 가능이다."
+    },
+    {
+      "번호": 2,
+      "이름": "Vercel 플러그인",
+      "저장소": "vercel/vercel-plugin",
+      "주소": "https://github.com/vercel/vercel-plugin",
+      "라이선스": "Apache-2.0",
+      "별": 295,
+      "플러그인": "vercel",
+      "명령": ["/plugin install vercel@claude-plugins-official"],
+      "다른길": "npx plugins add vercel/vercel-plugin",
+      "하는일": "배포·빌드 상태·로그·환경변수·도메인 같은 Vercel 작업을 클로드 코드 안에서 한다. 저장소에 deploy 명령 파일이 있다.",
+      "주의": "텔레메트리가 기본 켜져 있다(끄기 VERCEL_PLUGIN_TELEMETRY=off). 훅이 함께 설치된다."
+    },
+    {
+      "번호": 3,
+      "이름": "Oh My Claude Code",
+      "저장소": "Yeachan-Heo/oh-my-claudecode",
+      "주소": "https://github.com/Yeachan-Heo/oh-my-claudecode",
+      "라이선스": "MIT",
+      "별": 39505,
+      "플러그인": "oh-my-claudecode",
+      "명령": ["/plugin marketplace add https://github.com/Yeachan-Heo/oh-my-claudecode", "/plugin install oh-my-claudecode"],
+      "명령메모": "README 가 두 줄을 한 번에 붙이면 실패하니 하나씩 입력하라고 적는다.",
+      "하는일": "역할이 나뉜 에이전트 19명(저장소 agents/ 폴더 .md 19개를 센 값)을 팀으로 굴린다. 호출은 /team.",
+      "호출": "/team 3:executor \"fix all TypeScript errors\"",
+      "주의": "README: 무인 환경(CI)에서는 /team 같은 슬래시 명령에 기대지 말 것."
+    },
+    {
+      "번호": 4,
+      "이름": "Chrome DevTools MCP",
+      "저장소": "ChromeDevTools/chrome-devtools-mcp",
+      "주소": "https://github.com/ChromeDevTools/chrome-devtools-mcp",
+      "라이선스": "Apache-2.0",
+      "별": 52833,
+      "플러그인": "chrome-devtools-mcp",
+      "명령": ["claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest"],
+      "다른길": "/plugin marketplace add ChromeDevTools/chrome-devtools-mcp  다음  /plugin install chrome-devtools-mcp@chrome-devtools-plugins",
+      "하는일": "클로드 코드가 실제 크롬을 열어 콘솔·네트워크·스크린샷·성능 추적을 직접 본다.",
+      "주의": "크롬 인스턴스의 내용이 모델에 노출된다(README Disclaimers). 도구가 59개라 스키마가 문맥에 실린다 — 기본 작업만이면 --slim 모드가 있다."
+    }
+  ],
+  "토큰": "MCP 서버와 플러그인은 도구 스키마·스킬 설명이 쓰든 안 쓰든 매 호출 문맥에 실린다. 넷을 다 켜기보다 지금 일에 필요한 것만 켠다.",
+  "귀속": { "말": "넷은 각각 다른 회사·프로젝트가 만든 것이며 리본랩스와 제휴 관계가 없습니다." },
+  "확인_못한것": [
+    "Vercel 의 「deploy my app」 같은 자연어가 어느 스킬로 이어지는지",
+    "이 PC 에서 넷을 실제로 깔아 본 것은 아니다 — 명령은 각 공식 문서·README 원문 기준",
+    "Vercel 플러그인의 릴리스 태그(저장소에 릴리스가 없다)"
+  ]
+}

package/tail.mjs

@@ -0,0 +1,25 @@
+/**
+ * 「끝난 뒤 한 칸」 문안 — 정본은 `skillpack/tail_copy.mjs` 다.
+ * 사본이 여기 있는 이유는 하나뿐이다: npm 패키지는 폴더 밖을 import 할 수 없다.
+ * 고칠 일이 생기면 정본을 먼저 고치고 여기로 옮긴다. 반대로 하지 마라.
+ *
+ * 규율: ① 끝난 뒤 딱 한 칸 · ② 못 깔았으면 안 띄운다 · ③ 파일을 안 남긴다
+ *       ④ 고지 블록 금지 · ⑤ 첫 줄은 방금 한 일에서 이어져야 한다
+ * ★무료 설치기는 스킬팩 한 칸만 말한다(2026-08-24 전략). 그 다음 칸은 구매 이후다.
+ */
+/* ★맨 주소를 상수로 내놓지 않는다 — 조립해서만 내보낸다(utm 이 빠진 채 나가지 않게). */
+const 랜딩경로 = "/skillpack";
+export const 링크 = (퍼널) => `https://rebornlabs.kr${랜딩경로}?utm_source=installer&utm_medium=cli&utm_campaign=${퍼널}`;
+
+export const TAIL = {
+  vibe4: {
+    이음: [
+      "방금 한 일은 **바이브 코딩 전에 깔 플러그인 넷의 공식 설치 명령과 주의점을 한국어로 클로드 코드에 넣은 것**입니다 — Supabase 는 쓰기 권한부터 막는 법까지.",
+      "넷은 각각 다른 회사의 오픈소스라 대신 깔지 않았고 우리는 제휴 관계가 없습니다. 명령은 공식 문서 그대로 위에 적어 두었습니다.",
+    ],
+    제목: "리본랩스 스킬팩",
+    한줄: "같은 방식으로 골라 담은 48종을 한 줄로. 8,900원",
+  },
+};
+
+export const 마지막 = "목록과 직접 까는 명령까지 그 페이지에 그대로 적어 두었습니다. 안 사셔도 됩니다.";

package//354/225/210/353/202/264/354/212/244/355/202/254.md

@@ -0,0 +1,48 @@
+# 바이브 코딩 플러그인 넷 — 안내 스킬 사용법
+
+클로드 코드로 바이브 코딩을 시작하기 전에 깔 만한 **Supabase 플러그인 · Vercel 플러그인 · Oh My Claude Code · Chrome DevTools MCP** 의
+공식 설치 명령과, 붙이기 전에 알아야 할 것을 먼저 말해 주는 안내 스킬입니다.
+
+```
+npx --yes reborn-vibe4            # 안내 스킬을 깐다
+npx --yes reborn-vibe4 --check    # 이 PC 에 넷이 붙어 있는지 본다 (파일만 읽는다)
+```
+
+깔리는 자리 `~/.claude/skills/vibe-coding-plugins` · 사실 원장 `skill/facts.json`(확인일 2026-10-01).
+
+★**넷은 깔지도, 대신 실행하지도 않습니다.** 공식 명령을 보여 드리고 사용자가 보고 직접 칩니다.
+
+---
+
+## 먼저 아셔야 할 셋
+
+1. **Supabase 플러그인이 묶어 온 MCP 에는 `read_only` 가 없습니다.** 기본이 쓰기 가능입니다.
+   읽기전용으로 붙이는 줄(공식 문서의 URL 파라미터)을 스킬이 알려 줍니다.
+2. **플러그인과 MCP 는 안 써도 매 호출 문맥에 실립니다.** 넷을 다 켜지 말고 지금 일에 필요한 것만 켭니다.
+3. **Chrome DevTools MCP 는 연결된 크롬의 내용을 모델에 노출합니다.** 민감한 탭을 띄우지 않습니다.
+
+## 실측한 값 (2026-10-01)
+
+| 도구 | 저장소 | 라이선스 | 설치 |
+|---|---|---|---|
+| Supabase 플러그인 | supabase-community/supabase-plugin | MIT | `/plugin install supabase@claude-plugins-official` |
+| Vercel 플러그인 | vercel/vercel-plugin | Apache-2.0 | `/plugin install vercel@claude-plugins-official` |
+| Oh My Claude Code | Yeachan-Heo/oh-my-claudecode | MIT | `/plugin marketplace add https://github.com/Yeachan-Heo/oh-my-claudecode` → `/plugin install oh-my-claudecode` |
+| Chrome DevTools MCP | ChromeDevTools/chrome-devtools-mcp | Apache-2.0 | `claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest` |
+
+GitHub API · 각 저장소 README/LICENSE · Anthropic 공식 마켓플레이스 목록 · supabase.com 공식 문서로 직접 확인했습니다.
+이 PC 에서 넷을 실제로 깔아 본 것은 아닙니다.
+
+넷은 각각 다른 회사·프로젝트가 만든 것이며 **리본랩스와 제휴 관계가 없습니다.**
+이 안내 스킬과 설치기는 무료이며, 각 도구의 요금은 적지 않았습니다(바뀌는 값).
+
+---
+
+## 깔고 나서 이렇게 말해 보세요
+
+```
+바이브 코딩 전에 뭘 깔아야 해?
+supabase 플러그인 붙이는데 DB 를 지울까 봐 무서워
+이 PC 에 넷 중 뭐가 붙어 있어?
+OMC 설치 줄이 안 돼
+```