elanous 0.2.4 → 0.2.6

package/plugins/geo-check/graphs/run-step.ts

@@ -0,0 +1,177 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+type Data = Record<string, unknown>;
+const object = (v: unknown): Data => v !== null && typeof v === 'object' && !Array.isArray(v) ? v as Data : {};
+const text = (v: unknown): string => typeof v === 'string' ? v.trim() : '';
+const strings = (v: unknown): string[] => Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string' && !!x.trim()) : [];
+const rows = (v: unknown): Data[] => Array.isArray(v) ? v.map(object) : [];
+const line = (v: unknown): string => text(v).replace(/[\r\n|]+/g, ' ');
+const errorLine = (e: unknown): string => line(e instanceof Error ? e.message : String(e)).slice(0, 240) || 'unknown error';
+try {
+const contextPath = process.env.ELANOUS_GRAPH_CONTEXT ?? '';
+const context = object(JSON.parse(readFileSync(contextPath, 'utf8')));
+const input = object(context.input);
+const outputs = object(context.outputs);
+const stateDirectory = dirname(contextPath);
+if (!stateDirectory.endsWith('.json.contexts')) throw new Error('invalid graph run context');
+const defaultOutDir = stateDirectory.slice(0, -'.json.contexts'.length);
+const brand = text(input.brand);
+if (!brand) throw new Error('brand is required');
+const engines = input.engines === undefined ? ['openai-codex', 'grok'] : strings(input.engines);
+if (!engines.length || engines.length > 3 || engines.length !== new Set(engines).size || (input.engines !== undefined && (!Array.isArray(input.engines) || strings(input.engines).length !== input.engines.length))) throw new Error('engines must contain 1 to 3 distinct names');
+const cli = process.env.GEO_CHECK_ELANOUS_BIN || 'elanous';
+
+async function invoke(args: string[], engine?: string): Promise<unknown> {
+  const proc = Bun.spawn([cli, ...args], {
+    env: { ...process.env, ...(engine ? { ELANOUS_LLM_PROVIDER: engine } : {}) },
+    stdout: 'pipe', stderr: 'pipe',
+  });
+  const [stdout, stderr, exit] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]);
+  if (exit !== 0) throw new Error(line(stderr || stdout) || `CLI exited ${exit}`);
+  const last = stdout.trim().split('\n').at(-1);
+  if (!last) throw new Error('CLI returned no JSON');
+  return JSON.parse(last) as unknown;
+}
+function reply(raw: unknown): string {
+  const result = object(raw);
+  if (typeof result.reply !== 'string') throw new Error('ask returned no reply');
+  return result.reply;
+}
+function parseArray(raw: string): unknown {
+  const cleaned = raw.trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+  return JSON.parse(cleaned) as unknown;
+}
+function domains(v: string): string {
+  const raw = v.trim().replace(/^https?:\/\//i, '').replace(/^www\./i, '').replace(/\/+$/, '');
+  return raw.split('/')[0]?.toLowerCase().replace(/:\d+$/, '') ?? '';
+}
+function urls(v: unknown): string[] {
+  if (Array.isArray(v)) return v.flatMap(urls);
+  if (typeof v === 'string') return [...v.matchAll(/https?:\/\/[^\s<>"')\]]+/gi)].map(m => m[0]!.replace(/[.,;!?]+$/, ''));
+  if (v && typeof v === 'object') return Object.entries(v).flatMap(([key, item]) => key === 'url' && typeof item === 'string' ? [item] : urls(item));
+  return [];
+}
+// `elanous research --json` = { query, output, metadata } — result links are `- [title](url)` lines in `output`.
+// Only those links count; the query string or other fields may name the brand domain without it being a result.
+function resultUrls(raw: unknown): string[] {
+  const out = object(raw).output;
+  if (typeof out !== 'string') return [];
+  return [...out.matchAll(/^\s*-\s*\[[^\]]*\]\((https?:\/\/[^)\s]+)\)/gm)].map(m => m[1]!);
+}
+// A bare domain in the answer text («see elanous.ai») is a citation too, not only an https:// link.
+function mentionsHost(answer: string, host: string): boolean {
+  if (!host) return false;
+  const escaped = host.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`(^|[^a-z0-9.-])(?:www\\.)?${escaped}(?![a-z0-9-])`, 'i').test(answer);
+}
+function cited(url: string, host: string): boolean {
+  try {
+    const name = new URL(url).hostname.toLowerCase().replace(/^www\./, '');
+    return name === host || name.endsWith(`.${host}`);
+  } catch { return false; }
+}
+function firstMention(answer: string, name: string): number | null {
+  const lower = answer.toLocaleLowerCase();
+  const needle = name.toLocaleLowerCase();
+  let at = lower.indexOf(needle);
+  while (at >= 0) {
+    const before = at ? lower[at - 1]! : '';
+    const after = lower[at + needle.length] ?? '';
+    if (!/[\p{L}\p{N}_]/u.test(before) && !/[\p{L}\p{N}_]/u.test(after)) return at;
+    at = lower.indexOf(needle, at + 1);
+  }
+  return null;
+}
+function output(result: Data, calls = 0, errors = 0): void {
+  console.log(JSON.stringify({ ...result, calls, errors }));
+}
+
+async function run(step: string): Promise<void> {
+  if (step === 'questions') {
+    if (input.questions !== undefined && !Array.isArray(input.questions)) throw new Error('questions must be an array');
+    const provided = strings(input.questions);
+    if (provided.length > 8 || (Array.isArray(input.questions) && provided.length !== input.questions.length)) throw new Error('questions must contain at most 8 nonempty strings');
+    if (provided.length) { output({ questions: provided }); return; }
+    try {
+      const response = reply(await invoke(['ask', '--json', `Generate exactly 5 potential customer questions about the category of ${brand}. Respond ONLY with a JSON array of 5 question strings. Do not include the brand name in any question.`]));
+      const generated = parseArray(response);
+      if (!Array.isArray(generated) || generated.length !== 5 || strings(generated).length !== 5 || strings(generated).some(q => q.toLocaleLowerCase().includes(brand.toLocaleLowerCase()))) throw new Error('ask returned invalid or branded questions');
+      output({ questions: generated }, 1);
+    } catch (e) { output({ outcome: 'fail', questions: [], error: errorLine(e) }, 1, 1); }
+  } else if (step === 'answers') {
+    const questions = strings(object(outputs.questions).questions);
+    if (!questions.length || questions.length > 8) throw new Error('missing questions');
+    const answers: Data[] = [];
+    let failures = 0;
+    for (const question of questions) for (const engine of engines) {
+      try { answers.push({ question, engine, answer: reply(await invoke(['ask', '--json', question], engine)) }); }
+      catch (e) { failures++; answers.push({ question, engine, error: errorLine(e) }); }
+    }
+    output({ answers, outcome: failures === answers.length ? 'fail' : 'ok' }, answers.length, failures);
+  } else if (step === 'web') {
+    const questions = strings(object(outputs.questions).questions);
+    const web: Data[] = [];
+    let failures = 0;
+    for (const question of questions) {
+      try { web.push({ question, urls: resultUrls(await invoke(['research', '--json', '--limit', '5', question])).slice(0, 5) }); }
+      catch (e) { failures++; web.push({ question, urls: [], error: errorLine(e) }); }
+    }
+    output({ web }, questions.length, failures);
+  } else if (step === 'score') {
+    const answers = rows(object(outputs.answers).answers);
+    const web = rows(object(outputs.web).web);
+    if (!answers.length) throw new Error('missing answers');
+    const domain = domains(text(input.domain));
+    const table = answers.map(cell => {
+      const answer = text(cell.answer);
+      if (cell.error) return { question: cell.question, engine: cell.engine, error: cell.error, mention: false, citation: domain ? false : null, rank: null };
+      const position = firstMention(answer, brand);
+      const candidates = [...urls(answer), ...strings(web.find(row => row.question === cell.question)?.urls)];
+      return { question: cell.question, engine: cell.engine, mention: position !== null,
+        citation: domain ? candidates.some(url => cited(url, domain)) || mentionsHost(answer, domain) : null, rank: position === null ? null : answer.slice(0, position).trim().split(/\s+/).filter(Boolean).length + 1 };
+    });
+    output({ table }, 0, table.filter(cell => cell.error).length);
+  } else if (step === 'suggest') {
+    const table = rows(object(outputs.score).table);
+    if (!table.length) throw new Error('missing score table');
+    const gaps = table.filter(cell => cell.error || !cell.mention || cell.citation === false).map(cell => ({ question: cell.question, engine: cell.engine, error: cell.error ?? null, mention: cell.mention, citation: cell.citation }));
+    if (!gaps.length) { output({ suggestions: [] }); return; }
+    try {
+      const raw = parseArray(reply(await invoke(['ask', '--json', `Using ONLY this score table, return a JSON array of 3 to 5 improvement suggestions. Each must have "suggestion" (FAQ question, FAQPage/Organization structured data, comparison document, etc.) and "evidence" containing a question and engine from the missing cells. Evidence cells: ${JSON.stringify(gaps)}. Score table: ${JSON.stringify(table)}`])));
+      if (!Array.isArray(raw) || raw.length < 3 || raw.length > 5) throw new Error('invalid suggestion count');
+      const suggestions = raw.map(item => {
+        const candidate = object(item);
+        const evidence = object(candidate.evidence);
+        const match = gaps.find(cell => cell.question === evidence.question && cell.engine === evidence.engine);
+        if (!text(candidate.suggestion) || !match) throw new Error('suggestion missing valid score evidence');
+        return { suggestion: text(candidate.suggestion), evidence: { question: match.question, engine: match.engine } };
+      });
+      output({ suggestions }, 1);
+    } catch (e) { output({ outcome: 'fail', suggestions: [], error: errorLine(e) }, 1, 1); }
+  } else if (step === 'report') {
+    const table = rows(object(outputs.score).table);
+    const answers = rows(object(outputs.answers).answers);
+    const suggestions = rows(object(outputs.suggest).suggestions);
+    if (!table.length) throw new Error('missing score table');
+    const outDir = text(input.outDir) || defaultOutDir;
+    const success = table.filter(cell => !cell.error);
+    const citationSummary = text(input.domain) ? `${success.filter(cell => cell.citation).length}/${success.length} cite ${text(input.domain)}.` : 'Citation unknown (no domain provided).';
+    const summary = `${brand}: ${success.filter(cell => cell.mention).length}/${success.length} available answers mention the brand; ${citationSummary}`;
+    const markdown = [`# GEO check — ${line(brand)}`, '', summary, '', '| Question | Engine | Mention | Citation | Rank | Error |', '| --- | --- | --- | --- | --- | --- |',
+      ...table.map(cell => `| ${line(cell.question)} | ${line(cell.engine)} | ${cell.mention ? 'yes' : 'no'} | ${cell.citation === null ? 'unknown' : cell.citation ? 'yes' : 'no'} | ${cell.rank ?? '—'} | ${line(cell.error)} |`),
+      '', '## Suggestions', ...suggestions.map(item => `- ${line(item.suggestion)} — ${line(object(item.evidence).question)} / ${line(object(item.evidence).engine)}`),
+      '', '## Answers', ...answers.map(cell => `### ${line(cell.question)} — ${line(cell.engine)}\n\n${line(cell.error) || text(cell.answer).slice(0, 400)}\n`), ''].join('\n');
+    mkdirSync(outDir, { recursive: true });
+    const md = join(outDir, 'report.md');
+    const json = join(outDir, 'report.json');
+    writeFileSync(md, markdown, { mode: 0o600 });
+    writeFileSync(json, JSON.stringify({ brand, domain: text(input.domain), summary, table, suggestions, answers }, null, 2) + '\n', { mode: 0o600 });
+    output({ report: md, reportJson: json, summary }, 0, table.filter(cell => cell.error).length);
+  } else throw new Error(`unknown geo-check step: ${step}`);
+}
+
+await run(process.argv[2] ?? '');
+} catch (e) {
+  console.log(JSON.stringify({ outcome: 'fail', error: errorLine(e), calls: 0, errors: 1 }));
+}

package/plugins/geo-check/plugin.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://antigravity.google/schemas/v1/plugin.json",
+  "name": "geo-check",
+  "version": "0.1.0",
+  "description": "Measure brand mentions and citations in AI answers and web results.",
+  "extensions": {
+    "ai.elanous": {
+      "graphs": [
+        "./graphs/geo-check.yaml"
+      ],
+      "capabilities": [
+        "fs:workdir",
+        "proc:bun",
+        "proc:elanous"
+      ],
+      "connectors": [],
+      "pricing": {
+        "model": "free"
+      },
+      "trust": "official",
+      "category": "Marketing"
+    }
+  }
+}

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

@@ -2,5 +2,22 @@
   "name": "job-coach",
   "version": "0.1.0",
   "description": "Interview-to-NCS competency gap and cited course report.",
-  "skills": "./skills/"
+  "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/README.md

@@ -2,6 +2,48 @@
 
 **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
+```
+
+### 기업 모드 샘플 입력 (가상 정보만)
+
+다음은 **가상 인물** 민서 하와 **가상 회사** 푸른달 스튜디오의 예시다. 이미지 경로는 실제 사진이 아닌 플레이스홀더이며, 인터뷰 안의 참고용 표기일 뿐이다. 그래프 입력 필드는 `interview` 하나로, 이미지 파일을 읽거나 전송하는 입력은 없다. 비공개 작업 디렉터리에 `fictional-enterprise.md`로 저장한 뒤 위 명령의 `interview` 경로를 그 파일의 절대 경로로 바꾼다.
+
+```markdown
+## 기업 개요
+푸른달 스튜디오 (가상 회사). 이미지 참고 경로: /placeholder/images/fictional-company.png
+
+## 교육 대상
+민서 하 (가상 인물), 문서 기획 담당자
+
+## 현업 과제
+가상 행사 안내 문서의 기획
+
+## 교육 목표
+행사 안내 문서를 요구사항에 맞게 기획한다
+
+## 현재 역량
+문서 작성 경험 (자기보고)
+
+## 교육 제약
+예산과 승인 여부 미확인
+```
+
+### 입력·출력과 프라이버시 경계
+
+입력은 기업 모드 인터뷰 Markdown **파일의 비공개 절대 경로**를 담은 `--input '{"interview":"/private/path/to/fictional-enterprise.md"}'`이다. 위 여섯 `##` 섹션이 필요하다. 실제 직원 이름·사진·인사정보·사내 기밀을 샘플, 명령 인자 또는 공개 저장소에 넣지 않는다. 실제 인터뷰를 사용할 경우에도 민감 정보를 제거하고 접근 제한된 저장소에서만 실행한다. 그래프 러너는 입력·노드 stdout을 런 상태와 컨텍스트 JSON에 저장하므로 **파일 경로만 인자로 넘겨도 보고서와 런 상태에는 인터뷰에서 파생된 직무·역량이 남는다**. 파일 경로가 개인정보 비노출이나 무저장을 보장하는 것은 아니다.
+
+출력은 CLI의 상태 JSON(`statePath`와 `done`/`failed`) 및 그 상태 경로와 같은 디렉터리의 `<run-id>/report.md`다. 보고서는 아래 일곱 섹션으로 구성된다. NCS 조회가 실패하면 `failed`로 끝나며 확인되지 않은 과정·URL 및 내부 승인 여부는 `미확인`으로 남긴다. **No-send boundary:** 이 그래프 실행은 보고서를 로컬에 작성하는 경로이며 메신저·이메일로 보고서를 보내거나 마켓에 게시하는 단계가 없다. `--no-send` 플래그를 지원한다고 가정하지 않는다. 다만 NCS API 조회 및 외부 과정 조사는 네트워크 요청이므로 오프라인·무외부전송 실행이 아니다. 보고서 배포나 마켓 게시/시장 출시는 이 플러그인 README의 범위 밖이다.
+
+기업 보고서는 `기업 개요 및 교육 대상`, `교육 니즈`, `직무·과제 및 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`를 붙여 격리한다. 인터뷰 파일은 `## 희망 직무`, `## 경험`, `## 보유 역량`을 포함해야 한다.

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

@@ -8,7 +8,7 @@ const schema = (properties: Record<string, unknown>, required: string[]) => ({ t
 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_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']) },
 ];
 
@@ -31,9 +31,10 @@ export async function callNcsTool(name: string, args: Arguments, options: { key?
   } 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');
+    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);
+    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');

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

@@ -16,3 +16,30 @@ report:
 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 } }