elanous 0.2.0 → 0.2.4

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "elanous",
-  "version": "0.2.0",
+  "version": "0.2.4",
   "description": "Self-healing coding harness where eyes, hands, and memory all turn on one sentence — it authors its own goals, implements them in isolated worktrees, and reviews its own work.",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ElanvitalAI/monad.git"
+    "url": "git+https://github.com/ElanvitalAI/elanous.git"
   },
   "type": "module",
   "bin": {
     "elanous": "./bin/elanous.mjs",
-    "mda": "./bin/elanous.mjs"
+    "eln": "./bin/elanous.mjs"
   },
   "engines": {
     "bun": ">=1.3.5"
@@ -36,6 +36,7 @@
     ".rules/",
     "docs/goal-context/",
     "docs/design/craft/",
+    "docs/design/systems/",
     "docs/mission-requests/",
     "docs/ad-presets/",
     "!**/*.test.ts",
@@ -81,7 +82,9 @@
     "test:cdp": "bun run scripts/test-cdp.ts"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "0.14.1",
+    "@a2a-js/sdk": "^0.3.0",
+    "@agentclientprotocol/claude-agent-acp": "0.81.2",
+    "@agentclientprotocol/sdk": "1.5.0",
     "@antv/infographic": "^0.2.20",
     "@aws-sdk/client-secrets-manager": "^3.1043.0",
     "@discordjs/voice": "^0.19.2",
@@ -89,7 +92,6 @@
     "@google/gemini-cli": "0.38.0",
     "@google/genai": "^1.51.0",
     "@xterm/headless": "^6.0.0",
-    "@zed-industries/claude-code-acp": "0.16.2",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "diff": "^9.0.0",

package/plugins/job-coach/.agents/plugins/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "job-coach-local",
+  "interface": { "displayName": "AI 직무코치" },
+  "plugins": [
+    {
+      "name": "job-coach",
+      "source": { "source": "local", "path": "./" },
+      "policy": { "installation": "AVAILABLE", "authentication": "ON_INSTALL" },
+      "category": "Productivity"
+    }
+  ]
+}

package/plugins/job-coach/.codex-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "job-coach",
+  "version": "0.1.0",
+  "description": "Interview-to-NCS competency gap and cited course report.",
+  "skills": "./skills/"
+}

package/plugins/job-coach/.mcp.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "ncs": {
+      "command": "bun",
+      "args": ["${CODEX_PLUGIN_ROOT}/connectors/ncs/server.ts"],
+      "env": { "NCS_SERVICE_KEY": "${NCS_SERVICE_KEY}" }
+    }
+  }
+}

package/plugins/job-coach/README.md

@@ -0,0 +1,20 @@
+# job-coach — AI 직무코치
+
+**S** 인터뷰에서 직무 후보를 추출해 공공데이터포털의 NCS 능력단위와 비교하고, 외부 코스 조사로 보고서를 작성한다. **C** 실제 NCS 키와 코스 출처가 없으면 매칭·추천을 지어낼 수 없다. **Q** 이 패키지를 받은 사용자가 어떻게 실행하고 결과를 확인하는가? **A** 아래 실행 방법과 검증 방법을 따른다.
+
+## 실행
+
+공공데이터포털 [한국산업인력공단 NCS 기준정보 조회](https://www.data.go.kr/data/15128213/openapi.do) 활용신청 후 키를 **환경변수 `NCS_SERVICE_KEY`** 로 설정한다. 설치 시 `credentials` 이벤트의 `ncs.serviceKey` 에 입력하는 경로는 플러그인 설치기가 담당한다. 저장소에는 키를 넣지 않는다. `.mcp.json`은 MCP stdio 서버를 번들로 제공한다. 레시피는 러너가 제공하는 `ELANOUS_GRAPH_DIR`을 기준으로 번들 스크립트를 찾고, MCP의 `${CODEX_PLUGIN_ROOT}`는 Codex가 설치한 플러그인의 절대 경로로 치환한다. 런타임에는 `bun`과 PATH의 `elanous research --json`가 필요하다. 중첩 elanous 호출에는 `--test`를 붙여 격리한다. 인터뷰 파일은 `## 희망 직무`, `## 경험`, `## 보유 역량`을 포함해야 한다.
+
+```sh
+elanous graph run /absolute/path/to/installed/job-coach/graphs/report.yaml --input '{"interview":"/absolute/path/to/installed/job-coach/examples/interview-sample.md"}' --json
+```
+
+`job-coach:report` 별칭은 이 변경 범위의 그래프 CLI에서 아직 인식하지 않는다. 파일 경로로 실행해야 한다(`elanous plugin add`는 별도 골). 실행 결과의 `statePath`가 `<state>/graph-runs/job-coach-report/<run-id>.json`이고, 보고서는 같은 디렉터리의 `<run-id>/report.md`다. 실패 시 결과를 그럴듯하게 채우지 않고 `failed`로 끝난다. 주의: 실행 그래프 러너는 입력과 노드 stdout을 런 상태·컨텍스트 JSON에 보관하므로 실제 인터뷰 파일 **내용**을 그래프 입력·로그에 넣지 말고 비공개 경로만 건넨다. 프로필은 경험 원문 대신 건수만 산출하지만 직무 후보·보유 역량은 런 상태에 남는다. 런 상태 저장소는 접근제한된 개인용이어야 한다. `research`는 검색 링크를 추천으로 취급하지 않고 HTTPS 발행 페이지의 `Course` 구조화 메타데이터를 읽어 실제 과정인지 확인한 뒤, 과정 이름·설명이 NCS 능력단위 이름과 일치하는 경우에만 근거와 출처를 붙인다. 일반 문서·무관한 강좌·확인 불가 링크는 추천하지 않는다. 해당 과정이 없으면 보고서에 `확인된 관련 교육 과정 없음 (추천 미확인)`을 표시한다. `judge`는 빈 섹션이나 확인된 과정이 없는 첫 실행이면 `research`로 한 번 되돌린다. dry-run은 HTTP·연구·보고서 생성을 수행하지 않는다(런 상태 JSON은 저장한다):
+
+```sh
+elanous graph run /absolute/path/to/installed/job-coach/graphs/report.yaml --dry-run --json
+bun test src/plugins/examples/job-coach.test.ts
+```
+
+Codex에서는 `run-report` 스킬을 실행한다. elanous MCP 그래프가 있으면 그것을 우선 호출하고 없으면 NCS MCP, 외부 검색, 나머지 두 스킬로 단계를 수행한다. 로컬 마켓 인덱스는 이 패키지의 `.agents/plugins/marketplace.json`이다. `codex plugin marketplace add <job-coach 경로>` 후 `codex plugin add job-coach@job-coach-local`로 격리 Codex 홈에도 설치할 수 있다. 원본 인터뷰는 비공개로 유지하고 가상 샘플만 저장소에 포함한다.

package/plugins/job-coach/connectors/ncs/server.ts

@@ -0,0 +1,89 @@
+import { createInterface } from 'node:readline';
+
+// Public Data Portal: 한국산업인력공단_NCS 기준정보 조회, data.go.kr/data/15128213/openapi.do.
+const BASE = 'https://apis.data.go.kr/B490007/hrdkapi/';
+type Fetch = typeof fetch;
+type Arguments = Record<string, unknown>;
+const schema = (properties: Record<string, unknown>, required: string[]) => ({ type: 'object', properties, required, additionalProperties: false });
+const text = { type: 'string' };
+export const tools = [
+  { name: 'ncs_search_units', description: 'Search NCS competency units by keyword (NCS007).', inputSchema: schema({ keyword: text }, ['keyword']) },
+  { name: 'ncs_unit', description: 'Look up a competency unit by NCS classification code (NCS005).', inputSchema: schema({ code: text }, ['code']) },
+  { name: 'ncs_classification', description: 'List NCS classifications at major, middle, minor or detailed level (NCS001–004). Parent codes are required below major.', inputSchema: schema({ level: { type: 'string', enum: ['major', 'middle', 'minor', 'detailed'] }, code: text }, ['level']) },
+];
+
+function required(value: unknown, label: string): string {
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`${label} is required`);
+  return value.trim();
+}
+
+export async function callNcsTool(name: string, args: Arguments, options: { key?: string; fetch?: Fetch } = {}): Promise<unknown> {
+  const key = options.key ?? process.env.NCS_SERVICE_KEY;
+  if (!key?.trim()) throw new Error('NCS_SERVICE_KEY 키 없음 — 공공데이터포털 serviceKey를 설정하세요');
+  const params = new URLSearchParams({ serviceKey: key, pageNo: '1', numOfRows: '20' });
+  let operation: string;
+  if (name === 'ncs_search_units') {
+    operation = 'NCS007';
+    params.set('LVL', '5');
+    params.set('SWRD', required(args.keyword, 'keyword'));
+    params.set('SNUM', '1');
+    params.set('ENUM', '20');
+  } else if (name === 'ncs_unit') {
+    operation = 'NCS005';
+    const code = required(args.code, 'code');
+    if (!/^\d{8,}$/.test(code)) throw new Error('code must contain the complete numeric NCS classification code');
+    for (const [field, start, end] of [['NCS_LCLAS_CD', 0, 2], ['NCS_MCLAS_CD', 2, 4], ['NCS_SCLAS_CD', 4, 6], ['NCS_SUBD_CD', 6, 8]] as const) params.set(field, code.slice(start, end));
+    params.set('NCS_CL_CD', code);
+  } else if (name === 'ncs_classification') {
+    const levels = { major: 1, middle: 2, minor: 3, detailed: 4 } as const;
+    if (typeof args.level !== 'string' || !Object.hasOwn(levels, args.level)) throw new Error('level must be major, middle, minor or detailed');
+    const level = levels[args.level as keyof typeof levels];
+    operation = `NCS00${level}`;
+    if (level > 1) {
+      const code = required(args.code, 'parent code');
+      if (!/^\d+$/.test(code) || code.length < (level - 1) * 2) throw new Error('parent code must contain the numeric NCS ancestor codes');
+      ['NCS_LCLAS_CD', 'NCS_MCLAS_CD', 'NCS_SCLAS_CD'].slice(0, level - 1).forEach((field, index) => params.set(field, code.slice(index * 2, index * 2 + 2)));
+    }
+  } else throw new Error(`Unknown NCS tool: ${name}`);
+  let response: Response;
+  try {
+    response = await (options.fetch ?? fetch)(`${BASE}${operation}?${params}`, { signal: AbortSignal.timeout(15000) });
+  } catch {
+    throw new Error('NCS API connection failed (serviceKey redacted)');
+  }
+  if (!response.ok) throw new Error(`NCS API HTTP ${response.status}`);
+  const data: unknown = await response.json();
+  const envelope = data as { response?: { header?: { resultCode?: string; resultMsg?: string }; body?: unknown }; header?: { resultCode?: string; resultMsg?: string }; body?: unknown };
+  const result = envelope.response ?? envelope;
+  if (result.header?.resultCode && !['00', '0', '200'].includes(result.header.resultCode)) throw new Error(`NCS API rejected request (${result.header.resultCode})`);
+  if (!result.body) throw new Error('NCS API response has no body');
+  return { source: `https://www.data.go.kr/data/15128213/openapi.do#${operation}`, body: result.body };
+}
+
+export async function handleRequest(req: { jsonrpc?: string; id?: number | string; method?: string; params?: { name?: string; arguments?: Arguments; protocolVersion?: string } }, options: { key?: string; fetch?: Fetch } = {}) {
+  const id = req.id ?? null;
+  if (req.method === 'initialize') return { jsonrpc: '2.0', id, result: { protocolVersion: req.params?.protocolVersion ?? '2024-11-05', capabilities: { tools: {} }, serverInfo: { name: 'job-coach-ncs', version: '0.1.0' } } };
+  if (req.method === 'tools/list') return { jsonrpc: '2.0', id, result: { tools } };
+  if (req.method === 'tools/call') {
+    try {
+      const result = await callNcsTool(req.params?.name ?? '', req.params?.arguments ?? {}, options);
+      return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify(result) }] } };
+    } catch (error) {
+      return { jsonrpc: '2.0', id, result: { isError: true, content: [{ type: 'text', text: error instanceof Error ? error.message : 'NCS request failed' }] } };
+    }
+  }
+  return { jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } };
+}
+
+if (import.meta.main) {
+  const lines = createInterface({ input: process.stdin });
+  for await (const line of lines) {
+    try {
+      const request = JSON.parse(line);
+      if (request.id === undefined) continue;
+      process.stdout.write(JSON.stringify(await handleRequest(request)) + '\n');
+    } catch {
+      process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } }) + '\n');
+    }
+  }
+}

package/plugins/job-coach/examples/interview-sample.md

@@ -0,0 +1,11 @@
+# 가상 인물 인터뷰 (테스트 전용)
+
+## 희망 직무
+데이터 분석
+
+## 경험
+- 가상 동아리 설문 결과를 표로 정리했다.
+- 가상 프로젝트에서 시각화 자료를 만들었다.
+
+## 보유 역량
+스프레드시트, 데이터 시각화

package/plugins/job-coach/graphs/course-links.ts

@@ -0,0 +1,46 @@
+type Unit = { name: string; code: string };
+export type VerifiedCourse = { title: string; url: string; matchedUnit: string; evidence: string };
+
+// A search hit is a lead, not evidence of a course. Verify the publisher's page.
+export async function courseLinks(result: unknown, units: Unit[], fetchPage: typeof fetch = fetch): Promise<VerifiedCourse[]> {
+  if (!result || typeof result !== 'object' || !('output' in result) || typeof result.output !== 'string') return [];
+  const hits = [...result.output.matchAll(/^- \[([^\]\n]+)\]\((https:\/\/[^\s)]+)\)/gm)].slice(0, 10);
+  const courses: VerifiedCourse[] = [];
+  for (const [, , url] of hits) {
+    if (!url || courses.some(course => course.url === url)) continue;
+    let page: Response;
+    try {
+      page = await fetchPage(url, { signal: AbortSignal.timeout(8000), redirect: 'error' });
+      if (!page.ok || !page.headers.get('content-type')?.includes('text/html')) continue;
+    } catch { continue; }
+    let html: string;
+    try { html = (await page.text()).slice(0, 500_000); } catch { continue; }
+    // Only a publisher-declared Course (not a document with a promising link title)
+    // establishes that the destination is actually an educational offering.
+    for (const [, block] of html.matchAll(/<script\b[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi)) {
+      let data: unknown;
+      try { data = JSON.parse(block!); } catch { continue; }
+      const candidates = Array.isArray(data) ? data : [data];
+      for (const candidate of candidates) {
+        const entries = candidate && typeof candidate === 'object' && '@graph' in candidate && Array.isArray(candidate['@graph']) ? candidate['@graph'] : [candidate];
+        for (const entry of entries) {
+          if (!entry || typeof entry !== 'object') continue;
+          const record = entry as Record<string, unknown>;
+          const types = Array.isArray(record['@type']) ? record['@type'] : [record['@type']];
+          if (!types.includes('Course') && !types.includes('https://schema.org/Course')) continue;
+          const title = typeof record.name === 'string' ? record.name.trim() : '';
+          const description = typeof record.description === 'string' ? record.description.trim() : '';
+          if (!title || !description) continue;
+          const unit = units.find(({ name, code }) => !!code && name.trim().length >= 3 &&
+            (title.includes(name.trim()) || description.includes(name.trim())));
+          if (!unit) continue;
+          courses.push({ title, url, matchedUnit: `${unit.code} ${unit.name}`, evidence: `발행 페이지 Course 메타데이터의 이름·설명에서 NCS 능력단위 「${unit.name}」 확인` });
+          break;
+        }
+        if (courses.some(course => course.url === url)) break;
+      }
+      if (courses.some(course => course.url === url)) break;
+    }
+  }
+  return courses;
+}

package/plugins/job-coach/graphs/recipes.yaml

@@ -0,0 +1,18 @@
+profile:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" profile'
+  timeout_ms: 30000
+ncs-match:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" ncs-match'
+  timeout_ms: 30000
+research:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" research'
+  timeout_ms: 120000
+gap:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" gap'
+  timeout_ms: 30000
+report:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" report'
+  timeout_ms: 30000
+judge:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" judge'
+  timeout_ms: 30000

package/plugins/job-coach/graphs/report.yaml

@@ -0,0 +1,20 @@
+graph_id: job-coach-report
+version: 1
+entry_node: profile
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: profile, kind: agent, recipe: 'cmd:profile', max_visits: 1 }
+  - { node_id: ncs-match, kind: agent, recipe: 'cmd:ncs-match', max_visits: 1 }
+  - { node_id: research, kind: agent, recipe: 'cmd:research', max_visits: 2 }
+  - { node_id: gap, kind: agent, recipe: 'cmd:gap', max_visits: 2 }
+  - { node_id: report, kind: agent, recipe: 'cmd:report', max_visits: 2 }
+  - { node_id: judge, kind: judge, recipe: 'cmd:judge', max_visits: 2 }
+  - { node_id: done, kind: gate, max_visits: 1 }
+  - { node_id: failed, kind: gate, max_visits: 1 }
+edges:
+  - { from: profile, on: outcome, map: { ok: ncs-match, fail: failed } }
+  - { from: ncs-match, on: outcome, map: { ok: research, fail: failed } }
+  - { from: research, on: outcome, map: { ok: gap, fail: failed } }
+  - { from: gap, on: outcome, map: { ok: report, fail: failed } }
+  - { from: report, on: outcome, map: { ok: judge, fail: failed } }
+  - { from: judge, on: outcome, map: { ok: done, retry: research, fail: failed } }

package/plugins/job-coach/graphs/run-step.ts

@@ -0,0 +1,108 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { callNcsTool } from '../connectors/ncs/server.js';
+import { courseLinks } from './course-links.js';
+
+type Data = Record<string, unknown>;
+const value = (object: unknown): Data => object && typeof object === 'object' && !Array.isArray(object) ? object as Data : {};
+const text = (item: unknown) => typeof item === 'string' ? item.trim() : '';
+const list = (item: unknown): string[] => Array.isArray(item) ? item.filter((v): v is string => typeof v === 'string' && !!v.trim()) : [];
+const line = (item: unknown) => text(item).replace(/[\r\n|]/g, ' ');
+const json = (data: Data) => console.log(JSON.stringify(data));
+const context = value(JSON.parse(readFileSync(process.env.ELANOUS_GRAPH_CONTEXT ?? '', 'utf8')));
+const input = value(context.input);
+const outputs = value(context.outputs);
+const contextsDir = dirname(process.env.ELANOUS_GRAPH_CONTEXT ?? '');
+if (!contextsDir.endsWith('.json.contexts')) throw new Error('invalid graph run context');
+const runStateFile = contextsDir.slice(0, -'.contexts'.length);
+const reportDir = runStateFile.slice(0, -'.json'.length);
+const reportFile = join(reportDir, 'report.md');
+
+async function run(step: string) {
+  if (step === 'profile') {
+    const path = text(input.interview);
+    if (!path || !path.endsWith('.md')) throw new Error('input.interview must name a Markdown interview file');
+    const interview = readFileSync(path, 'utf8').replace(/\r\n?/g, '\n');
+    if (!interview.trim()) throw new Error('empty interview');
+    // Structured interview headings are the documented input contract; no guessed competencies.
+    const field = (heading: string) => interview.split(`## ${heading}\n`)[1]?.split(/\n## /)[0]?.trim() ?? '';
+    const jobs = field('희망 직무').split(/[,\n]/).map(s => s.trim()).filter(Boolean);
+    const experiences = field('경험').split(/\n/).map(s => s.replace(/^[-*] /, '').trim()).filter(Boolean);
+    const skills = field('보유 역량').split(/[,\n]/).map(s => s.replace(/^[-*] /, '').trim()).filter(Boolean);
+    if (!jobs.length || !experiences.length || !skills.length) throw new Error('interview requires 희망 직무, 경험, 보유 역량 headings');
+    json({ jobs, skills, experienceCount: experiences.length });
+  } else if (step === 'ncs-match') {
+    const profile = value(outputs.profile);
+    const jobs = list(profile.jobs);
+    if (!jobs.length) throw new Error('missing profile jobs');
+    const results = await Promise.all(jobs.slice(0, 3).map(async (job) => ({ job, result: await callNcsTool('ncs_search_units', { keyword: job }) })));
+    const units = results.flatMap(({ job, result }) => {
+      const body = value(value(result).body);
+      const raw = value(body.items).item;
+      return (Array.isArray(raw) ? raw : raw ? [raw] : []).map(item => {
+        const unit = value(item);
+        return { job, code: line(unit.NCS_CL_CD ?? unit.NCS_COMPE_UNIT_CD), name: line(unit.COMPE_UNIT_NAME), definition: line(unit.COMPE_UNIT_DEF), source: text(value(result).source) };
+      }).filter(unit => unit.name && unit.code);
+    });
+    if (!units.length) throw new Error('NCS search returned no named competency units; cannot invent a match');
+    json({ units });
+  } else if (step === 'research') {
+    const profile = value(outputs.profile);
+    const query = `${list(profile.jobs).join(' ')} 역량 교육 과정 강의 공식 출처`;
+    if (!query.trim()) throw new Error('missing job for research');
+    const cli = Bun.spawn(['elanous', '--test', 'research', query, '--json'], { env: process.env, stdout: 'pipe', stderr: 'pipe' });
+    const stdout = await new Response(cli.stdout).text();
+    const stderr = await new Response(cli.stderr).text();
+    if (await cli.exited !== 0) throw new Error(`research failed: ${stderr.slice(0, 300)}`);
+    const result = JSON.parse(stdout) as unknown;
+    const ncs = value(outputs['ncs-match']);
+    const units = Array.isArray(ncs.units) ? ncs.units.map(value).map(unit => ({ name: text(unit.name), code: text(unit.code) })) : [];
+    if (!units.length) throw new Error('missing NCS units for course verification');
+    const courses = await courseLinks(result, units);
+    json({ courses });
+  } else if (step === 'gap') {
+    const profile = value(outputs.profile);
+    const ncs = value(outputs['ncs-match']);
+    const skills = list(profile.skills);
+    const units = Array.isArray(ncs.units) ? ncs.units.map(value) : [];
+    if (!units.length) throw new Error('missing NCS units');
+    const gaps = units.map(unit => ({ code: line(unit.code), name: line(unit.name), status: skills.some(skill => line(skill) === line(unit.name) && !!line(unit.name)) ? '보유(인터뷰 자기보고)' : '갭(증거 미확인)' }));
+    json({ gaps });
+  } else if (step === 'report') {
+    const profile = value(outputs.profile);
+    const ncs = value(outputs['ncs-match']);
+    const research = value(outputs.research);
+    const gap = value(outputs.gap);
+    const units = Array.isArray(ncs.units) ? ncs.units.map(value) : [];
+    const courses = Array.isArray(research.courses) ? research.courses.map(value) : [];
+    const gaps = Array.isArray(gap.gaps) ? gap.gaps.map(value) : [];
+    if (!units.length || !gaps.length) throw new Error('cannot report without NCS units and gaps');
+    const md = ['# AI 직무코치 보고서', '', '## 직무', ...list(profile.jobs).map(x => `- ${line(x)}`), '',
+      '## NCS 능력단위 매칭', ...units.map(x => `- ${line(x.code)} — ${line(x.name)} (${line(x.job)})`), '',
+      '## 역량 갭', ...gaps.map(x => `- ${line(x.code)} ${line(x.name)}: ${line(x.status)}`), '',
+      '## 추천 코스', ...(courses.length ? courses.map(x => `- [${line(x.title).replace(/[\[\]]/g, '')}](${text(x.url)}) — ${line(x.matchedUnit)}; ${line(x.evidence)}`) : ['- 확인된 관련 교육 과정 없음 (추천 미확인)']), '',
+      '## 출처', '- [한국산업인력공단 NCS 기준정보 조회](https://www.data.go.kr/data/15128213/openapi.do)',
+      ...courses.map(x => `- ${text(x.url)}`), '', '※ 보유 역량은 인터뷰 자기보고이며, 확인되지 않은 역량은 갭으로 표시합니다.', ''].join('\n');
+    mkdirSync(reportDir, { recursive: true });
+    writeFileSync(reportFile, md, { mode: 0o600 });
+    json({ report: reportFile });
+  } else if (step === 'judge') {
+    const report = text(value(outputs.report).report);
+    if (!report || report !== reportFile) throw new Error('missing report path');
+    const content = readFileSync(report, 'utf8');
+    const sections = ['직무', 'NCS 능력단위 매칭', '역량 갭', '추천 코스', '출처'];
+    const complete = sections.every((section, index) => {
+      const start = content.indexOf(`## ${section}\n`);
+      if (start < 0) return false;
+      const end = index + 1 < sections.length ? content.indexOf(`## ${sections[index + 1]}\n`, start) : content.length;
+      return end > start && content.slice(start + section.length + 4, end).includes('- ');
+    });
+    const visits = readFileSync(runStateFile, 'utf8');
+    const priorJudgeVisits = (JSON.parse(visits) as { path?: string[] }).path?.filter(node => node === 'judge').length ?? 0;
+    const courses = value(outputs.research).courses;
+    const hasVerifiedCourse = Array.isArray(courses) && courses.length > 0;
+    json({ outcome: !complete ? priorJudgeVisits < 2 ? 'retry' : 'fail' : !hasVerifiedCourse && priorJudgeVisits < 2 ? 'retry' : 'ok', report });
+  } else throw new Error(`unknown report step: ${step}`);
+}
+
+await run(process.argv[2] ?? '');

package/plugins/job-coach/plugin.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://antigravity.google/schemas/v1/plugin.json",
+  "name": "job-coach",
+  "version": "0.1.0",
+  "description": "Interview-to-NCS competency gap and cited course report.",
+  "extensions": {
+    "ai.elanous": {
+      "graphs": ["./graphs/report.yaml"],
+      "capabilities": ["network:fetch"],
+      "connectors": [{ "id": "ncs", "fields": [{ "name": "serviceKey", "secret": true }] }]
+    }
+  }
+}

package/plugins/job-coach/plugin.ts

@@ -0,0 +1,6 @@
+export default {
+  name: 'job-coach',
+  version: '0.1.0',
+  initialState: () => ({}),
+  panes: {},
+};

package/plugins/job-coach/skills/career-report/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: career-report
+description: Produce a career report from interview profile, verified NCS units and cited course research.
+---
+
+Write Markdown with sections `## 직무`, `## NCS 능력단위 매칭` (code, name and job), `## 역량 갭` (required unit vs self-reported possession), `## 추천 코스` (course title and real URL), and `## 출처` (NCS catalog and course URLs). Do not infer confirmed competency from an interview; label gaps `증거 미확인`. Do not invent NCS units or course URLs. A search link alone is not a course: inspect the publisher's page, confirm it declares an actual course, and cite which NCS unit appears in the course name or description. Only verified, relevant courses belong in `추천 코스`; otherwise write `확인된 관련 교육 과정 없음 (추천 미확인)`. Unverified search links are not recommendations. If the NCS key or NCS sources are unavailable, return an explicit error rather than a plausible report. Never echo the original interview or credential to a log.

package/plugins/job-coach/skills/interview-to-profile/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: interview-to-profile
+description: Extract career candidates, experience and self-reported skills from a Korean interview.
+---
+
+Read the interview Markdown. Extract, without invention, `jobs` (target job candidates), `skills` (self-reported capabilities) and `experienceCount` (number of concrete work or project descriptions). Do not persist the raw descriptions in graph stdout. Record unknowns as missing rather than extrapolating. Never print or log the original interview. For the packaged graph, prepare headings `## 희망 직무`, `## 경험`, `## 보유 역량`; list items for experience and comma-separated skills. A job is a candidate, not a confirmed NCS code.

package/plugins/job-coach/skills/run-report/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: run-report
+description: Run the job-coach NCS competency and course report in elanous or Codex.
+---
+
+If an elanous MCP graph-run tool with the installed `job-coach:report` alias is present, call it with `{ "interview": "<absolute path to Markdown interview>" }`. For a file-based run, use `elanous graph run <installed plugin root>/graphs/report.yaml --input '{"interview":"<absolute path>"}'`. Do not claim this alias is available in the current file-only graph CLI. Inspect the returned run state and read `<state>/graph-runs/job-coach-report/<run-id>/report.md` only after `status: done`.
+
+Without the elanous graph tool, perform these steps with the other two packaged skills:
+1. `interview-to-profile`: extract job candidates, experience count and self-reported skills.
+2. Call NCS MCP `ncs_search_units` for each candidate keyword and `ncs_unit` for a selected full classification code; keep official codes/names and NCS source. If `NCS_SERVICE_KEY` is absent, stop with an explicit missing-key error.
+3. Research courses and learning materials externally. A search hit alone is not a recommendation: inspect the publisher's course page, confirm it describes an actual course, and match the name or description to a cited NCS unit. Record that relevance evidence and the direct URL. Treat documents and unrelated or unverified courses as research leads, not recommendations; if no course qualifies, mark recommendations unverified. Do not invent courses or sources.
+4. Compare NCS unit requirements with the interview's *self-reported* skills; missing evidence is a gap, not proof of incapacity.
+5. Use `career-report` for the Markdown sections; check that every section contains evidence and a citation. On an empty section, research once more and recheck. If still empty, report the deficiency rather than fabricate content.
+
+Keep interview text and API credentials out of logs and repository artifacts.