cdsa-harness 0.2.0 → 0.5.1

package/README.md

@@ -11,6 +11,9 @@
 - **의존성 0개** — Node 18+ 내장 기능만(`fetch`/`readline`/`node:test`)
 - **실제 LLM 연결** — OpenAI · Anthropic(Claude) · OpenRouter, 또는 키 없이 `mock`
 - **교육 모드** — 매 반복마다 모델에 보내는 메시지 구성·추정 토큰·시스템 프롬프트, 실제 토큰 사용량/응답시간까지 그대로 표시
+- **MCP 클라이언트** — Claude Code·Cursor 등과 **공용 표준**. MCP 서버를 그대로 붙여 도구로 사용
+- **플러그인** — npm 으로 설치하거나 `.cdsa/plugins/` 에 JS 파일 → **도구 자동 등록**
+- **크로스포맷 스킬** — `.cdsa/skills/` 뿐 아니라 `.claude/commands/`·`.opencode/command/` 의 스킬도 인식
 
 ---
 
@@ -68,6 +71,74 @@ export OPENROUTER_API_KEY=sk-or-...
 
 ---
 
+## 🔌 플러그인 (추가 도구)
+
+### 방법 A — npm 으로 설치 (권장)
+
+`cdsa-harness-plugin-*` 이름의 패키지를 설치하면 **자동으로 발견·로드**됩니다.
+
+```bash
+cdsa-harness add cdsa-harness-plugin-git   # = npm install 후 자동 로드
+# 또는 직접:  npm install cdsa-harness-plugin-git
+cdsa-harness                               # 실행 → /plugins 에 자동 등록됨
+```
+
+- cwd 의 `node_modules` 와 전역 설치 위치를 모두 탐색합니다.
+- 이름 규칙과 무관하게 강제 로드하려면 `config.json` 의 `"plugins": ["패키지명"]` 에 추가.
+- 플러그인 패키지는 default export 로 `플러그인 def` · `def 배열` · `{ tools:[...], skills:[...] }` 중 하나를 제공.
+
+> **npm vs npx**: `npm install`(=설치, 보관) 으로 플러그인을 **추가**하고, `npx`(=설치 없이 실행) 또는 설치된 `cdsa-harness` 로 **실행**합니다.
+
+### 방법 B — 로컬 파일 (실험용)
+
+`.cdsa/plugins/` (작업 폴더) 또는 `~/.cdsa_harness/plugins/` 에 `.js`/`.mjs` 파일을 두면 자동 등록.
+
+```js
+// .cdsa/plugins/word_count.mjs
+import fs from "node:fs";
+import path from "node:path";
+export default {
+  name: "word_count",
+  description: "텍스트 파일의 글자/줄/단어 수를 센다",
+  parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] },
+  mutating: false,                 // true 면 실행 전 승인
+  async handler(args, ctx) {       // ctx.workspace = 작업 폴더 절대경로
+    const text = fs.readFileSync(path.resolve(ctx.workspace, args.path), "utf8");
+    return `글자 ${text.length}, 줄 ${text.split("\n").length}`;
+  },
+};
+```
+
+## 🔗 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/` 에 마크다운을 두면 `/파일명` 으로 실행됩니다. 본문의 `$ARGUMENTS`(또는 `{{args}}`)가 치환됩니다.
+**다른 에이전트의 스킬도 인식** — `.claude/commands/`, `.claude/skills/<이름>/SKILL.md`, `.opencode/command/` 등을 함께 읽습니다. `/skills` 로 목록 확인.
+
+```markdown
+---
+description: 파일을 읽고 3줄로 요약
+---
+$ARGUMENTS 파일을 read_file 로 읽고 핵심을 한국어 3줄로 요약해줘.
+```
+실행: `/summarize notes.txt`
+
 ## 설정 (config.json)
 
 `~/.cdsa_harness/config.json` (실행 폴더에 `config.json` 있으면 우선).
@@ -112,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.2.0",
-  "description": "AI 에이전트의 내부 동작(컨텍스트·API요청·토큰·도구·되먹임)을 단계별로 드러내는 교육용 터미널 하네스. OpenAI/Claude/OpenRouter 지원.",
+  "version": "0.5.1",
+  "description": "AI 에이전트의 내부 동작을 단계별로 드러내는 교육용 터미널 하네스. OpenAI/Claude/OpenRouter + MCP(다른 에이전트와 공용) + npm 플러그인·크로스포맷 스킬.",
   "type": "module",
   "bin": {
     "cdsa-harness": "bin/cdsa-harness.js",

package/src/cli.js

@@ -13,9 +13,14 @@ import {
   loadConfig,
   saveConfig,
 } from "./config.js";
+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";
 import { Toolbox } from "./tools.js";
 import { c, panel, renderDiff } from "./ui.js";
 
@@ -144,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 || "(변경 미리보기 없음)"), {
@@ -156,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 ? "" : "사용자가 거부했습니다." };
   };
@@ -213,6 +214,9 @@ function printHelp() {
         `  ${c.cyan("/model")} <이름>   모델 변경`,
         `  ${c.cyan("/teach")}    교육 모드 켜기/끄기(내부 과정 펼쳐보기)`,
         `  ${c.cyan("/context")}  지금 모델에 보내는 컨텍스트 들여다보기`,
+        `  ${c.cyan("/skills")}   스킬 목록(.cdsa/skills 의 /명령들)`,
+        `  ${c.cyan("/plugins")}  플러그인 목록(파일·npm 추가 도구)`,
+        `  ${c.cyan("/mcp")}      연결된 MCP 서버/도구(다른 에이전트와 공용)`,
         `  ${c.cyan("/reset")}    대화/컨텍스트 초기화`,
         `  ${c.cyan("/config")}   현재 설정값`,
         `  ${c.cyan("/quit")}     종료 (Ctrl+D)`,
@@ -226,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 에 연결할까요? 번호를 입력하세요.",
@@ -238,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;
@@ -251,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;
 }
@@ -298,6 +318,7 @@ export async function main(argv = []) {
     console.log(
       "CDSA Harness — AI 에이전트 내부를 드러내는 교육용 하네스 (터미널)\n\n" +
         "사용법: cdsa-harness [옵션]\n" +
+        "       cdsa-harness add <npm-패키지>   플러그인 설치(이후 자동 로드)\n" +
         "  --provider <openai|anthropic|openrouter|mock>\n" +
         "  --model <모델명>\n" +
         "  --workspace <폴더경로>\n" +
@@ -310,6 +331,24 @@ export async function main(argv = []) {
     return 0;
   }
 
+  // `cdsa-harness add <패키지>` — 플러그인을 npm 으로 설치(이후 자동 로드).
+  if (args._[0] === "add" || args._[0] === "install") {
+    const pkgs = args._.slice(1);
+    if (!pkgs.length) {
+      console.log("사용법: cdsa-harness add <npm-패키지...>   예) cdsa-harness add cdsa-harness-plugin-git");
+      return 1;
+    }
+    console.log(c.cyan(`npm install ${pkgs.join(" ")} ...`));
+    try {
+      execFileSync("npm", ["install", ...pkgs], { stdio: "inherit", cwd: process.cwd() });
+      console.log(c.green("설치 완료. 다음 실행부터 플러그인이 자동으로 로드됩니다 (/plugins 로 확인)."));
+      return 0;
+    } catch (e) {
+      console.log(c.red(`설치 실패: ${e.message}`));
+      return 1;
+    }
+  }
+
   const cfg = loadConfig();
   if (args.provider) cfg.provider = args.provider;
   if (args.model) cfg.model = args.model;
@@ -318,24 +357,73 @@ 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);
 
-  const toolbox = new Toolbox(cfg.workspacePath(), cfg.allow_shell);
-  const session = SessionLog.create();
+  // 플러그인(추가 도구)·스킬(프롬프트 템플릿)을 불러온다:
+  //   ① 파일: .cdsa/plugins · .cdsa/skills (작업폴더/홈)
+  //   ② npm 패키지: cdsa-harness-plugin-* 자동 발견 + config.plugins 강제 로드
+  const filePlugins = await loadPlugins(cfg.workspacePath());
+  const npm = await discoverNpmExtensions(process.cwd(), cfg.plugins || []);
+  // ③ 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 || mcp.servers.length) {
+    const bits = [];
+    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");
+  }
+
+  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();
@@ -343,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();
 
@@ -363,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;
@@ -394,6 +479,55 @@ export async function main(argv = []) {
       console.log(panel(clip(ctx.systemPrompt, 800).split("\n"), { title: "📜 시스템 프롬프트", color: "grey" }));
       continue;
     }
+    if (low === "/plugins") {
+      const lines = [];
+      if (!toolbox.plugins.length) lines.push(c.dim("등록된 플러그인이 없습니다."));
+      for (const p of toolbox.plugins) {
+        const src = p.source && p.source.includes("/") ? "📄 " + p.source.split("/").slice(-1)[0] : "📦 " + (p.source || "npm");
+        lines.push(`${c.bold(p.name)}${p.mutating ? c.yellow(" (승인필요)") : ""}  ${c.grey(p.description || "")} ${c.dim(src)}`);
+      }
+      for (const e of toolbox.pluginErrors) lines.push(c.red("✖ " + e));
+      lines.push(c.dim("추가: npm 패키지 'cdsa-harness-plugin-*' 설치 → 자동 로드 (cdsa-harness add <pkg>)"));
+      lines.push(c.dim("또는: <작업폴더>/.cdsa/plugins/ 에 .js/.mjs 파일"));
+      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("등록된 스킬이 없습니다.")];
+      lines.push(c.dim("위치: <작업폴더>/.cdsa/skills/ 또는 ~/.cdsa_harness/skills/ (.md). 본문의 $ARGUMENTS 치환."));
+      console.log(panel(lines, { title: "🎯 스킬 (프롬프트 템플릿, /이름 으로 실행)", color: "cyan" }));
+      continue;
+    }
+
+    // 위 내장 명령에 안 걸린 '/...' → 스킬이면 실행, 아니면 안내.
+    if (user.startsWith("/")) {
+      const name = low.slice(1).split(/\s+/)[0];
+      if (skills[name]) {
+        const argStr = user.split(/\s+/).slice(1).join(" ");
+        console.log(c.dim(`(스킬 '/${name}' 실행)`));
+        rule();
+        try {
+          await loop.run(renderSkill(skills[name], argStr));
+        } catch (e) {
+          console.log(c.red(`실행 오류: ${e?.message || e}`));
+        }
+        rule();
+      } else {
+        console.log(c.yellow(`알 수 없는 명령/스킬: /${name} — ${c.cyan("/help")}, ${c.cyan("/skills")} 참고`));
+      }
+      continue;
+    }
 
     rule();
     try {
@@ -406,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"],
 };
@@ -37,6 +38,8 @@ const DEFAULTS = {
   temperature: 0.2,
   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/loop.js

@@ -7,7 +7,7 @@ import fs from "node:fs";
 import path from "node:path";
 
 import { LLMError } from "./llm.js";
-import { MUTATING_TOOLS, TOOL_LABELS, ToolError, toolSchemas } from "./tools.js";
+import { TOOL_LABELS, ToolError, toolSchemas } from "./tools.js";
 
 // 단계(Step) 상수
 export const Step = {
@@ -145,7 +145,7 @@ export class AgentLoop {
       "규칙 파일 + 작업 폴더 내용을 시스템 프롬프트로 묶어 모델에 전달합니다."
     );
 
-    const tools = toolSchemas(this.config.allow_shell);
+    const tools = toolSchemas(this.config.allow_shell, this.toolbox.plugins);
     const toolNames = tools.map((t) => t.function.name);
     let finalText = "";
 
@@ -227,8 +227,8 @@ export class AgentLoop {
   }
 
   async _handleToolCall(tc) {
-    const label = TOOL_LABELS[tc.name] || tc.name;
-    const needsApproval = MUTATING_TOOLS.has(tc.name);
+    const label = this.toolbox.label ? this.toolbox.label(tc.name) : TOOL_LABELS[tc.name] || tc.name;
+    const needsApproval = this.toolbox.isMutating(tc.name);
 
     if (needsApproval && this.config.approval_mode === "manual") {
       const req = this._buildApprovalRequest(tc);
@@ -250,7 +250,7 @@ export class AgentLoop {
 
     this._emit(Step.TOOL_RUN, `도구 실행: ${label}`, JSON.stringify(tc.args).slice(0, 2000));
     try {
-      const result = this.toolbox.execute(tc.name, tc.args);
+      const result = await this.toolbox.execute(tc.name, tc.args);
       this._emit(Step.TOOL_RESULT, `결과 반영: ${label}`, (result.output || "").slice(0, 4000));
       return result.output;
     } catch (e) {

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/plugins.js

@@ -0,0 +1,191 @@
+// 플러그인 시스템 — OpenCode 스타일 확장성.
+// `.cdsa/plugins/` (작업 폴더) 와 `~/.cdsa_harness/plugins/` (전역) 의 .js/.mjs 파일을
+// 불러와 '새 도구'로 등록한다. 각 파일은 아래 형태의 객체를 default export 한다:
+//
+//   export default {
+//     name: "word_count",
+//     description: "텍스트 파일의 글자/줄 수를 센다",
+//     parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] },
+//     mutating: false,                  // true 면 실행 전 사용자 승인 필요
+//     async handler(args, ctx) { ... }  // ctx = { workspace }
+//   }
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+export function pluginDirs(workspace) {
+  return [
+    path.join(os.homedir(), ".cdsa_harness", "plugins"),
+    path.join(workspace, ".cdsa", "plugins"),
+  ];
+}
+
+export async function loadPlugins(workspace) {
+  const plugins = [];
+  for (const dir of pluginDirs(workspace)) {
+    let files = [];
+    try {
+      if (!fs.existsSync(dir)) continue;
+      files = fs.readdirSync(dir).filter((f) => /\.(mjs|js)$/.test(f)).sort();
+    } catch {
+      continue;
+    }
+    for (const f of files) {
+      const full = path.join(dir, f);
+      try {
+        const mod = await import(pathToFileURL(full).href);
+        const def = mod.default || mod.plugin || mod;
+        if (!def || !def.name || typeof def.handler !== "function") {
+          plugins.push({ error: `${f}: name/handler 가 없습니다` });
+          continue;
+        }
+        plugins.push({
+          name: def.name,
+          description: def.description || "",
+          parameters: def.parameters || { type: "object", properties: {} },
+          mutating: Boolean(def.mutating),
+          handler: def.handler,
+          source: full,
+        });
+      } catch (e) {
+        plugins.push({ error: `${f}: ${e.message}` });
+      }
+    }
+  }
+  return plugins;
+}
+
+// ---------------------------------------------------------------------------
+// npm 패키지로 설치한 플러그인 자동 발견.
+//   - 이름이 `cdsa-harness-plugin-*` (또는 `@scope/cdsa-harness-plugin-*`)
+//   - 또는 package.json 에 keywords: ["cdsa-harness-plugin"] / "cdsaHarness" 필드
+//   인 패키지를 node_modules 에서 찾아 불러온다.
+// 패키지는 다음 중 하나를 default export:
+//   · 플러그인 def 객체  · def 배열  · { tools:[...], skills:[{name,description,body}] }
+// ---------------------------------------------------------------------------
+function isPluginPackage(pkgJson, name) {
+  if (/^(@[^/]+\/)?cdsa-harness-plugin-/.test(name)) return true;
+  if (pkgJson && pkgJson.cdsaHarness) return true;
+  const kw = (pkgJson && pkgJson.keywords) || [];
+  return Array.isArray(kw) && kw.includes("cdsa-harness-plugin");
+}
+
+async function importPackage(nmDir, name) {
+  const req = createRequire(path.join(nmDir, "__cdsa_resolve__.js"));
+  const entry = req.resolve(name);
+  return import(pathToFileURL(entry).href);
+}
+
+function normalizeModule(mod, source) {
+  const out = { plugins: [], skills: [] };
+  const def = (mod && (mod.default ?? mod)) || null;
+  if (!def) return out;
+  let tools = [];
+  let skills = [];
+  if (Array.isArray(def)) tools = def;
+  else if (def.tools || def.skills) {
+    tools = def.tools || [];
+    skills = def.skills || [];
+  } else if (def.name && typeof def.handler === "function") tools = [def];
+  for (const t of tools) {
+    if (t && t.name && typeof t.handler === "function") {
+      out.plugins.push({
+        name: t.name,
+        description: t.description || "",
+        parameters: t.parameters || { type: "object", properties: {} },
+        mutating: Boolean(t.mutating),
+        handler: t.handler,
+        source,
+      });
+    }
+  }
+  for (const s of skills) if (s && s.name && s.body) out.skills.push(s);
+  return out;
+}
+
+// 한 node_modules 디렉터리를 훑어 플러그인 패키지를 모은다.
+export async function scanNodeModules(nmDir) {
+  const result = { plugins: [], skills: [], errors: [] };
+  let entries = [];
+  try {
+    if (!fs.existsSync(nmDir)) return result;
+    entries = fs.readdirSync(nmDir);
+  } catch {
+    return result;
+  }
+  const names = [];
+  for (const e of entries) {
+    if (e.startsWith(".")) continue;
+    if (e.startsWith("@")) {
+      try {
+        for (const sub of fs.readdirSync(path.join(nmDir, e))) names.push(`${e}/${sub}`);
+      } catch {
+        /* ignore */
+      }
+    } else names.push(e);
+  }
+  for (const name of names) {
+    let pkgJson = {};
+    try {
+      pkgJson = JSON.parse(fs.readFileSync(path.join(nmDir, name, "package.json"), "utf8"));
+    } catch {
+      continue;
+    }
+    if (!isPluginPackage(pkgJson, name)) continue;
+    try {
+      const mod = await importPackage(nmDir, name);
+      const norm = normalizeModule(mod, name);
+      result.plugins.push(...norm.plugins);
+      result.skills.push(...norm.skills);
+    } catch (e) {
+      result.errors.push(`${name}: ${e.message}`);
+    }
+  }
+  return result;
+}
+
+// cwd 의 node_modules + cdsa-harness 자신의 node_modules(전역 설치 시 형제 패키지) 를 훑고,
+// config.plugins 에 적힌 패키지는 이름 규칙과 무관하게 강제로 불러온다.
+export async function discoverNpmExtensions(cwd, explicitNames = []) {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const nmDirs = [];
+  const add = (d) => {
+    const r = path.resolve(d);
+    if (!nmDirs.includes(r)) nmDirs.push(r);
+  };
+  add(path.join(cwd, "node_modules"));
+  add(path.resolve(here, "..", "..")); // .../node_modules/cdsa-harness/src → .../node_modules
+
+  const merged = { plugins: [], skills: [], errors: [] };
+  for (const nm of nmDirs) {
+    const r = await scanNodeModules(nm);
+    merged.plugins.push(...r.plugins);
+    merged.skills.push(...r.skills);
+    merged.errors.push(...r.errors);
+  }
+  for (const name of explicitNames) {
+    if (merged.plugins.some((p) => p.source === name)) continue;
+    let loaded = false;
+    for (const nm of nmDirs) {
+      try {
+        const norm = normalizeModule(await importPackage(nm, name), name);
+        if (norm.plugins.length || norm.skills.length) {
+          merged.plugins.push(...norm.plugins);
+          merged.skills.push(...norm.skills);
+          loaded = true;
+          break;
+        }
+      } catch {
+        /* try next dir */
+      }
+    }
+    if (!loaded) merged.errors.push(`${name}: 불러올 수 없음(설치되어 있나요? npm i ${name})`);
+  }
+  // 이름 중복 제거(먼저 발견된 것 우선)
+  const byName = new Map();
+  for (const p of merged.plugins) if (!byName.has(p.name)) byName.set(p.name, p);
+  merged.plugins = [...byName.values()];
+  return merged;
+}

package/src/skills.js

@@ -0,0 +1,93 @@
+// 스킬 시스템 — OpenCode 의 커스텀 커맨드와 같은 개념.
+// `.cdsa/skills/` (작업 폴더) 와 `~/.cdsa_harness/skills/` (전역) 의 .md 파일을 불러온다.
+// 파일명이 곧 스킬 이름이고(`/이름` 으로 실행), 본문은 모델에 전달할 프롬프트 템플릿이다.
+// 본문 안의 `$ARGUMENTS` 는 `/이름 뒤에 붙인 텍스트` 로 치환된다.
+//
+//   ---
+//   description: 파일을 읽고 3줄로 요약
+//   ---
+//   $ARGUMENTS 파일을 read_file 로 읽고 핵심을 한국어 3줄로 요약해줘.
+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(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"),
+  ];
+}
+
+function parseFrontmatter(text) {
+  const m = /^---\n([\s\S]*?)\n---\n?/.exec(text);
+  if (!m) return { meta: {}, body: text.trim() };
+  const meta = {};
+  for (const line of m[1].split("\n")) {
+    const i = line.indexOf(":");
+    if (i > 0) meta[line.slice(0, i).trim()] = line.slice(i + 1).trim();
+  }
+  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 entries = [];
+    try {
+      if (!fs.existsSync(dir)) continue;
+      entries = fs.readdirSync(dir).sort();
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      const full = path.join(dir, e);
+      let stat;
+      try {
+        stat = fs.statSync(full);
+      } catch {
+        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();
+  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;
+}

package/src/tools.js

@@ -51,10 +51,27 @@ export function diffLines(oldText, newText) {
 }
 
 export class Toolbox {
-  constructor(workspace, allowShell = false) {
+  constructor(workspace, allowShell = false, plugins = []) {
     this.workspace = path.resolve(workspace);
     fs.mkdirSync(this.workspace, { recursive: true });
     this.allowShell = allowShell;
+    // 정상 로드된 플러그인만 도구로 사용(로드 에러는 따로 보관해 표시).
+    this.plugins = plugins.filter((p) => p && p.name && typeof p.handler === "function");
+    this.pluginErrors = plugins.filter((p) => p && p.error).map((p) => p.error);
+    this._pluginMap = new Map(this.plugins.map((p) => [p.name, p]));
+  }
+
+  // 실행 전 사용자 승인이 필요한 도구인가? (환경을 바꾸는 내장 도구 + mutating 플러그인)
+  isMutating(name) {
+    if (MUTATING_TOOLS.has(name)) return true;
+    const p = this._pluginMap.get(name);
+    return Boolean(p && p.mutating);
+  }
+
+  label(name) {
+    if (TOOL_LABELS[name]) return TOOL_LABELS[name];
+    const p = this._pluginMap.get(name);
+    return p ? `플러그인:${name}` : name;
   }
 
   _resolve(rel) {
@@ -148,16 +165,27 @@ export class Toolbox {
     return { ok: code === 0, output: `$ ${command}\n(exit=${code})\n${out}` };
   }
 
-  execute(name, args = {}) {
+  async execute(name, args = {}) {
     if (name === "list_dir") return this.listDir(args.path || ".");
     if (name === "read_file") return this.readFile(args.path || "");
     if (name === "write_file") return this.writeFile(args.path || "", args.content || "");
     if (name === "run_shell") return this.runShell(args.command || "");
+    const plugin = this._pluginMap.get(name);
+    if (plugin) {
+      let result;
+      try {
+        result = await plugin.handler(args, { workspace: this.workspace });
+      } catch (e) {
+        throw new ToolError(`플러그인 '${name}' 실행 오류: ${e.message}`);
+      }
+      const output = typeof result === "string" ? result : result?.output ?? JSON.stringify(result);
+      return { ok: true, output: String(output) };
+    }
     throw new ToolError(`알 수 없는 도구입니다: ${name}`);
   }
 }
 
-export function toolSchemas(allowShell = false) {
+export function toolSchemas(allowShell = false, plugins = []) {
   const schemas = [
     {
       type: "function",
@@ -216,5 +244,17 @@ export function toolSchemas(allowShell = false) {
       },
     });
   }
+  // 플러그인이 제공하는 도구를 모델에게도 노출한다.
+  for (const p of plugins) {
+    if (!p || !p.name || typeof p.handler !== "function") continue;
+    schemas.push({
+      type: "function",
+      function: {
+        name: p.name,
+        description: (p.description || `플러그인 도구 ${p.name}`) + (p.mutating ? " (승인 필요)" : ""),
+        parameters: p.parameters || { type: "object", properties: {} },
+      },
+    });
+  }
   return schemas;
 }

package/workspace/.cdsa/plugins/word_count.mjs

@@ -0,0 +1,31 @@
+// 예시 플러그인: 작업 폴더 안 텍스트 파일의 글자/줄/단어 수를 센다.
+// 이 파일을 .cdsa/plugins/ 에 두면 자동으로 'word_count' 도구가 등록되어
+// 모델이 호출할 수 있게 된다. (읽기 전용이라 mutating: false → 승인 불필요)
+import fs from "node:fs";
+import path from "node:path";
+
+export default {
+  name: "word_count",
+  description: "작업 폴더 안 텍스트 파일의 글자수/줄수/단어수를 센다.",
+  parameters: {
+    type: "object",
+    properties: { path: { type: "string", description: "작업 폴더 기준 상대 경로" } },
+    required: ["path"],
+  },
+  mutating: false,
+  async handler(args, ctx) {
+    const rel = (args.path || "").trim();
+    const target = path.resolve(ctx.workspace, rel);
+    if (target !== ctx.workspace && !target.startsWith(ctx.workspace + path.sep)) {
+      return "작업 폴더 밖 경로에는 접근할 수 없습니다.";
+    }
+    if (!fs.existsSync(target) || !fs.statSync(target).isFile()) {
+      return `파일이 없습니다: ${rel}`;
+    }
+    const text = fs.readFileSync(target, "utf8");
+    const chars = text.length;
+    const lines = text.split("\n").length;
+    const words = (text.trim().match(/\S+/g) || []).length;
+    return `${rel} → 글자 ${chars}, 줄 ${lines}, 단어 ${words}`;
+  },
+};

package/workspace/.cdsa/skills/summarize.md

@@ -0,0 +1,5 @@
+---
+description: 지정한 파일을 읽고 한국어 3줄로 요약
+---
+$ARGUMENTS 파일을 read_file 도구로 읽은 다음, 핵심 내용을 한국어 3줄로 요약해줘.
+파일을 수정하지는 말고, 요약만 보여줘.