elanous 0.2.0 → 0.2.5

package/graphs/video/broll-line.yaml

@@ -0,0 +1,54 @@
+# Word-aligned narration → density-aware B-roll → composited video → measured QC.
+graph_id: broll-line
+version: 1
+entry_node: align
+terminal_nodes: [delivered, skipped, blocked, unobserved]
+nodes:
+  - node_id: align
+    kind: agent
+    recipe: broll-align-words
+    max_visits: 2
+    contract: { inputs: [audio_path], tools: network-write, outputs: [aligned_words, narration_seconds] }
+  - node_id: plan
+    kind: agent
+    recipe: broll-density-plan
+    max_visits: 2
+    contract: { inputs: [aligned_words, density_target], tools: read-only, outputs: [broll_slots, target_clips] }
+  - node_id: clips
+    kind: agent
+    recipe: broll-select-clips
+    max_visits: 2
+    contract: { inputs: [broll_slots, clips_dir], tools: network-write, outputs: [broll_clips, skipped_clips] }
+  - node_id: assemble
+    kind: agent
+    recipe: broll-render
+    max_visits: 2
+    contract: { inputs: [base_video, broll_clips, clips_dir], tools: workspace-write, outputs: [rendered_path, rendered_clips] }
+  - node_id: qc
+    kind: gate
+    recipe: broll-qc
+    max_visits: 2
+    contract: { inputs: [rendered_path, rendered_clips, density_target], tools: read-and-run, outputs: [qc_pass, qc_seconds, density_actual] }
+  - node_id: delivered
+    kind: judge
+    recipe: terminal-delivered
+    max_visits: 1
+  - node_id: skipped
+    kind: judge
+    recipe: terminal-skipped
+    max_visits: 1
+  - node_id: blocked
+    kind: judge
+    recipe: terminal-blocked
+    max_visits: 1
+  - node_id: unobserved
+    kind: judge
+    recipe: terminal-unobserved
+    max_visits: 1
+edges:
+  - { from: align, on: outcome, map: { ok: plan, error: blocked, unmeasurable: unobserved } }
+  - { from: plan, on: outcome, map: { ok: clips, unmeasurable: unobserved } }
+  # A timed-out clip is skipped inside the recipe; any selected clip still renders.
+  - { from: clips, on: outcome, map: { ok: assemble, empty: skipped, unmeasurable: unobserved } }
+  - { from: assemble, on: outcome, map: { ok: qc, empty: skipped, error: assemble, unmeasurable: unobserved } }
+  - { from: qc, on: outcome, map: { pass: delivered, fail: assemble, unmeasurable: unobserved } }

package/graphs/video/explainer-line.yaml

@@ -0,0 +1,58 @@
+# «N가지 한 번에 정리» explainer: facts → script → timed VO → composition → checked render → measured QC.
+# Engine = skills/explainer-video (vo.ts · build.mjs). Render/snapshot/check = the existing hyperframes-render recipe.
+# ⚠️ Recipes explainer-script / explainer-vo / explainer-build / explainer-qc are declared here and not yet coded
+#    (src/video-pipeline/recipes) — a walk stops at the first of them as «unknown recipe». Until then the skill runs these steps.
+graph_id: explainer-line
+version: 1
+entry_node: script
+terminal_nodes: [delivered, needs-human, blocked, unobserved]
+nodes:
+  - node_id: script
+    kind: agent
+    recipe: explainer-script
+    max_visits: 3
+    contract: { inputs: [facts, sources], tools: read-only, outputs: [script_path] }
+  - node_id: vo
+    kind: agent
+    recipe: explainer-vo
+    max_visits: 2
+    contract: { inputs: [script_path], tools: network-write, outputs: [vo_dir, narration_seconds] }
+  - node_id: build
+    kind: agent
+    recipe: explainer-build
+    max_visits: 3
+    contract: { inputs: [script_path, vo_dir], tools: workspace-write, outputs: [hyperframes_project, timeline_path] }
+  - node_id: render
+    kind: gate
+    recipe: hyperframes-render
+    max_visits: 2
+    contract: { inputs: [hyperframes_project], tools: workspace-write, outputs: [hf_render_path, hf_snapshot_dir, hf_check] }
+  - node_id: qc
+    kind: gate
+    recipe: explainer-qc
+    max_visits: 2
+    contract: { inputs: [hf_render_path, script_path], tools: read-and-run, outputs: [vo_match, loudness_lufs, true_peak_db] }
+  - node_id: delivered
+    kind: judge
+    recipe: terminal-delivered
+    max_visits: 1
+  - node_id: needs-human
+    kind: judge
+    recipe: terminal-needs-human
+    max_visits: 1
+  - node_id: blocked
+    kind: judge
+    recipe: terminal-blocked
+    max_visits: 1
+  - node_id: unobserved
+    kind: judge
+    recipe: terminal-unobserved
+    max_visits: 1
+edges:
+  - { from: script, on: outcome, map: { ok: vo, no-facts: needs-human, unmeasurable: unobserved } }
+  - { from: vo, on: outcome, map: { ok: build, no-key: needs-human, error: blocked, unmeasurable: unobserved } }
+  - { from: build, on: outcome, map: { ok: render, bad-script: script, error: blocked, unmeasurable: unobserved } }
+  # check/snapshot failures are layout faults → rebuild; a wrong-length render is a timing fault → rebuild too.
+  - { from: render, on: outcome, map: { ok: qc, check-fail: build, render-mismatch: build, unmeasurable: unobserved } }
+  # speech ≠ script → re-voice that line; loudness off → rebuild (mix lives in the composition); public release is a human call.
+  - { from: qc, on: outcome, map: { pass: delivered, vo-mismatch: vo, loudness: build, public: needs-human, unmeasurable: unobserved } }

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "elanous",
-  "version": "0.2.0",
+  "version": "0.2.5",
   "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",
+  "author": "Elanvital AI",
+  "homepage": "https://elanous.ai",
   "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 +38,7 @@
     ".rules/",
     "docs/goal-context/",
     "docs/design/craft/",
+    "docs/design/systems/",
     "docs/mission-requests/",
     "docs/ad-presets/",
     "!**/*.test.ts",
@@ -81,7 +84,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 +94,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,23 @@
+{
+  "name": "job-coach",
+  "version": "0.1.0",
+  "description": "Interview-to-NCS competency gap and cited course report.",
+  "skills": "./skills/",
+  "contributes": {
+    "skills": [
+      { "name": "interview-to-profile" },
+      { "name": "career-report" },
+      { "name": "run-report" },
+      { "name": "enterprise-needs" },
+      { "name": "enterprise-task-analysis" },
+      { "name": "enterprise-ai-fit" },
+      { "name": "enterprise-competency" },
+      { "name": "enterprise-roadmap" }
+    ]
+  },
+  "extensions": {
+    "ai.elanous": {
+      "graphs": ["./graphs/report.yaml", "./graphs/report-enterprise.yaml"]
+    }
+  }
+}

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,32 @@
+# job-coach — AI 직무코치
+
+**S** 인터뷰에서 직무 후보를 추출해 공공데이터포털의 NCS 능력단위와 비교하고, 외부 코스 조사로 보고서를 작성한다. **C** 실제 NCS 키와 코스 출처가 없으면 매칭·추천을 지어낼 수 없다. **Q** 이 패키지를 받은 사용자가 어떻게 실행하고 결과를 확인하는가? **A** 아래 실행 방법과 검증 방법을 따른다.
+
+## 개인 모드 · 기업 HRD 모드
+
+개인 모드(`report.yaml`)는 `## 희망 직무`, `## 경험`, `## 보유 역량` 인터뷰를 읽고 직무 후보 → NCS 매칭 → 검증된 과정 조사 → 자기보고 역량 갭 → 개인 보고서로 진행한다. NCS 키가 없으면 실패하며 확인된 과정 URL이 없으면 추천을 `미확인`으로 표시한다. 개인 보고서의 다섯 섹션과 기존 `research` 재시도 계약은 유지한다.
+
+기업 HRD 모드(`report-enterprise.yaml`)는 `## 기업 개요`, `## 교육 대상`, `## 현업 과제`, `## 교육 목표`, `## 현재 역량`, `## 교육 제약`의 인터뷰를 받는다. 가상 회사·가상 직원으로 입력을 시험하고 실제 직원 정보나 내부 정책을 예시 파일에 싣지 않는다. 같은 NCS 조회를 재사용해 니즈 → 현업 과제 → NCS → AI 적합성(비AI 대안 포함) → 역량 → 로드맵 → 교육 명세와 운영 경로를 만든 뒤 일곱 섹션을 판정한다. 섹션 또는 근거가 누락되면 보고 단계로 한 번 되돌리고 다시 판정한다. 인터뷰 진술은 자기보고이고, NCS 코드·과정/URL·사내 정책 및 AI 도입 승인은 조회·확인 전에는 `미확인`이다.
+
+```sh
+elanous graph run /absolute/path/to/installed/job-coach/graphs/report-enterprise.yaml --input '{"interview":"/private/path/to/fictional-enterprise.md"}' --json
+```
+
+기업 보고서는 `기업 개요 및 교육 대상`, `교육 니즈`, `직무·과제 및 NCS`, `AI 적합성`, `역량 진단`, `교육 로드맵`, `교육 명세·운영 경로` 순서다. NCS 조회에 실패하면 매칭을 발명하지 않고 런을 실패로 종료한다. `run-report` 스킬은 개인 보고서 진입이며 기업 모드는 다섯 개 기업 스킬(`enterprise-needs`, `enterprise-task-analysis`, `enterprise-ai-fit`, `enterprise-competency`, `enterprise-roadmap`)과 기업 그래프를 이용한다.
+
+## 실행
+
+공공데이터포털 [한국산업인력공단 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,90 @@
+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 its NCS_COMPE_UNIT_CD (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 competency unit 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.slice(0, 8));
+    params.set('NCS_COMPE_UNIT_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/gap-judge.ts

@@ -0,0 +1,44 @@
+export type GapUnit = { code: string; name: string; definition: string; level: string; elements: { name: string; criteria: string }[] };
+export type GapVerdict = { code: string; name: string; status: '보유' | '부분' | '갭'; quote: string };
+
+type Judge = (prompt: string) => Promise<string>;
+export const MAX_GAP_PROMPT_CHARS = 12000;
+
+export function gapPrompt(units: GapUnit[], interview: string): string {
+  return [
+    '인터뷰 원문과 공식 NCS 능력단위의 능력단위요소·수행준거·수준을 대조한다.',
+    '각 단위별 보유(수행준거를 충족하는 구체적 경험), 부분(일부만 입증), 갭(근거 없음) 중 하나를 판정한다.',
+    '단위 이름·보유 역량 목록만으로 보유를 추정하지 말고 원문에서 정확한 한 문장을 quote로 그대로 인용한다.',
+    '반드시 JSON 객체 {"gaps":[{"code":"...","status":"보유|부분|갭","quote":"..."}]}만 출력한다. 모든 code를 각각 한 번씩 포함한다.',
+    'NCS 단위:', JSON.stringify(units), '인터뷰 원문:', interview,
+  ].join('\n');
+}
+
+function completeSentence(interview: string, quote: string): boolean {
+  if (!quote || /[\r\n]/.test(quote) || !/[.!?。！？]$/.test(quote) || /[.!?。！？]\s*\S/.test(quote.slice(0, -1))) return false;
+  let from = 0;
+  while (true) {
+    const index = interview.indexOf(quote, from);
+    if (index < 0) return false;
+    const before = interview.slice(0, index);
+    if (/(?:^|[.!?。！？]|\n)[ \t]*(?:[-*][ \t]+)?$/.test(before) && !/[\p{L}\p{N}]/u.test(interview[index + quote.length] ?? '')) return true;
+    from = index + 1;
+  }
+}
+
+export async function judgeGaps(units: GapUnit[], interview: string, judge: Judge): Promise<GapVerdict[]> {
+  const prompt = gapPrompt(units, interview);
+  if (prompt.length > MAX_GAP_PROMPT_CHARS) throw new Error('gap prompt exceeds input limit; interview or NCS detail is too long');
+  const answer = await judge(prompt);
+  let parsed: unknown;
+  try { parsed = JSON.parse(answer.replace(/^```(?:json)?\s*|\s*```$/g, '').trim()); } catch { parsed = {}; }
+  const rows = (parsed && typeof parsed === 'object' && 'gaps' in parsed && Array.isArray(parsed.gaps)) ? parsed.gaps : [];
+  return units.map(unit => {
+    const matches = rows.filter(row => row && typeof row === 'object' && row.code === unit.code);
+    const row = matches.length === 1 ? matches[0] as { status?: unknown; quote?: unknown } : {};
+    const quote = typeof row.quote === 'string' ? row.quote.trim() : '';
+    const isSentence = completeSentence(interview, quote);
+    const status = isSentence && (row.status === '보유' || row.status === '부분') ? row.status : '갭';
+    return { code: unit.code, name: unit.name, status, quote: isSentence ? quote : '' };
+  });
+}

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

@@ -0,0 +1,45 @@
+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
+intake:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" intake'
+  timeout_ms: 30000
+needs:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" needs'
+  timeout_ms: 30000
+task:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" task'
+  timeout_ms: 30000
+ai-fit:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" ai-fit'
+  timeout_ms: 30000
+competency:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" competency'
+  timeout_ms: 30000
+roadmap:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" roadmap'
+  timeout_ms: 30000
+spec:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" spec'
+  timeout_ms: 30000
+routing:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" routing'
+  timeout_ms: 30000
+judge-enterprise:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" judge-enterprise'
+  timeout_ms: 30000

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

@@ -0,0 +1,28 @@
+graph_id: job-coach-report-enterprise
+version: 1
+entry_node: intake
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: intake, kind: agent, recipe: 'cmd:intake', max_visits: 1 }
+  - { node_id: needs, kind: agent, recipe: 'cmd:needs', max_visits: 1 }
+  - { node_id: task, kind: agent, recipe: 'cmd:task', max_visits: 1 }
+  - { node_id: ncs-match, kind: agent, recipe: 'cmd:ncs-match', max_visits: 1 }
+  - { node_id: ai-fit, kind: agent, recipe: 'cmd:ai-fit', max_visits: 2 }
+  - { node_id: competency, kind: agent, recipe: 'cmd:competency', max_visits: 2 }
+  - { node_id: roadmap, kind: agent, recipe: 'cmd:roadmap', max_visits: 2 }
+  - { node_id: spec, kind: agent, recipe: 'cmd:spec', max_visits: 2 }
+  - { node_id: routing, kind: agent, recipe: 'cmd:routing', max_visits: 2 }
+  - { node_id: judge, kind: judge, recipe: 'cmd:judge-enterprise', max_visits: 2 }
+  - { node_id: done, kind: gate, max_visits: 1 }
+  - { node_id: failed, kind: gate, max_visits: 1 }
+edges:
+  - { from: intake, on: outcome, map: { ok: needs, fail: failed } }
+  - { from: needs, on: outcome, map: { ok: task, fail: failed } }
+  - { from: task, on: outcome, map: { ok: ncs-match, fail: failed } }
+  - { from: ncs-match, on: outcome, map: { ok: ai-fit, fail: failed } }
+  - { from: ai-fit, on: outcome, map: { ok: competency, fail: failed } }
+  - { from: competency, on: outcome, map: { ok: roadmap, fail: failed } }
+  - { from: roadmap, on: outcome, map: { ok: spec, fail: failed } }
+  - { from: spec, on: outcome, map: { ok: routing, fail: failed } }
+  - { from: routing, on: outcome, map: { ok: judge, fail: failed } }
+  - { from: judge, on: outcome, map: { ok: done, retry: ai-fit, fail: failed } }

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 } }