cx-skills 1.3.0 → 1.7.0

package/README.ko.md

@@ -39,8 +39,11 @@ npm install -g cx-skills
 # 수동 모드 — agent 직접 지정
 /cx-auto 3:codex "src/api, src/auth, src/payment 각각 리뷰"
 
-# 단일 에이전트 라우팅
-/cx-route executor "JWT 인증 미들웨어 구현" implement 300
+# Codex-only (Gemini 불필요)
+/cx-codex "리팩터링 + 리뷰"
+
+# Gemini-only (Codex 불필요)
+/cx-gemini "구현 + 문서화"
 ```
 
 끝입니다. `cli-route.sh`는 세션 시작 시 자동 설치됩니다.
@@ -64,10 +67,8 @@ npm install -g cx-skills
 |------|---------|------|
 | **cx-auto** (자동) | N (AI 결정) | 복합 작업 — AI가 분류 + 분해 |
 | **cx-auto** (수동) | N:agent | 직접 제어 — agent와 워커 수 지정 |
-| **cx-route** | 1 | 단일 작업 — 에이전트 하나, 프롬프트 하나 |
-| **bteam** | N Codex | 코드 중심 병렬 작업 |
-| **hteam** | Codex + Gemini + Claude | 혼합 작업 (코드 + UI + 테스트) |
-| **kteam** | N (Windows 안정화) | Windows 환경 Gemini 안정화 적용 |
+| **cx-codex** | N (Codex-only) | Gemini CLI 없는 환경 |
+| **cx-gemini** | N (Gemini-only) | Codex CLI 없는 환경 |
 
 ---
 
@@ -78,9 +79,10 @@ npm install -g cx-skills
 | 스킬 | 설명 | 예시 |
 |------|------|------|
 | **cx-auto** | 통합 병렬 오케스트레이터 | `/cx-auto "분석 + 구현 + 테스트"` |
-| **cx-route** | 단일 에이전트 CLI 라우팅 | `/cx-route executor "기능 구현"` |
+| **cx-codex** | Codex-only 오케스트레이터 (Gemini 불필요) | `/cx-codex "리팩터링 + 리뷰"` |
+| **cx-gemini** | Gemini-only 오케스트레이터 (Codex 불필요) | `/cx-gemini "구현 + 문서화"` |
 
-### CLI 커맨드 (`sc` 라우터 경유)
+### CLI 커맨드 (cx-auto 숏컷)
 
 | 커맨드 | 라우팅 대상 | 용도 |
 |--------|-----------|------|
@@ -93,16 +95,6 @@ npm install -g cx-skills
 | `/test` | Claude | 테스트 실행 |
 | `/explain` | Codex | 코드 설명 |
 
-[전체 커맨드 목록 →](skills/sc/SKILL.md)
-
-### 팀 오케스트레이션
-
-| 스킬 | 설명 |
-|------|------|
-| **bteam** | Codex 워커 기반 멀티 에이전트 팀 |
-| **hteam** | 하이브리드 팀 (Codex + Gemini + Claude) |
-| **kteam** | Windows 안정화 팀 변형 |
-
 ### 유틸리티
 
 | 스킬 | 설명 |
@@ -221,12 +213,23 @@ gemini -p "echo hello"
 
 ### CLI 없이 사용
 
-Codex/Gemini CLI가 없어도 cx-skills는 동작합니다. 해당 CLI가 없으면 자동으로 **Claude 네이티브 에이전트로 fallback**합니다.
+Codex/Gemini CLI가 없어도 cx-skills는 동작합니다. `cli-route.sh` (v1.4+)가 자동으로 **fallback** 처리합니다:
 
 ```
-Codex 없음 → executor/debugger 등이 Claude Sonnet Agent로 실행
-Gemini 없음 → designer/writer 등이 Claude Sonnet Agent로 실행
-둘 다 없음 → 모든 작업이 Claude 네이티브로 실행 (비용 증가)
+Codex 없음  → Codex 에이전트를 Gemini로 리매핑 (있으면) 또는 Claude 네이티브
+Gemini 없음 → Gemini 에이전트를 Codex로 리매핑 (있으면) 또는 Claude 네이티브
+둘 다 없음  → 모든 작업이 Claude 네이티브로 실행 (비용 증가)
+```
+
+환경변수 또는 전용 스킬로 모드를 강제할 수도 있습니다:
+
+```bash
+# 환경변수
+CX_CLI_MODE=codex bash ~/.claude/scripts/cli-route.sh executor "작업" implement
+
+# 전용 스킬
+/cx-codex "작업"    # 모든 외부 CLI 작업을 Codex로 강제
+/cx-gemini "작업"   # 모든 외부 CLI 작업을 Gemini로 강제
 ```
 
 ---
@@ -263,6 +266,8 @@ head -6 ~/.claude/scripts/cli-route.sh | grep VERSION
 | v1.1 | stderr 분리, 출력 필터링, 타임아웃, MCP 프로필 지원 |
 | v1.2 | effort 동적 라우팅, bg/fg 모드, Opus 직접 수행, Gemini 모델 분기 |
 | v1.3 | context-file 지원, DAG 실행 연계 |
+| v1.4 | CX_CLI_MODE 지원 (codex-only/gemini-only), CLI 미설치 자동 fallback |
+| v1.5 | MCP 인벤토리 캐싱 — 실제 서버 가용성 기반 동적 힌트 생성 |
 
 ### 자동 업데이트
 
@@ -298,15 +303,16 @@ cx-skills/
 ├── hooks/
 │   └── hooks.json         # 라이프사이클 훅 (자동 설정)
 ├── scripts/
-│   ├── cli-route.sh       # CLI 라우팅 래퍼 (v1.3)
+│   ├── cli-route.sh       # CLI 라우팅 래퍼 (v1.5)
+│   ├── mcp-check.mjs      # MCP 인벤토리 캐시 (백그라운드)
 │   └── setup.mjs          # 세션 시작 시 자동 설치
-├── skills/                # 16개 스킬 (자동 발견)
+├── skills/
 │   ├── cx-auto/           # 통합 병렬 오케스트레이터
-│   ├── cx-route/          # 단일 에이전트 라우팅
-│   ├── sc/                # CLI 커맨드 라우터
-│   ├── bteam/             # Codex 팀
-│   ├── hteam/             # 하이브리드 팀
-│   └── ...
+│   ├── cx-codex/          # Codex-only 오케스트레이터
+│   ├── cx-gemini/         # Gemini-only 오케스트레이터
+│   ├── auto-verify/       # 실행 후 검증
+│   ├── manage-skills/     # 스킬 관리
+│   └── verify-implementation/  # 통합 검증
 ├── hud/
 │   └── hud-qos-status.mjs # 상태바 HUD
 ├── package.json

package/README.md

@@ -41,8 +41,11 @@ npm install -g cx-skills
 # Manual mode — specify agent directly
 /cx-auto 3:codex "review src/api, src/auth, src/payment"
 
-# Single agent routing
-/cx-route executor "implement JWT auth middleware" implement 300
+# Codex-only (no Gemini needed)
+/cx-codex "refactor + review"
+
+# Gemini-only (no Codex needed)
+/cx-gemini "implement + document"
 ```
 
 That's it. `cli-route.sh` is auto-installed on session start.
@@ -66,10 +69,8 @@ That's it. `cli-route.sh` is auto-installed on session start.
 |------|---------|----------|
 | **cx-auto** (auto) | N (AI decides) | Complex multi-part tasks — AI classifies + decomposes |
 | **cx-auto** (manual) | N:agent | Direct control — you choose agent and worker count |
-| **cx-route** | 1 | Single focused task — one agent, one prompt |
-| **bteam** | N Codex | Code-heavy parallel work |
-| **hteam** | Codex + Gemini + Claude | Mixed tasks (code + UI + testing) |
-| **kteam** | N (Windows stable) | Windows environments with Gemini stability fixes |
+| **cx-codex** | N (Codex-only) | Environments without Gemini CLI |
+| **cx-gemini** | N (Gemini-only) | Environments without Codex CLI |
 
 ---
 
@@ -80,9 +81,10 @@ That's it. `cli-route.sh` is auto-installed on session start.
 | Skill | Description | Example |
 |-------|-------------|---------|
 | **cx-auto** | Unified parallel orchestrator | `/cx-auto "analyze + implement + test"` |
-| **cx-route** | Single agent CLI routing | `/cx-route executor "implement feature"` |
+| **cx-codex** | Codex-only orchestrator (no Gemini) | `/cx-codex "refactor + review"` |
+| **cx-gemini** | Gemini-only orchestrator (no Codex) | `/cx-gemini "implement + document"` |
 
-### CLI Commands (via `sc` router)
+### CLI Commands (via cx-auto shortcuts)
 
 | Command | Routes To | Use Case |
 |---------|-----------|----------|
@@ -95,16 +97,6 @@ That's it. `cli-route.sh` is auto-installed on session start.
 | `/test` | Claude | Test execution |
 | `/explain` | Codex | Code explanation |
 
-[Full command list →](skills/sc/SKILL.md)
-
-### Team Orchestration
-
-| Skill | Description |
-|-------|-------------|
-| **bteam** | Multi-agent team with Codex workers |
-| **hteam** | Hybrid team (Codex + Gemini + Claude) |
-| **kteam** | Windows-stabilized team variant |
-
 ### Utilities
 
 | Skill | Description |
@@ -223,14 +215,25 @@ gemini -p "echo hello"
 
 ### Without External CLIs
 
-cx-skills works without Codex/Gemini. Missing CLIs automatically **fallback to Claude native agents**:
+cx-skills works without Codex/Gemini. Missing CLIs automatically **fallback** via `cli-route.sh` (v1.4+):
 
 ```
-No Codex → executor/debugger run as Claude Sonnet Agent
-No Gemini → designer/writer run as Claude Sonnet Agent
+No Codex  → Codex agents reroute to Gemini (if available) or Claude native
+No Gemini → Gemini agents reroute to Codex (if available) or Claude native
 Neither   → All tasks run via Claude native (higher cost)
 ```
 
+You can also force a specific mode via environment variable or dedicated skills:
+
+```bash
+# Environment variable
+CX_CLI_MODE=codex bash ~/.claude/scripts/cli-route.sh executor "task" implement
+
+# Dedicated skills
+/cx-codex "task"    # Forces all external CLI work to Codex
+/cx-gemini "task"   # Forces all external CLI work to Gemini
+```
+
 ---
 
 ## OMC Compatibility
@@ -276,6 +279,8 @@ Follows [Semantic Versioning](https://semver.org/):
 | v1.1 | stderr separation, output filtering, timeout, MCP profile support |
 | v1.2 | Dynamic effort routing, bg/fg modes, Opus oversight, Gemini model branching |
 | v1.3 | Context-file support, DAG execution integration |
+| v1.4 | CX_CLI_MODE support (codex-only/gemini-only), auto-fallback for missing CLIs |
+| v1.5 | MCP inventory caching — dynamic hints based on actual server availability |
 
 ### Auto-Update
 
@@ -298,15 +303,16 @@ cx-skills/
 ├── hooks/
 │   └── hooks.json         # Lifecycle hooks (auto-setup)
 ├── scripts/
-│   ├── cli-route.sh       # CLI routing wrapper (v1.3)
+│   ├── cli-route.sh       # CLI routing wrapper (v1.5)
+│   ├── mcp-check.mjs      # MCP inventory cache (background)
 │   └── setup.mjs          # Auto-install on session start
-├── skills/                # 16 skills (auto-discovered)
+├── skills/
 │   ├── cx-auto/           # Unified parallel orchestrator
-│   ├── cx-route/          # Single agent routing
-│   ├── sc/                # CLI command router
-│   ├── bteam/             # Codex team
-│   ├── hteam/             # Hybrid team
-│   └── ...
+│   ├── cx-codex/          # Codex-only orchestrator
+│   ├── cx-gemini/         # Gemini-only orchestrator
+│   ├── auto-verify/       # Post-execution verification
+│   ├── manage-skills/     # Skill management
+│   └── verify-implementation/  # Integration verification
 ├── hud/
 │   └── hud-qos-status.mjs # Status bar HUD
 ├── package.json

package/bin/cx-skills.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 // cx-skills CLI — setup, doctor, version
 import { copyFileSync, existsSync, readFileSync, mkdirSync, chmodSync, readdirSync } from "fs";
 import { join, dirname } from "path";
@@ -34,6 +34,32 @@ function which(cmd) {
   } catch { return null; }
 }
 
+function whichInShell(cmd, shell) {
+  const cmds = {
+    bash: `bash -c 'command -v ${cmd} 2>/dev/null'`,
+    cmd: `cmd /c where ${cmd} 2>nul`,
+    pwsh: `pwsh -NoProfile -c "(Get-Command ${cmd} -EA SilentlyContinue).Source"`,
+  };
+  const command = cmds[shell];
+  if (!command) return null;
+  try {
+    const result = execSync(command, {
+      encoding: "utf8",
+      timeout: 8000,
+      stdio: ["pipe", "pipe", "ignore"],
+    }).trim();
+    return result.split(/\r?\n/)[0] || null;
+  } catch { return null; }
+}
+
+function checkShellAvailable(shell) {
+  const cmds = { bash: "bash --version", cmd: "cmd /c echo ok", pwsh: "pwsh -NoProfile -c echo ok" };
+  try {
+    execSync(cmds[shell], { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "ignore"] });
+    return true;
+  } catch { return false; }
+}
+
 function getVersion(filePath) {
   try {
     const content = readFileSync(filePath, "utf8");
@@ -61,17 +87,57 @@ function syncFile(src, dst, label) {
     return true;
   }
 
-  if (srcVer && dstVer && srcVer !== dstVer) {
+  const srcContent = readFileSync(src, "utf8");
+  const dstContent = readFileSync(dst, "utf8");
+  if (srcContent !== dstContent) {
     copyFileSync(src, dst);
     try { chmodSync(dst, 0o755); } catch {}
-    ok(`${label}: 업데이트됨 (v${dstVer} → v${srcVer})`);
+    const verInfo = (srcVer && dstVer && srcVer !== dstVer)
+      ? `(v${dstVer} → v${srcVer})`
+      : srcVer ? `(v${srcVer}, 내용 변경)` : "(내용 변경)";
+    ok(`${label}: 업데이트됨 ${verInfo}`);
     return true;
   }
 
-  ok(`${label}: 최신 상태 ${dstVer ? `(v${dstVer})` : ""}`);
+  ok(`${label}: 최신 상태 ${srcVer ? `(v${srcVer})` : ""}`);
   return false;
 }
 
+// ── 크로스 셸 진단 ──
+
+function checkCliCrossShell(cmd, installHint) {
+  const shells = process.platform === "win32" ? ["bash", "cmd", "pwsh"] : ["bash"];
+  let anyFound = false;
+  let bashMissing = false;
+
+  for (const shell of shells) {
+    if (!checkShellAvailable(shell)) {
+      info(`${shell}: ${DIM}셸 없음 (건너뜀)${RESET}`);
+      continue;
+    }
+    const p = whichInShell(cmd, shell);
+    if (p) {
+      ok(`${shell}:  ${p}`);
+      anyFound = true;
+    } else {
+      fail(`${shell}:  미발견`);
+      if (shell === "bash") bashMissing = true;
+    }
+  }
+
+  if (!anyFound) {
+    info(`미설치 (선택사항) — ${installHint}`);
+    info("없으면 Claude 네이티브 에이전트로 fallback");
+    return 1;
+  }
+  if (bashMissing) {
+    warn("bash에서 미발견 — cli-route.sh 실행 불가");
+    info('→ ~/.bashrc에 추가: export PATH="$PATH:$APPDATA/npm"');
+    return 1;
+  }
+  return 0;
+}
+
 // ── 명령어 ──
 
 function cmdSetup() {
@@ -150,37 +216,26 @@ function cmdDoctor() {
     warn("미설치 (선택사항) — cx-skills setup으로 설치 가능");
   }
 
-  // 3. Codex CLI
+  // 3. Codex CLI (크로스 셸 체크)
   console.log(`${CYAN}[Codex CLI]${RESET}`);
-  const codexPath = which("codex");
-  if (codexPath) {
-    ok(`설치됨 — ${codexPath}`);
-    // API 키 확인
+  issues += checkCliCrossShell("codex", "npm install -g @openai/codex");
+  if (which("codex")) {
     if (process.env.OPENAI_API_KEY) {
       ok("OPENAI_API_KEY 설정됨");
     } else {
       warn("OPENAI_API_KEY 미설정 (Codex Pro 구독이면 불필요)");
     }
-  } else {
-    warn("미설치 (선택사항) — npm install -g @openai/codex");
-    info("없으면 Claude 네이티브 에이전트로 fallback");
-    issues++;
   }
 
-  // 4. Gemini CLI
+  // 4. Gemini CLI (크로스 셸 체크)
   console.log(`${CYAN}[Gemini CLI]${RESET}`);
-  const geminiPath = which("gemini");
-  if (geminiPath) {
-    ok(`설치됨 — ${geminiPath}`);
+  issues += checkCliCrossShell("gemini", "npm install -g @google/gemini-cli");
+  if (which("gemini")) {
     if (process.env.GEMINI_API_KEY) {
       ok("GEMINI_API_KEY 설정됨");
     } else {
       warn("GEMINI_API_KEY 미설정 (gemini auth login 필요할 수 있음)");
     }
-  } else {
-    warn("미설치 (선택사항) — npm install -g @google/gemini-cli");
-    info("없으면 Claude 네이티브 에이전트로 fallback");
-    issues++;
   }
 
   // 5. Claude Code
@@ -193,7 +248,33 @@ function cmdDoctor() {
     issues++;
   }
 
-  // 6. 플러그인 등록
+  // 6. 스킬 설치 상태
+  console.log(`${CYAN}[Skills]${RESET}`);
+  const skillsSrc = join(PKG_ROOT, "skills");
+  const skillsDst = join(CLAUDE_DIR, "skills");
+  if (existsSync(skillsSrc)) {
+    let installed = 0;
+    let total = 0;
+    const missing = [];
+    for (const name of readdirSync(skillsSrc)) {
+      if (!existsSync(join(skillsSrc, name, "SKILL.md"))) continue;
+      total++;
+      if (existsSync(join(skillsDst, name, "SKILL.md"))) {
+        installed++;
+      } else {
+        missing.push(name);
+      }
+    }
+    if (installed === total) {
+      ok(`${installed}/${total}개 설치됨`);
+    } else {
+      warn(`${installed}/${total}개 설치됨 — 미설치: ${missing.join(", ")}`);
+      info("cx-skills setup으로 동기화 가능");
+      issues++;
+    }
+  }
+
+  // 7. 플러그인 등록
   console.log(`${CYAN}[Plugin]${RESET}`);
   const pluginsFile = join(CLAUDE_DIR, "plugins", "installed_plugins.json");
   if (existsSync(pluginsFile)) {
@@ -208,6 +289,29 @@ function cmdDoctor() {
     info("플러그인 시스템 감지 안 됨 — npm 단독 사용");
   }
 
+  // 8. MCP 인벤토리
+  console.log(`${CYAN}[MCP Inventory]${RESET}`);
+  const mcpCache = join(CLAUDE_DIR, "cache", "mcp-inventory.json");
+  if (existsSync(mcpCache)) {
+    try {
+      const inv = JSON.parse(readFileSync(mcpCache, "utf8"));
+      ok(`캐시 존재 (${inv.timestamp})`);
+      if (inv.codex?.servers?.length) {
+        const names = inv.codex.servers.map(s => s.name).join(", ");
+        info(`Codex: ${inv.codex.servers.length}개 서버 (${names})`);
+      }
+      if (inv.gemini?.servers?.length) {
+        const names = inv.gemini.servers.map(s => s.name).join(", ");
+        info(`Gemini: ${inv.gemini.servers.length}개 서버 (${names})`);
+      }
+    } catch {
+      warn("캐시 파일 파싱 실패");
+    }
+  } else {
+    warn("캐시 없음 — 다음 세션 시작 시 자동 생성");
+    info(`수동: node ${join(PKG_ROOT, "scripts", "mcp-check.mjs")}`);
+  }
+
   // 결과
   console.log("");
   if (issues === 0) {
@@ -217,10 +321,185 @@ function cmdDoctor() {
   }
 }
 
+function cmdUpdate() {
+  console.log(`\n${BOLD}cx-skills update${RESET}\n`);
+
+  // 1. 설치 방식 감지
+  const pluginsFile = join(CLAUDE_DIR, "plugins", "installed_plugins.json");
+  let installMode = "unknown";
+  let pluginPath = null;
+
+  // 플러그인 모드 감지
+  if (existsSync(pluginsFile)) {
+    try {
+      const plugins = JSON.parse(readFileSync(pluginsFile, "utf8"));
+      for (const [key, entries] of Object.entries(plugins.plugins || {})) {
+        if (key.startsWith("cx-skills")) {
+          pluginPath = entries[0]?.installPath;
+          installMode = "plugin";
+          break;
+        }
+      }
+    } catch {}
+  }
+
+  // PKG_ROOT가 플러그인 캐시 내에 있으면 플러그인 모드
+  if (installMode === "unknown" && PKG_ROOT.includes(join(".claude", "plugins"))) {
+    installMode = "plugin";
+    pluginPath = PKG_ROOT;
+  }
+
+  // npm global 감지
+  if (installMode === "unknown") {
+    try {
+      const npmList = execSync("npm list -g cx-skills --depth=0", {
+        encoding: "utf8",
+        timeout: 10000,
+        stdio: ["pipe", "pipe", "ignore"],
+      });
+      if (npmList.includes("cx-skills")) installMode = "npm-global";
+    } catch {}
+  }
+
+  // npm local 감지
+  if (installMode === "unknown") {
+    const localPkg = join(process.cwd(), "node_modules", "cx-skills");
+    if (existsSync(localPkg)) installMode = "npm-local";
+  }
+
+  // git 저장소 직접 사용
+  if (installMode === "unknown" && existsSync(join(PKG_ROOT, ".git"))) {
+    installMode = "git-local";
+  }
+
+  info(`검색: ${installMode === "plugin" ? "플러그인" : installMode === "npm-global" ? "npm global" : installMode === "npm-local" ? "npm local" : installMode === "git-local" ? "git 로컬 저장소" : "알 수 없음"} 설치 감지`);
+
+  // 2. 설치 방식에 따라 업데이트
+  const oldVer = PKG.version;
+  let updated = false;
+
+  try {
+    switch (installMode) {
+      case "plugin": {
+        const gitDir = pluginPath || PKG_ROOT;
+        const result = execSync("git pull", {
+          encoding: "utf8",
+          timeout: 30000,
+          cwd: gitDir,
+        }).trim();
+        ok(`git pull — ${result}`);
+        updated = true;
+        break;
+      }
+      case "npm-global": {
+        const result = execSync("npm update -g cx-skills", {
+          encoding: "utf8",
+          timeout: 60000,
+          stdio: ["pipe", "pipe", "ignore"],
+        }).trim().split(/\r?\n/)[0];
+        ok(`npm update -g — ${result || "완료"}`);
+        updated = true;
+        break;
+      }
+      case "npm-local": {
+        const result = execSync("npm update cx-skills", {
+          encoding: "utf8",
+          timeout: 60000,
+          cwd: process.cwd(),
+          stdio: ["pipe", "pipe", "ignore"],
+        }).trim().split(/\r?\n/)[0];
+        ok(`npm update — ${result || "완료"}`);
+        updated = true;
+        break;
+      }
+      case "git-local": {
+        const result = execSync("git pull", {
+          encoding: "utf8",
+          timeout: 30000,
+          cwd: PKG_ROOT,
+        }).trim();
+        ok(`git pull — ${result}`);
+        updated = true;
+        break;
+      }
+      default:
+        fail("설치 방식을 감지할 수 없음");
+        info("수동 업데이트: cd <cx-skills-dir> && git pull");
+        return;
+    }
+  } catch (e) {
+    fail(`업데이트 실패: ${e.message}`);
+    return;
+  }
+
+  // 3. setup 재실행 (cli-route.sh, HUD, 스킬 동기화)
+  if (updated) {
+    console.log("");
+    // 업데이트 후 새 버전 읽기
+    let newVer = oldVer;
+    try {
+      const newPkg = JSON.parse(readFileSync(join(PKG_ROOT, "package.json"), "utf8"));
+      newVer = newPkg.version;
+    } catch {}
+
+    if (newVer !== oldVer) {
+      ok(`버전: v${oldVer} → v${newVer}`);
+    } else {
+      ok(`버전: v${oldVer} (이미 최신)`);
+    }
+
+    // setup 재실행
+    console.log("");
+    info("setup 재실행 중...");
+    cmdSetup();
+  }
+
+  console.log(`${GREEN}${BOLD}업데이트 완료${RESET}\n`);
+}
+
+function cmdList() {
+  console.log(`\n${BOLD}cx-skills list${RESET}\n`);
+
+  // 플러그인 내 스킬
+  const pluginSkills = join(PKG_ROOT, "skills");
+  const installedSkills = join(CLAUDE_DIR, "skills");
+
+  console.log(`${CYAN}[패키지 스킬]${RESET}`);
+  if (existsSync(pluginSkills)) {
+    for (const name of readdirSync(pluginSkills).sort()) {
+      const src = join(pluginSkills, name, "SKILL.md");
+      if (!existsSync(src)) continue;
+      const dst = join(installedSkills, name, "SKILL.md");
+      const installed = existsSync(dst);
+      const status = installed ? `${GREEN}✓${RESET}` : `${RED}✗${RESET}`;
+      console.log(`  ${status} ${BOLD}${name}${RESET}${installed ? "" : ` ${DIM}(미설치)${RESET}`}`);
+    }
+  }
+
+  // 설치된 스킬 중 패키지에 없는 것
+  console.log(`\n${CYAN}[사용자 스킬]${RESET}`);
+  const pkgNames = new Set(existsSync(pluginSkills) ? readdirSync(pluginSkills) : []);
+  let userCount = 0;
+  if (existsSync(installedSkills)) {
+    for (const name of readdirSync(installedSkills).sort()) {
+      if (pkgNames.has(name)) continue;
+      const skill = join(installedSkills, name, "SKILL.md");
+      if (!existsSync(skill)) continue;
+      console.log(`  ${DIM}●${RESET} ${name}`);
+      userCount++;
+    }
+  }
+  if (userCount === 0) info("없음");
+
+  console.log(`\n${DIM}설치 위치: ${installedSkills}${RESET}\n`);
+}
+
 function cmdVersion() {
   console.log(`cx-skills v${PKG.version}`);
   const routeVer = getVersion(join(CLAUDE_DIR, "scripts", "cli-route.sh"));
   if (routeVer) console.log(`cli-route.sh v${routeVer}`);
+  const hudVer = getVersion(join(CLAUDE_DIR, "hud", "hud-qos-status.mjs"));
+  if (hudVer) console.log(`hud-qos-status.mjs v${hudVer}`);
 }
 
 function cmdHelp() {
@@ -228,8 +507,10 @@ function cmdHelp() {
 ${BOLD}cx-skills${RESET} — CLI-first multi-model orchestrator for Claude Code
 
 ${CYAN}Usage:${RESET}
-  cx-skills setup     cli-route.sh와 HUD를 ~/.claude/에 설치/업데이트
-  cx-skills doctor    Codex/Gemini 연결 상태 진단
+  cx-skills setup     cli-route.sh, HUD, 스킬을 ~/.claude/에 설치/업데이트
+  cx-skills doctor    크로스 셸 CLI 진단 + MCP 인벤토리 확인
+  cx-skills update    최신 버전으로 업데이트
+  cx-skills list      설치된 스킬 목록 표시
   cx-skills version   버전 표시
   cx-skills help      이 도움말
 
@@ -248,6 +529,8 @@ const cmd = process.argv[2] || "help";
 switch (cmd) {
   case "setup":   cmdSetup(); break;
   case "doctor":  cmdDoctor(); break;
+  case "update":  cmdUpdate(); break;
+  case "list": case "ls": cmdList(); break;
   case "version": case "--version": case "-v": cmdVersion(); break;
   case "help": case "--help": case "-h": cmdHelp(); break;
   default: