cdsa-harness 0.4.0 → 0.5.1

package/README.md

@@ -11,8 +11,9 @@
 - **의존성 0개** — Node 18+ 내장 기능만(`fetch`/`readline`/`node:test`)
 - **실제 LLM 연결** — OpenAI · Anthropic(Claude) · OpenRouter, 또는 키 없이 `mock`
 - **교육 모드** — 매 반복마다 모델에 보내는 메시지 구성·추정 토큰·시스템 프롬프트, 실제 토큰 사용량/응답시간까지 그대로 표시
-- **플러그인** — `.cdsa/plugins/` 에 JS 파일을 두면 **새 도구가 자동 등록**되어 모델이 사용
-- **스킬** — `.cdsa/skills/` 에 마크다운을 두면 `/이름` 으로 부르는 **프롬프트 템플릿**
+- **MCP 클라이언트** — Claude Code·Cursor 등과 **공용 표준**. MCP 서버를 그대로 붙여 도구로 사용
+- **플러그인** — npm 으로 설치하거나 `.cdsa/plugins/` 에 JS 파일 → **도구 자동 등록**
+- **크로스포맷 스킬** — `.cdsa/skills/` 뿐 아니라 `.claude/commands/`·`.opencode/command/` 의 스킬도 인식
 
 ---
 
@@ -108,10 +109,27 @@ export default {
 };
 ```
 
+## 🔗 MCP — 다른 에이전트와 플러그인 공유
+
+[MCP](https://modelcontextprotocol.io) 서버는 Claude Code·Cursor·Zed 등이 함께 쓰는 **공용 도구 표준**입니다.
+`config.json` 에 **그 도구들과 동일한 형식**으로 적으면, 다른 에이전트용으로 만든 MCP 서버를 cdsa-harness 에서 그대로 씁니다.
+
+```json
+{
+  "mcpServers": {
+    "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path"] },
+    "github":     { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"], "env": { "GITHUB_TOKEN": "..." } }
+  }
+}
+```
+
+연결되면 각 도구가 `mcp__서버__도구` 이름으로 모델에 노출됩니다. `/mcp` 로 확인.
+(부수효과가 있을 수 있는 도구는 실행 전 승인을 받습니다 — `readOnlyHint` 가 있으면 자동.)
+
 ## 🎯 스킬 (프롬프트 템플릿)
 
-`.cdsa/skills/` 또는 `~/.cdsa_harness/skills/` 에 마크다운을 두면 `/파일명` 으로 실행됩니다.
-본문의 `$ARGUMENTS` 는 명령 뒤 텍스트로 치환됩니다. `/skills` 로 목록 확인.
+`.cdsa/skills/` 에 마크다운을 두면 `/파일명` 으로 실행됩니다. 본문의 `$ARGUMENTS`(또는 `{{args}}`)가 치환됩니다.
+**다른 에이전트의 스킬도 인식** — `.claude/commands/`, `.claude/skills/<이름>/SKILL.md`, `.opencode/command/` 등을 함께 읽습니다. `/skills` 로 목록 확인.
 
 ```markdown
 ---
@@ -165,6 +183,9 @@ node-cli/
 │   ├── llm.js            # OpenAI/Anthropic/OpenRouter + mock, 응답 정규화(토큰·지연)
 │   ├── tools.js          # 도구 + sandbox + diff
 │   ├── loop.js           # ⭐ Agent Loop + 교육용 이벤트(컨텍스트/되먹임)
+│   ├── mcp.js            # MCP 클라이언트(stdio JSON-RPC) — 다른 에이전트와 공용
+│   ├── plugins.js        # 파일·npm 플러그인 발견/로드
+│   ├── skills.js         # 크로스포맷 스킬 로더
 │   ├── session.js        # 세션 로그(JSONL)
 │   ├── banner.js / ui.js # 배너 · ANSI/박스/diff 렌더
 │   └── cli.js            # REPL + 교육 모드 렌더 + /setup

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cdsa-harness",
-  "version": "0.4.0",
-  "description": "AI 에이전트의 내부 동작을 단계별로 드러내는 교육용 터미널 하네스. OpenAI/Claude/OpenRouter + npm 으로 설치하는 플러그인(추가 도구)·스킬 확장.",
+  "version": "0.5.1",
+  "description": "AI 에이전트의 내부 동작을 단계별로 드러내는 교육용 터미널 하네스. OpenAI/Claude/OpenRouter + MCP(다른 에이전트와 공용) + npm 플러그인·크로스포맷 스킬.",
   "type": "module",
   "bin": {
     "cdsa-harness": "bin/cdsa-harness.js",

package/src/cli.js

@@ -17,6 +17,7 @@ import { execFileSync } from "node:child_process";
 
 import { AgentLoop, Step } from "./loop.js";
 import { LLMClient } from "./llm.js";
+import { connectMcpServers } from "./mcp.js";
 import { discoverNpmExtensions, loadPlugins } from "./plugins.js";
 import { SessionLog, sessionsDir } from "./session.js";
 import { loadSkills, renderSkill } from "./skills.js";
@@ -148,7 +149,7 @@ function printCompact(ev) {
   console.log(line);
 }
 
-function makeApproval(rl) {
+function makeApproval(ask) {
   return async (req) => {
     if (req.toolName === "write_file") {
       console.log(panel(renderDiff(req.diff || "(변경 미리보기 없음)"), {
@@ -160,12 +161,8 @@ function makeApproval(rl) {
     } else {
       console.log(panel([JSON.stringify(req.args)], { title: `🔐 ${req.toolLabel}`, color: "yellow" }));
     }
-    let ans = "";
-    try {
-      ans = (await rl.question(c.yellow("이 작업을 승인하시겠습니까? [y/N] "))).trim().toLowerCase();
-    } catch {
-      ans = "";
-    }
+    const raw = await ask(c.yellow("이 작업을 승인하시겠습니까? [y/N] "));
+    const ans = (raw || "").trim().toLowerCase();
     const approved = ans === "y" || ans === "yes";
     return { approved, reason: approved ? "" : "사용자가 거부했습니다." };
   };
@@ -218,7 +215,8 @@ function printHelp() {
         `  ${c.cyan("/teach")}    교육 모드 켜기/끄기(내부 과정 펼쳐보기)`,
         `  ${c.cyan("/context")}  지금 모델에 보내는 컨텍스트 들여다보기`,
         `  ${c.cyan("/skills")}   스킬 목록(.cdsa/skills 의 /명령들)`,
-        `  ${c.cyan("/plugins")}  플러그인 목록(.cdsa/plugins 의 추가 도구)`,
+        `  ${c.cyan("/plugins")}  플러그인 목록(파일·npm 추가 도구)`,
+        `  ${c.cyan("/mcp")}      연결된 MCP 서버/도구(다른 에이전트와 공용)`,
         `  ${c.cyan("/reset")}    대화/컨텍스트 초기화`,
         `  ${c.cyan("/config")}   현재 설정값`,
         `  ${c.cyan("/quit")}     종료 (Ctrl+D)`,
@@ -232,8 +230,14 @@ function printHelp() {
   );
 }
 
+// 붙여넣기한 키에 섞이기 쉬운 따옴표/공백/줄바꿈을 정리.
+function cleanKey(s) {
+  return (s || "").trim().replace(/^["']|["']$/g, "").trim();
+}
+
 // 대화형 연결 설정. 키는 환경변수가 있으면 그걸 우선 안내(파일 저장 안 함).
-async function runSetup(rl, cfg) {
+// ask 가 null 을 주면(Ctrl+C) 조용히 취소.
+async function runSetup(ask, cfg) {
   console.log(panel(
     [
       "어떤 AI 에 연결할까요? 번호를 입력하세요.",
@@ -244,8 +248,9 @@ async function runSetup(rl, cfg) {
     ],
     { title: "🔌 연결 설정 (/setup)", color: "cyan" }
   ));
-  const pick = (await rl.question(c.cyan("제공자 번호 [1-4]: "))).trim();
-  const provider = { "1": "openai", "2": "anthropic", "3": "openrouter", "4": "mock" }[pick];
+  const pickRaw = await ask(c.cyan("제공자 번호 [1-4] (취소: Enter): "));
+  if (pickRaw === null) return false;
+  const provider = { "1": "openai", "2": "anthropic", "3": "openrouter", "4": "mock" }[pickRaw.trim()];
   if (!provider) {
     console.log(c.yellow("취소했습니다."));
     return false;
@@ -257,27 +262,36 @@ async function runSetup(rl, cfg) {
   } else {
     const envName = ENV_KEYS[provider];
     const envVal = (process.env[envName] || "").trim();
+    let useExistingEnv = false;
     if (envVal) {
-      const useEnv = (await rl.question(c.cyan(`환경변수 ${envName} 에서 키를 찾았어요. 사용할까요? [Y/n] `))).trim().toLowerCase();
-      if (useEnv === "" || useEnv === "y" || useEnv === "yes") {
-        cfg.api_key = ""; // 환경변수 사용 → 파일엔 저장 안 함
-      } else {
-        const k = (await rl.question(c.cyan("API 키 붙여넣기(입력이 보일 수 있음): "))).trim();
-        cfg.api_key = k;
-      }
+      const useEnv = (await ask(c.cyan(`환경변수 ${envName} 에서 키를 찾았어요. 사용할까요? [Y/n] `))) || "";
+      useExistingEnv = ["", "y", "yes"].includes(useEnv.trim().toLowerCase());
+    }
+    if (useExistingEnv) {
+      cfg.api_key = ""; // 환경변수 사용 → 파일엔 저장 안 함
     } else {
-      console.log(c.dim(`(또는 종료 후 환경변수 ${envName} 에 키를 넣어두면 파일에 저장하지 않아도 됩니다)`));
-      const k = (await rl.question(c.cyan("API 키 붙여넣기(입력이 보일 수 있음): "))).trim();
-      cfg.api_key = k;
+      if (!envVal) console.log(c.dim(`(또는 종료 후 환경변수 ${envName} 에 키를 넣어두면 파일에 저장하지 않아도 됩니다)`));
+      const k = await ask(c.cyan("API 키 붙여넣기(붙여넣기 후 Enter): "));
+      if (k === null) {
+        console.log(c.yellow("취소했습니다."));
+        return false;
+      }
+      cfg.api_key = cleanKey(k);
     }
     const sugg = SUGGESTED_MODELS[provider] || [];
     const def = sugg[0] || "";
-    const m = (await rl.question(c.cyan(`모델 [${def}] (추천: ${sugg.join(", ")}): `))).trim();
-    cfg.model = m || def;
+    const note = provider === "openrouter" ? c.dim("  (OpenRouter 는 'provider/model' 형식)") : "";
+    const m = await ask(c.cyan(`모델 [${def}]${note}\n  추천: ${sugg.join(", ")}\n  > `));
+    if (m === null) {
+      console.log(c.yellow("취소했습니다."));
+      return false;
+    }
+    cfg.model = m.trim() || def;
   }
 
   const saved = saveConfig(cfg);
   console.log(c.green(`설정을 저장했습니다 → ${saved}`));
+  console.log(c.dim(`provider=${cfg.provider} · model=${cfg.model}`));
   if (!cfg.isReady()) console.log(c.yellow("⚠️ 아직 키가 없어 호출이 실패할 수 있어요. 환경변수나 /setup 으로 키를 넣어주세요."));
   return true;
 }
@@ -343,12 +357,32 @@ export async function main(argv = []) {
   if (args.noTeach) cfg.teach_mode = false;
 
   const rl = readline.createInterface({ input: stdin, output: stdout });
+  let session = null;
+  let mcp = { tools: [], servers: [], errors: [], closeAll: () => {} };
+
+  // Ctrl+C → 깔끔하게 종료(스택트레이스 없이). 어디서 누르든 안전.
+  const gracefulExit = () => {
+    try { rl.close(); } catch { /* */ }
+    try { session && session.close(); } catch { /* */ }
+    try { mcp && mcp.closeAll && mcp.closeAll(); } catch { /* */ }
+    console.log(c.dim("\n종료합니다. 안녕히 가세요!"));
+    process.exit(0);
+  };
+  rl.on("SIGINT", gracefulExit);
+  // 프롬프트 헬퍼: Ctrl+C(AbortError) 등은 null 로 돌려 호출부가 취소로 처리.
+  const ask = async (q) => {
+    try {
+      return await rl.question(q);
+    } catch {
+      return null;
+    }
+  };
 
   if (args.setup) {
-    await runSetup(rl, cfg);
+    await runSetup(ask, cfg);
   } else if (!cfg.isReady() && cfg.provider !== "mock") {
     console.log(c.yellow(`provider=${cfg.provider} 인데 API 키가 없습니다. 연결 설정을 시작합니다.\n`));
-    await runSetup(rl, cfg);
+    await runSetup(ask, cfg);
   }
 
   printIntro(cfg);
@@ -358,26 +392,38 @@ export async function main(argv = []) {
   //   ② npm 패키지: cdsa-harness-plugin-* 자동 발견 + config.plugins 강제 로드
   const filePlugins = await loadPlugins(cfg.workspacePath());
   const npm = await discoverNpmExtensions(process.cwd(), cfg.plugins || []);
-  const plugins = [...filePlugins, ...npm.plugins, ...npm.errors.map((e) => ({ error: e }))];
+  // ③ MCP 서버(다른 에이전트와 공용 표준)의 도구도 플러그인처럼 등록
+  if (cfg.mcpServers && Object.keys(cfg.mcpServers).length) {
+    process.stdout.write(c.dim("MCP 서버 연결 중...\r"));
+    mcp = await connectMcpServers(cfg.mcpServers);
+  }
+  const plugins = [
+    ...filePlugins,
+    ...npm.plugins,
+    ...mcp.tools,
+    ...npm.errors.map((e) => ({ error: e })),
+    ...mcp.errors.map((e) => ({ error: `MCP ${e}` })),
+  ];
   const skills = {};
   for (const s of npm.skills) skills[s.name] = { name: s.name, description: s.description || "", body: s.body, source: "(npm)" };
   Object.assign(skills, loadSkills(cfg.workspacePath())); // 로컬 파일 스킬이 우선
   const toolbox = new Toolbox(cfg.workspacePath(), cfg.allow_shell, plugins);
-  if (toolbox.plugins.length || Object.keys(skills).length || toolbox.pluginErrors.length) {
+  if (toolbox.plugins.length || Object.keys(skills).length || toolbox.pluginErrors.length || mcp.servers.length) {
     const bits = [];
-    if (toolbox.plugins.length) bits.push(c.green(`플러그인 ${toolbox.plugins.length}개`) + c.grey(` (${toolbox.plugins.map((p) => p.name).join(", ")})`));
-    if (Object.keys(skills).length) bits.push(c.green(`스킬 ${Object.keys(skills).length}개`) + c.grey(` (${Object.keys(skills).map((s) => "/" + s).join(", ")})`));
-    if (toolbox.pluginErrors.length) bits.push(c.red(`플러그인 오류 ${toolbox.pluginErrors.length}개`));
-    console.log("🔌 " + bits.join(" · ") + "\n");
+    if (toolbox.plugins.length) bits.push(c.green(`도구 +${toolbox.plugins.length}개`));
+    if (mcp.servers.length) bits.push(c.green(`MCP ${mcp.servers.length}개`) + c.grey(` (${mcp.servers.map((s) => s.name).join(", ")})`));
+    if (Object.keys(skills).length) bits.push(c.green(`스킬 ${Object.keys(skills).length}개`));
+    if (toolbox.pluginErrors.length) bits.push(c.red(`오류 ${toolbox.pluginErrors.length}개`));
+    console.log("🔌 " + bits.join(" · ") + c.dim("  (/plugins /skills /mcp 로 상세)") + "\n");
   }
 
-  const session = SessionLog.create();
+  session = SessionLog.create();
   const loop = new AgentLoop({
     config: cfg,
     client: makeClient(cfg),
     toolbox,
     onEvent: makePrinter(cfg),
-    approvalCallback: makeApproval(rl),
+    approvalCallback: makeApproval(ask),
     session,
   });
   loop.reset();
@@ -385,12 +431,9 @@ export async function main(argv = []) {
   const rule = () => console.log(c.grey("─".repeat(Math.min(80, stdout.columns || 80))));
 
   while (true) {
-    let user;
-    try {
-      user = (await rl.question(c.bold(c.cyan("› ")))).trim();
-    } catch {
-      break;
-    }
+    const raw = await ask(c.bold(c.cyan("› ")));
+    if (raw === null) break; // Ctrl+D / Ctrl+C / 스트림 종료
+    const user = raw.trim();
     if (!user) continue;
     const low = user.toLowerCase();
 
@@ -405,7 +448,7 @@ export async function main(argv = []) {
       continue;
     }
     if (low === "/setup" || low === "/login") {
-      await runSetup(rl, cfg);
+      await runSetup(ask, cfg);
       loop.client = makeClient(cfg);
       loop.reset();
       continue;
@@ -449,6 +492,16 @@ export async function main(argv = []) {
       console.log(panel(lines, { title: "🔌 플러그인 (모델이 쓸 수 있는 추가 도구)", color: "blue" }));
       continue;
     }
+    if (low === "/mcp") {
+      const lines = [];
+      if (!mcp.servers.length) lines.push(c.dim("연결된 MCP 서버가 없습니다."));
+      for (const s of mcp.servers) lines.push(`${c.bold(s.name)}  ${c.grey(`도구 ${s.count}개`)}`);
+      for (const t of mcp.tools) lines.push(`  ${c.cyan(t.name)}  ${c.grey(clip(t.description, 60))}`);
+      for (const e of mcp.errors) lines.push(c.red("✖ " + e));
+      lines.push(c.dim('설정: config.json 의 "mcpServers" (Claude Code/Cursor 와 동일 형식)'));
+      console.log(panel(lines, { title: "🔗 MCP 서버 (다른 에이전트와 공용)", color: "blue" }));
+      continue;
+    }
     if (low === "/skills") {
       const names = Object.keys(skills);
       const lines = names.length ? names.map((n) => `${c.cyan("/" + n)}  ${c.grey(skills[n].description || "")}`) : [c.dim("등록된 스킬이 없습니다.")];
@@ -487,6 +540,7 @@ export async function main(argv = []) {
 
   rl.close();
   session.close();
+  mcp.closeAll();
   console.log(c.dim("\n종료합니다. 안녕히 가세요!"));
   return 0;
 }

package/src/config.js

@@ -9,10 +9,11 @@ export const PROVIDERS = ["openai", "anthropic", "openrouter", "mock"];
 export const SUGGESTED_MODELS = {
   openai: ["gpt-4o-mini", "gpt-4.1-mini", "gpt-4.1"],
   anthropic: ["claude-3-5-haiku-latest", "claude-3-5-sonnet-latest", "claude-sonnet-4-5"],
+  // OpenRouter 는 반드시 'provider/model' 형식. (옛 anthropic/claude-3.5-sonnet 등은 404 가능)
   openrouter: [
     "openai/gpt-4o-mini",
-    "anthropic/claude-3.5-sonnet",
-    "google/gemini-2.5-flash",
+    "anthropic/claude-3.7-sonnet",
+    "google/gemini-2.0-flash-001",
   ],
   mock: ["mock-agent"],
 };
@@ -38,6 +39,7 @@ const DEFAULTS = {
   max_tokens: 1024,
   teach_mode: true,
   plugins: [], // 추가로 불러올 npm 플러그인 패키지 이름(이름 규칙과 무관하게 강제 로드)
+  mcpServers: {}, // MCP 서버 설정 (Claude Code/Cursor 와 동일한 형식)
 };
 
 export function configDir() {

package/src/llm.js

@@ -46,7 +46,16 @@ export class LLMClient {
     const latencyMs = Date.now() - started;
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      throw new LLMError(`API 오류 ${res.status}: ${trim(text) || res.statusText}`);
+      let msg = `API 오류 ${res.status}: ${trim(text) || res.statusText}`;
+      if (res.status === 404) {
+        msg += "\n  ↳ 모델 이름을 확인하세요. /model 로 변경 가능. " +
+          "OpenRouter 는 'provider/model' 형식이어야 합니다 (예: openai/gpt-4o-mini, anthropic/claude-3.7-sonnet).";
+      } else if (res.status === 401 || res.status === 403) {
+        msg += "\n  ↳ API 키가 잘못되었거나 권한이 없어요. /setup 으로 다시 연결하세요.";
+      } else if (res.status === 429) {
+        msg += "\n  ↳ 요청이 너무 많거나 크레딧이 부족할 수 있어요(잠시 후 재시도).";
+      }
+      throw new LLMError(msg);
     }
     return { payload: await res.json(), latencyMs, bodyBytes: Buffer.byteLength(json, "utf8") };
   }

package/src/mcp.js

@@ -0,0 +1,148 @@
+// MCP (Model Context Protocol) 클라이언트 — 상호운용의 핵심.
+// Claude Code · Cursor · Zed 등에서 쓰는 'MCP 서버'를 그대로 붙여 쓴다.
+// 설정은 그 도구들과 동일한 형식:
+//   "mcpServers": { "이름": { "command": "npx", "args": ["-y","..."], "env": {} } }
+//
+// stdio 전송(JSON-RPC 2.0, 줄바꿈 구분). 외부 의존성 없음(node child_process).
+import { spawn } from "node:child_process";
+
+const PROTOCOL_VERSION = "2024-11-05";
+
+export class McpServer {
+  constructor(name, spec) {
+    this.name = name;
+    this.spec = spec || {};
+    this.proc = null;
+    this.nextId = 1;
+    this.pending = new Map();
+    this.buf = "";
+    this.tools = [];
+  }
+
+  async start(timeout = 20000) {
+    if (!this.spec.command) throw new Error("command 가 없습니다");
+    this.proc = spawn(this.spec.command, this.spec.args || [], {
+      env: { ...process.env, ...(this.spec.env || {}) },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    this.proc.stdout.on("data", (d) => this._onData(d));
+    this.proc.stderr.on("data", () => {}); // 서버 로그는 무시
+    this.proc.on("error", (e) => this._failAll(e));
+    this.proc.on("exit", () => this._failAll(new Error("MCP 서버 프로세스 종료")));
+
+    await this._request(
+      "initialize",
+      { protocolVersion: PROTOCOL_VERSION, capabilities: {}, clientInfo: { name: "cdsa-harness", version: "0.5.0" } },
+      timeout
+    );
+    this._notify("notifications/initialized", {});
+    const list = await this._request("tools/list", {}, timeout);
+    this.tools = (list && list.tools) || [];
+    return this.tools;
+  }
+
+  _onData(chunk) {
+    this.buf += chunk.toString("utf8");
+    let nl;
+    while ((nl = this.buf.indexOf("\n")) >= 0) {
+      const line = this.buf.slice(0, nl);
+      this.buf = this.buf.slice(nl + 1);
+      if (!line.trim()) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue; // 프레이밍 깨진 줄 무시
+      }
+      if (msg.id != null && this.pending.has(msg.id)) {
+        const { resolve, reject } = this.pending.get(msg.id);
+        this.pending.delete(msg.id);
+        if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+        else resolve(msg.result);
+      }
+    }
+  }
+
+  _request(method, params, timeout = 20000) {
+    const id = this.nextId++;
+    const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP ${method} 시간초과`));
+      }, timeout);
+      this.pending.set(id, {
+        resolve: (r) => { clearTimeout(timer); resolve(r); },
+        reject: (e) => { clearTimeout(timer); reject(e); },
+      });
+      try {
+        this.proc.stdin.write(payload);
+      } catch (e) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(e);
+      }
+    });
+  }
+
+  _notify(method, params) {
+    try {
+      this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
+    } catch {
+      /* ignore */
+    }
+  }
+
+  _failAll(err) {
+    for (const { reject } of this.pending.values()) reject(err);
+    this.pending.clear();
+  }
+
+  async callTool(name, args) {
+    const res = await this._request("tools/call", { name, arguments: args || {} });
+    const parts = ((res && res.content) || []).map((b) =>
+      b.type === "text" ? b.text : b.type === "json" ? JSON.stringify(b.json) : `[${b.type}]`
+    );
+    const text = parts.join("\n") || (res && res.isError ? "(오류)" : "(빈 결과)");
+    return res && res.isError ? `MCP 오류: ${text}` : text;
+  }
+
+  stop() {
+    try {
+      this.proc && this.proc.kill();
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+// 여러 MCP 서버에 연결하고, 각 도구를 '플러그인 형식' tool def 로 변환해 돌려준다.
+// (Toolbox/loop 가 플러그인과 동일하게 다룰 수 있음)
+export async function connectMcpServers(servers = {}) {
+  const out = { tools: [], servers: [], errors: [], instances: [] };
+  for (const [name, spec] of Object.entries(servers)) {
+    if (!spec || spec.disabled) continue;
+    const srv = new McpServer(name, spec);
+    try {
+      const tools = await srv.start();
+      out.instances.push(srv);
+      out.servers.push({ name, count: tools.length });
+      for (const t of tools) {
+        const readOnly = t.annotations && t.annotations.readOnlyHint === true;
+        out.tools.push({
+          name: `mcp__${name}__${t.name}`,
+          description: t.description || `MCP(${name}) 도구 ${t.name}`,
+          parameters: t.inputSchema || { type: "object", properties: {} },
+          mutating: !readOnly, // 읽기전용 힌트가 없으면 보수적으로 승인 필요
+          handler: async (args) => srv.callTool(t.name, args),
+          source: `mcp:${name}`,
+        });
+      }
+    } catch (e) {
+      out.errors.push(`${name}: ${e.message}`);
+      srv.stop();
+    }
+  }
+  out.closeAll = () => out.instances.forEach((s) => s.stop());
+  return out;
+}

package/src/skills.js

@@ -11,10 +11,21 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
+// 우리 폴더 + 다른 코딩 에이전트들의 커맨드/스킬 폴더도 함께 읽어 상호운용한다.
+// (Claude Code, OpenCode 등은 스킬이 결국 frontmatter 달린 마크다운이라 그대로 호환)
 export function skillDirs(workspace) {
+  const home = os.homedir();
   return [
-    path.join(os.homedir(), ".cdsa_harness", "skills"),
+    // 전역
+    path.join(home, ".cdsa_harness", "skills"),
+    path.join(home, ".claude", "commands"),
+    path.join(home, ".config", "opencode", "command"),
+    // 작업 폴더
     path.join(workspace, ".cdsa", "skills"),
+    path.join(workspace, ".claude", "commands"),
+    path.join(workspace, ".claude", "skills"),
+    path.join(workspace, ".opencode", "command"),
+    path.join(workspace, ".github", "prompts"),
   ];
 }
 
@@ -29,33 +40,54 @@ function parseFrontmatter(text) {
   return { meta, body: text.slice(m[0].length).trim() };
 }
 
+function addSkill(skills, name, file) {
+  if (!name || skills[name]) return; // 먼저 발견된 것 우선
+  try {
+    const raw = fs.readFileSync(file, "utf8");
+    const { meta, body } = parseFrontmatter(raw);
+    skills[name] = { name, description: meta.description || "", body, source: file };
+  } catch {
+    /* ignore unreadable skill */
+  }
+}
+
 export function loadSkills(workspace) {
   const skills = {};
   for (const dir of skillDirs(workspace)) {
-    let files = [];
+    let entries = [];
     try {
       if (!fs.existsSync(dir)) continue;
-      files = fs.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+      entries = fs.readdirSync(dir).sort();
     } catch {
       continue;
     }
-    for (const f of files) {
-      const name = f.replace(/\.md$/, "");
+    for (const e of entries) {
+      const full = path.join(dir, e);
+      let stat;
       try {
-        const raw = fs.readFileSync(path.join(dir, f), "utf8");
-        const { meta, body } = parseFrontmatter(raw);
-        skills[name] = { name, description: meta.description || "", body, source: path.join(dir, f) };
+        stat = fs.statSync(full);
       } catch {
-        /* ignore unreadable skill */
+        continue;
+      }
+      if (stat.isFile() && e.endsWith(".md")) {
+        addSkill(skills, e.replace(/\.md$/, ""), full);
+      } else if (stat.isDirectory()) {
+        // Claude Code 스킬 형식: <이름>/SKILL.md
+        const skillMd = path.join(full, "SKILL.md");
+        if (fs.existsSync(skillMd)) addSkill(skills, e, skillMd);
       }
     }
   }
   return skills;
 }
 
-// 스킬 본문에 인자를 채워 최종 프롬프트를 만든다.
+// 스킬 본문에 인자를 채워 최종 프롬프트를 만든다. $ARGUMENTS / {{args}} 둘 다 지원.
 export function renderSkill(skill, args) {
   const argStr = (args || "").trim();
-  if (skill.body.includes("$ARGUMENTS")) return skill.body.replace(/\$ARGUMENTS/g, argStr);
-  return argStr ? `${skill.body}\n\n[추가 입력]\n${argStr}` : skill.body;
+  let body = skill.body;
+  const hasPlaceholder = /\$ARGUMENTS|\{\{\s*args\s*\}\}/.test(body);
+  if (hasPlaceholder) {
+    return body.replace(/\$ARGUMENTS/g, argStr).replace(/\{\{\s*args\s*\}\}/g, argStr);
+  }
+  return argStr ? `${body}\n\n[추가 입력]\n${argStr}` : body;
 }