elanous 0.2.4 → 0.2.5

package/graphs/release/release-loop.yaml

@@ -1,3 +1,4 @@
+# Inputs gateRemote (SSH host, e.g. node-b) and gateRemoteMirror (bare mirror path, default ~/mirror/elanous-agent.git): run gate sweeps in temporary remote clones without a matching caller checkout; omit gateRemote for local execution.
 graph_id: release-loop
 loop:
   title: 릴리스
@@ -17,6 +18,8 @@ nodes:
   - { node_id: upgrade, kind: gate, recipe: 'cmd:upgrade', max_visits: 1 }
   - { node_id: tui, kind: gate, recipe: 'cmd:tui', max_visits: 1 }
   - { node_id: docs, kind: agent, recipe: 'cmd:docs', max_visits: 1 }
+  - { node_id: notes-check, kind: gate, recipe: 'cmd:notes-check', max_visits: 1 }
+  - { node_id: auto-approve, kind: gate, recipe: 'cmd:auto-approve', max_visits: 1 }
   - { node_id: approve-publish, kind: hitl, recipe: 'approval:publish', max_visits: 1 }
   - { node_id: publish, kind: git, recipe: 'cmd:publish-command', max_visits: 1 }
   - { node_id: docs-land, kind: git, recipe: 'cmd:docs-land', max_visits: 1 }
@@ -32,7 +35,9 @@ edges:
   - { from: prepare, on: outcome, map: { ok: upgrade, fail: failed, error: failed } }
   - { from: upgrade, on: outcome, map: { ok: tui, fail: failed, error: failed } }
   - { from: tui, on: outcome, map: { ok: docs, fail: failed, error: failed } }
-  - { from: docs, on: outcome, map: { ok: approve-publish, fail: failed, error: failed } }
+  - { from: docs, on: outcome, map: { ok: notes-check, fail: failed, error: failed } }
+  - { from: notes-check, on: outcome, map: { ok: auto-approve, fail: failed, error: failed } }
+  - { from: auto-approve, on: outcome, map: { ok: publish, fail: approve-publish, error: approve-publish } }
   - { from: approve-publish, on: outcome, map: { ok: publish, fail: failed } }
   - { from: publish, on: outcome, map: { ok: docs-land, fail: failed, error: failed } }
   - { from: docs-land, on: outcome, map: { ok: verify, fail: failed, error: failed } }

package/graphs/video/README.md

@@ -42,6 +42,7 @@ fi
 | `exec-standard.yaml` | *"이 파이프라인을 «정기적으로» 어떻게 도나"* | `delivered` · `skipped` · `failed` · `unobserved` |
 | 🆕 `film-production-standard.yaml` | *"편집 앱을 스크립트로 몰아 한 편을 만들고 소셜까지 어떻게 내나"* | `delivered` · `master-only` · `host-blocked` · `blocked` · `unobserved` |
 | 🆕 `character-video-standard.yaml` | *"레퍼런스에서 캐릭터를 세우고, 연출된 컷을 뽑고, 편집까지 어떻게 한 루프로 도나"* | `delivered` · `rendered-unedited` · `blocked` · `unobserved` |
+| 🆕 `explainer-line.yaml` | *"사실 목록으로 «N가지 한 번에» 설명 영상을 어떻게 만들어 검사까지 가나"* (스킬 `explainer-video` · 팩 `video-explainer`) | `delivered` · `needs-human` · `blocked` · `unobserved` |
 | `overlays/render-patient.yaml` | 「같은 회차에서 N번 되돌아왔다」면 예산을 올린다 | — |
 | 🆕 `vlog-found-footage-pipeline.declaration.yaml` | *"남이 찍어 보낸 소재에서 «이야기»를 어떻게 뽑아 납품까지 가나"* | `delivered` · `needs-human` · `blocked` · `unobserved` |
 | 🆕 `video-production-pipeline.declaration.yaml` | *"영상 한 편을 «어느 갈래든» 어떻게 만들어 납품까지 가나"* | `delivered` · `needs-human` · `blocked` · `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,8 +1,10 @@
 {
   "name": "elanous",
-  "version": "0.2.4",
+  "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/elanous.git"

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,18 @@
 
 **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`를 붙여 격리한다. 인터뷰 파일은 `## 희망 직무`, `## 경험`, `## 보유 역량`을 포함해야 한다.

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

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

@@ -1,7 +1,9 @@
+import { createHash } from 'node:crypto';
 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';
+import { gapPrompt, judgeGaps, MAX_GAP_PROMPT_CHARS, type GapUnit } from './gap-judge.js';
 
 type Data = Record<string, unknown>;
 const value = (object: unknown): Data => object && typeof object === 'object' && !Array.isArray(object) ? object as Data : {};
@@ -9,6 +11,30 @@ 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 items = (raw: unknown): Data[] => {
+  const item = value(raw).items ? value(value(raw).items).item : value(raw).item ?? raw;
+  return (Array.isArray(item) ? item : item ? [item] : []).map(value);
+};
+const pick = (record: Data, ...names: string[]) => names.map(name => line(record[name])).find(Boolean) ?? '';
+const MAX_DETAIL_UNITS = 6;
+const DETAIL_CONCURRENCY = 2;
+const gapUnit = (unit: Data): GapUnit => ({
+  code: line(unit.code), name: line(unit.name), definition: line(unit.definition), level: line(unit.level),
+  elements: Array.isArray(unit.elements) ? unit.elements.map(value).map(element => ({ name: line(element.name), criteria: line(element.criteria) })) : [],
+});
+const detailFields = (raw: unknown) => {
+  const body = value(value(raw).body);
+  const records = items(body);
+  const detail = records[0] ?? body;
+  const elements = items(detail.COMPE_UNIT_ELEM ?? detail.competencyUnitElements ?? detail.elements ?? body.COMPE_UNIT_ELEM);
+  return {
+    level: pick(detail, 'COMPE_UNIT_LVL', 'COMPE_UNIT_LEVEL', 'NCS_LVL', 'level'),
+    elements: elements.map(element => ({
+      name: pick(element, 'COMPE_UNIT_ELEM_NAME', 'NCS_COMPE_UNIT_ELEM_NAME', 'name'),
+      criteria: pick(element, 'PERF_CRIT', 'PERF_CRITERIA', 'PERFORMANCE_CRITERIA', 'criteria'),
+    })).filter(element => element.name || element.criteria),
+  };
+};
 const context = value(JSON.parse(readFileSync(process.env.ELANOUS_GRAPH_CONTEXT ?? '', 'utf8')));
 const input = value(context.input);
 const outputs = value(context.outputs);
@@ -17,6 +43,11 @@ if (!contextsDir.endsWith('.json.contexts')) throw new Error('invalid graph run
 const runStateFile = contextsDir.slice(0, -'.contexts'.length);
 const reportDir = runStateFile.slice(0, -'.json'.length);
 const reportFile = join(reportDir, 'report.md');
+const enterpriseHeadings = ['기업 개요 및 교육 대상', '교육 니즈', '직무·과제 및 NCS', 'AI 적합성', '역량 진단', '교육 로드맵', '교육 명세·운영 경로'];
+const interviewField = (interview: string, heading: string) => interview.split(`## ${heading}\n`)[1]?.split(/\n## /)[0]?.trim() ?? '';
+const brief = (raw: string) => line(raw.replace(/^[-*]\s*/gm, '')).slice(0, 240) || '미확인';
+const enterpriseOutput = (name: string) => value(outputs[name]);
+const enterpriseLine = (label: string, raw: unknown) => `- ${label}: ${line(raw) || '미확인'}`;
 
 async function run(step: string) {
   if (step === 'profile') {
@@ -31,21 +62,170 @@ async function run(step: string) {
     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 === 'intake') {
+    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');
+    const headings = ['기업 개요', '교육 대상', '현업 과제', '교육 목표', '현재 역량', '교육 제약'];
+    if (headings.some(heading => !interview.includes(`## ${heading}\n`))) throw new Error(`enterprise interview requires ${headings.join(', ')} headings`);
+    const task = interviewField(interview, '현업 과제').split(/\n|[,;]/).map(s => s.replace(/^[-*]\s*/, '').trim()).find(Boolean) ?? '';
+    if (!task || task === '미확인') throw new Error('missing enterprise task for NCS search');
+    for (const heading of ['교육 대상', '교육 목표']) {
+      const field = brief(interviewField(interview, heading));
+      if (field === '미확인') throw new Error(`missing enterprise ${heading}`);
+    }
+    const jobs = [line(task).slice(0, 80)];
+    json({ jobs, sections: Object.fromEntries(headings.map(heading => [heading, brief(interviewField(interview, heading))])) });
+  } else if (step === 'needs') {
+    const sections = value(enterpriseOutput('intake').sections);
+    if (!text(sections['현업 과제'])) throw new Error('missing enterprise intake');
+    json({ learnerGroup: sections['교육 대상'], task: sections['현업 과제'], requestedOutcome: sections['교육 목표'], evidence: '인터뷰 자기보고', baseline: '미확인' });
+  } else if (step === 'task') {
+    const needs = enterpriseOutput('needs');
+    if (!text(needs.task)) throw new Error('missing enterprise needs');
+    json({ work: needs.task, performanceCriterion: text(needs.requestedOutcome) || '미확인', source: '현업 과제·교육 목표 (인터뷰 자기보고)' });
   } else if (step === 'ncs-match') {
-    const profile = value(outputs.profile);
+    const profile = value(outputs.profile ?? outputs.intake);
     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');
+    const named = results.flatMap(({ job, result }) => items(value(result).body).map(unit => ({
+      job, code: pick(unit, 'NCS_COMPE_UNIT_CD'), name: pick(unit, 'COMPE_UNIT_NAME'),
+      definition: pick(unit, 'COMPE_UNIT_DEF'), source: text(value(result).source),
+    })).filter(unit => unit.name));
+    // A hit without NCS_COMPE_UNIT_CD cannot be looked up (its classification code is not a unit code) — skip it, keep the rest.
+    const matches = named.filter(unit => unit.code);
+    if (named.length && !matches.length) throw new Error('NCS search returned named competency units only without NCS_COMPE_UNIT_CD; cannot invent a match');
+    if (!matches.length) throw new Error('NCS search returned no named competency units; cannot invent a match');
+    // Interleave jobs in search order; deduplicate codes before the bounded detail lookup.
+    const perJob = jobs.slice(0, 3).map(job => matches.filter(unit => unit.job === job));
+    const candidates: typeof matches = [];
+    const seen = new Set<string>();
+    for (let index = 0; candidates.length < MAX_DETAIL_UNITS && perJob.some(group => index < group.length); index++) {
+      for (const group of perJob) {
+        const unit = group[index];
+        if (unit && !seen.has(unit.code)) {
+          candidates.push(unit);
+          seen.add(unit.code);
+          if (candidates.length === MAX_DETAIL_UNITS) break;
+        }
+      }
+    }
+    const details: (typeof matches[number] & ReturnType<typeof detailFields> & { source: string })[] = [];
+    for (let index = 0; index < candidates.length; index += DETAIL_CONCURRENCY) {
+      details.push(...await Promise.all(candidates.slice(index, index + DETAIL_CONCURRENCY).map(async unit => {
+        const detail = await callNcsTool('ncs_unit', { code: unit.code });
+        const fields = detailFields(detail);
+        if (!fields.level || !fields.elements.length || fields.elements.some(element => !element.name || !element.criteria)) {
+          throw new Error(`NCS unit ${unit.code} has no complete elements, performance criteria and level`);
+        }
+        return { ...unit, ...fields, source: text(value(detail).source) };
+      })));
+    }
+    const interview = readFileSync(text(input.interview), 'utf8');
+    const units: typeof details = [];
+    for (const detail of details) {
+      if (gapPrompt([...units, detail].map(unit => gapUnit(unit)), interview).length <= MAX_GAP_PROMPT_CHARS) units.push(detail);
+    }
+    if (!units.length) throw new Error('interview or NCS detail exceeds gap prompt input limit');
     json({ units });
+  } else if (step === 'ai-fit') {
+    const task = enterpriseOutput('task');
+    const ncs = enterpriseOutput('ncs-match');
+    const units = Array.isArray(ncs.units) ? ncs.units.map(value) : [];
+    if (!text(task.work) || !units.length) throw new Error('missing task or NCS evidence for AI fit');
+    json({ task: task.work, ncsCodes: units.map(unit => text(unit.code)),
+      opportunity: '해당 과제의 AI 보조 가능성 검토 (효과 미확인)',
+      alternative: '업무 절차 정리 및 담당자 검토',
+      feasibility: '데이터 접근·보안·사내 정책 승인 미확인', decision: '조건부 검토' });
+  } else if (step === 'competency') {
+    const sections = value(enterpriseOutput('intake').sections);
+    const units = enterpriseOutput('ncs-match').units;
+    if (!Array.isArray(units) || !units.length) throw new Error('missing NCS units for competency assessment');
+    json({ current: sections['현재 역량'] || '미확인', status: '인터뷰 자기보고만 확인; 객관적 수준 미확인',
+      requirements: units.map(value).map(unit => ({ code: text(unit.code), name: text(unit.name), level: text(unit.level) || '미확인' })) });
+  } else if (step === 'roadmap') {
+    const competency = enterpriseOutput('competency');
+    const aiFit = enterpriseOutput('ai-fit');
+    if (!Array.isArray(competency.requirements) || !text(aiFit.decision)) throw new Error('missing competency or AI fit');
+    json({ phases: ['현재 수준 확인', '업무 기반 실습', '담당자 검토를 동반한 시범 적용', '업무 산출물 평가'],
+      assessment: '실제 업무 산출물의 수행 기준에 따른 관찰 평가', adoption: '제안 단계; 승인 미확인' });
+  } else if (step === 'spec') {
+    const roadmap = enterpriseOutput('roadmap');
+    const sections = value(enterpriseOutput('intake').sections);
+    if (!Array.isArray(roadmap.phases)) throw new Error('missing enterprise roadmap');
+    json({ audience: sections['교육 대상'] || '미확인', outcome: sections['교육 목표'] || '미확인',
+      activities: roadmap.phases, assessment: roadmap.assessment, constraints: sections['교육 제약'] || '미확인',
+      duration: '미확인', courses: '미확인' });
+  } else if (step === 'routing') {
+    const spec = enterpriseOutput('spec');
+    if (!Array.isArray(spec.activities)) throw new Error('missing enterprise training spec');
+    const sections = value(enterpriseOutput('intake').sections);
+    const ncs = enterpriseOutput('ncs-match');
+    const units = Array.isArray(ncs.units) ? ncs.units.map(value) : [];
+    if (!units.length) throw new Error('cannot report without verified NCS units');
+    const requirements = enterpriseOutput('competency').requirements;
+    if (!Array.isArray(requirements) || !requirements.length) throw new Error('missing competency requirements');
+    const md = ['# 기업 HRD 교육 제안 보고서', '',
+      `## ${enterpriseHeadings[0]}`, enterpriseLine('기업 개요 (인터뷰 자기보고)', sections['기업 개요']), enterpriseLine('교육 대상 (인터뷰 자기보고)', sections['교육 대상']), '',
+      `## ${enterpriseHeadings[1]}`, enterpriseLine('교육 대상', enterpriseOutput('needs').learnerGroup), enterpriseLine('현업 니즈 (인터뷰 자기보고)', enterpriseOutput('needs').task), enterpriseLine('교육 목표', enterpriseOutput('needs').requestedOutcome), enterpriseLine('근거', enterpriseOutput('needs').evidence), enterpriseLine('현재 수준', enterpriseOutput('needs').baseline), '',
+      `## ${enterpriseHeadings[2]}`, enterpriseLine('직무 과제', enterpriseOutput('task').work), enterpriseLine('관찰할 수행 기준', enterpriseOutput('task').performanceCriterion), enterpriseLine('과제 출처', enterpriseOutput('task').source),
+      ...units.map(unit => `- NCS ${line(unit.code)} — ${line(unit.name)} · 수준 ${line(unit.level) || '미확인'} · 출처 ${line(unit.source) || '미확인'}`), '',
+      `## ${enterpriseHeadings[3]}`, enterpriseLine('적용 검토 과제', enterpriseOutput('ai-fit').task), enterpriseLine('관련 NCS 코드', list(enterpriseOutput('ai-fit').ncsCodes).join(', ')), enterpriseLine('적용 가능성', enterpriseOutput('ai-fit').opportunity), enterpriseLine('비AI 대안', enterpriseOutput('ai-fit').alternative), enterpriseLine('도입 판정', enterpriseOutput('ai-fit').decision), enterpriseLine('정책 및 데이터 접근', enterpriseOutput('ai-fit').feasibility), '',
+      `## ${enterpriseHeadings[4]}`, enterpriseLine('현재 역량 (자기보고)', enterpriseOutput('competency').current), enterpriseLine('검증 상태', enterpriseOutput('competency').status),
+      ...requirements.map(raw => value(raw)).map(unit => `- 요구 역량: NCS ${line(unit.code)} — ${line(unit.name)} · 수준 ${line(unit.level) || '미확인'}`), '',
+      `## ${enterpriseHeadings[5]}`, ...list(enterpriseOutput('roadmap').phases).map((phase, i) => `- ${i + 1}. ${line(phase)}`), enterpriseLine('평가', enterpriseOutput('roadmap').assessment), enterpriseLine('채택 상태', enterpriseOutput('roadmap').adoption), '',
+      `## ${enterpriseHeadings[6]}`, enterpriseLine('교육 대상', spec.audience), enterpriseLine('교육 목표', spec.outcome), enterpriseLine('평가 명세', spec.assessment), enterpriseLine('시간·예산·접근 제약', spec.constraints),
+      enterpriseLine('기간', spec.duration), enterpriseLine('추천 과정·URL', spec.courses), '- 운영 경로: 담당자와 비AI/AI 시범 방식을 검토; 데이터 접근·정책 승인은 미확인', '',
+      '※ 인터뷰는 자기보고이며 NCS는 확인된 조회 결과만 인용합니다. 제안은 회사의 승인된 정책이나 확정 교육 과정이 아닙니다.', ''].join('\n');
+    mkdirSync(reportDir, { recursive: true });
+    writeFileSync(reportFile, md, { mode: 0o600 });
+    json({ report: reportFile });
+  } else if (step === 'judge-enterprise') {
+    const report = text(enterpriseOutput('routing').report);
+    if (report !== reportFile) throw new Error('missing enterprise report path');
+    const content = readFileSync(reportFile, 'utf8');
+    const needs = enterpriseOutput('needs');
+    const task = enterpriseOutput('task');
+    const aiFit = enterpriseOutput('ai-fit');
+    const competency = enterpriseOutput('competency');
+    const roadmap = enterpriseOutput('roadmap');
+    const spec = enterpriseOutput('spec');
+    const sections = value(enterpriseOutput('intake').sections);
+    const units = Array.isArray(enterpriseOutput('ncs-match').units) ? (enterpriseOutput('ncs-match').units as unknown[]).map(value) : [];
+    const phases = list(roadmap.phases);
+    const requirements = Array.isArray(competency.requirements) ? competency.requirements.map(value) : [];
+    const substantive = (raw: unknown) => !!text(raw) && text(raw) !== '미확인';
+    const required: string[][] = [
+      [enterpriseLine('기업 개요 (인터뷰 자기보고)', sections['기업 개요']), enterpriseLine('교육 대상 (인터뷰 자기보고)', sections['교육 대상'])],
+      [enterpriseLine('교육 대상', needs.learnerGroup), enterpriseLine('현업 니즈 (인터뷰 자기보고)', needs.task), enterpriseLine('교육 목표', needs.requestedOutcome), enterpriseLine('근거', needs.evidence), enterpriseLine('현재 수준', needs.baseline)],
+      [enterpriseLine('직무 과제', task.work), enterpriseLine('관찰할 수행 기준', task.performanceCriterion), enterpriseLine('과제 출처', task.source),
+        ...units.map(unit => `- NCS ${line(unit.code)} — ${line(unit.name)} · 수준 ${line(unit.level) || '미확인'} · 출처 ${line(unit.source) || '미확인'}`)],
+      [enterpriseLine('적용 검토 과제', aiFit.task), enterpriseLine('관련 NCS 코드', list(aiFit.ncsCodes).join(', ')), enterpriseLine('적용 가능성', aiFit.opportunity), enterpriseLine('비AI 대안', aiFit.alternative), enterpriseLine('도입 판정', aiFit.decision), enterpriseLine('정책 및 데이터 접근', aiFit.feasibility)],
+      [enterpriseLine('현재 역량 (자기보고)', competency.current), enterpriseLine('검증 상태', competency.status),
+        ...requirements.map(unit => `- 요구 역량: NCS ${line(unit.code)} — ${line(unit.name)} · 수준 ${line(unit.level) || '미확인'}`)],
+      [...phases.map((phase, i) => `- ${i + 1}. ${line(phase)}`), enterpriseLine('평가', roadmap.assessment), enterpriseLine('채택 상태', roadmap.adoption)],
+      [enterpriseLine('교육 대상', spec.audience), enterpriseLine('교육 목표', spec.outcome), enterpriseLine('평가 명세', spec.assessment), enterpriseLine('시간·예산·접근 제약', spec.constraints), enterpriseLine('기간', spec.duration), enterpriseLine('추천 과정·URL', spec.courses), '- 운영 경로: 담당자와 비AI/AI 시범 방식을 검토; 데이터 접근·정책 승인은 미확인'],
+    ];
+    const complete = enterpriseHeadings.every((heading, index) => {
+      const marker = `## ${heading}\n`;
+      const start = content.indexOf(marker);
+      const end = index < enterpriseHeadings.length - 1 ? content.indexOf(`## ${enterpriseHeadings[index + 1]}\n`, start + marker.length) : content.length;
+      if (start < 0 || end <= start || content.indexOf(marker, start + marker.length) !== -1) return false;
+      const lines = new Set(content.slice(start + marker.length, end).split('\n'));
+      return required[index]!.every(expected => lines.has(expected));
+    });
+    const hasNcs = units.length > 0 && units.every(unit => substantive(unit.code) && substantive(unit.name)) &&
+      list(aiFit.ncsCodes).join(', ') === units.map(unit => text(unit.code)).join(', ');
+    const hasRequiredInput = [sections['교육 대상'], sections['교육 목표'], needs.learnerGroup, needs.requestedOutcome, spec.audience, spec.outcome].every(substantive);
+    const hasRequirements = requirements.length === units.length && requirements.every((unit, index) =>
+      substantive(unit.code) && substantive(unit.name) && substantive(unit.level) &&
+      ['code', 'name', 'level'].every(field => text(unit[field]) === text(units[index]?.[field])));
+    const hasDecision = [aiFit.task, aiFit.opportunity, aiFit.alternative, aiFit.decision, roadmap.assessment].every(substantive) &&
+      text(aiFit.task) === text(task.work) && phases.length >= 4 && phases.every(substantive);
+    const path = (JSON.parse(readFileSync(runStateFile, 'utf8')) as { path?: string[] }).path ?? [];
+    const visits = path.filter(node => node === 'judge' || node === 'judge-enterprise').length;
+    json({ outcome: complete && hasRequiredInput && hasNcs && hasRequirements && hasDecision ? 'ok' : visits < 2 ? 'retry' : 'fail', report });
   } else if (step === 'research') {
     const profile = value(outputs.profile);
     const query = `${list(profile.jobs).join(' ')} 역량 교육 과정 강의 공식 출처`;
@@ -61,13 +241,27 @@ async function run(step: string) {
     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) : [];
+    const units = Array.isArray(ncs.units) ? ncs.units.map(value).map(gapUnit) : [];
     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 });
+    const interview = readFileSync(text(input.interview), 'utf8');
+    // A research retry revisits gap with the same units and interview — reuse only a verdict made from exactly those.
+    const basis = createHash('sha256').update(gapPrompt(units, interview)).digest('hex');
+    const previous = value(outputs.gap);
+    if (previous.basis === basis && Array.isArray(previous.gaps)) {
+      json({ gaps: previous.gaps, basis });
+      return;
+    }
+    const gaps = await judgeGaps(units, interview, async prompt => {
+      const cli = Bun.spawn(['elanous', '--test', 'ask', '--json', prompt], { env: process.env, stdout: 'pipe', stderr: 'pipe' });
+      const stdout = await new Response(cli.stdout).text();
+      await new Response(cli.stderr).text();
+      if (await cli.exited !== 0) throw new Error('gap LLM failed');
+      const response = value(JSON.parse(stdout));
+      if (typeof response.reply !== 'string') throw new Error('gap LLM returned no reply');
+      return response.reply;
+    });
+    json({ gaps, basis });
   } else if (step === 'report') {
     const profile = value(outputs.profile);
     const ncs = value(outputs['ncs-match']);
@@ -78,8 +272,8 @@ async function run(step: string) {
     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)}`), '',
+      '## NCS 능력단위 매칭', ...units.map(x => `- ${line(x.code)} — ${line(x.name)} (${line(x.job)}) · 수준 ${line(x.level) || '미확인'}${Array.isArray(x.elements) ? x.elements.map(value).map(element => ` · ${line(element.name)}: ${line(element.criteria)}`).join('') : ''}`), '',
+      '## 역량 갭', ...gaps.map(x => `- ${line(x.code)} ${line(x.name)}: ${line(x.status)}${text(x.quote) ? ` — 인터뷰 인용: “${line(x.quote)}”` : ''}`), '',
       '## 추천 코스', ...(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');

package/plugins/job-coach/plugin.json

@@ -3,11 +3,24 @@
   "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"],
-      "capabilities": ["network:fetch"],
-      "connectors": [{ "id": "ncs", "fields": [{ "name": "serviceKey", "secret": true }] }]
+      "graphs": ["./graphs/report.yaml", "./graphs/report-enterprise.yaml"],
+      "capabilities": ["fs:workdir", "net:apis.data.go.kr", "proc:bun", "proc:elanous", "secret:ncs"],
+      "connectors": [{ "id": "ncs", "fields": [{ "name": "serviceKey", "secret": true, "env": "NCS_SERVICE_KEY" }] }]
     }
   }
 }

package/plugins/job-coach/skills/enterprise-ai-fit/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: enterprise-ai-fit
+description: Assess AI applicability to verified enterprise tasks, including non-AI alternatives and policy unknowns.
+---
+
+Use at the enterprise `ai-fit` stage after `task` and the existing `ncs-match` stage. For each concrete task, compare a plausible AI-assisted workflow with a non-AI alternative. Record the input data type, expected benefit, failure mode, human review point, testable outcome and evidence from the task or confirmed NCS unit. Separate suitability from a promise of productivity gain. If data rights, access, privacy, security or organization approval are not documented, mark policy and deployment feasibility `미확인`; do not assert permission to upload internal information to an external model. When AI adds no justified value or a task is insufficiently described, recommend the non-AI or evidence-gathering route rather than an AI course.
+
+Use only fictional company examples. Summarize the interview instead of copying quotations; any indispensable quotation must be brief, relevant and de-identified. Never fabricate an NCS code, course name, URL or internal policy; mark unknown details `미확인`. Hand the supported AI-fit and unresolved constraints to `competency`.

package/plugins/job-coach/skills/enterprise-competency/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: enterprise-competency
+description: Compare task and verified NCS requirements to self-reported enterprise competencies without inferring incapacity.
+---
+
+Use after `enterprise-ai-fit` at the `competency` stage. Map each verified NCS unit's official code, name, level and criteria to the relevant task, keeping its source. Compare those requirements with `## 현재 역량` as self-report only. Classify each requirement as evidenced by interview, gap in evidence, or `미확인` where baseline evidence is absent; never equate missing evidence with inability or claim that an interview verifies mastery. For AI-suitable tasks, include human review, data handling and evaluation skills only insofar as the task and evidence require them. Link each proposed learning outcome to a task and an observable assessment; flag unverified NCS detail `미확인`, not an invented official unit.
+
+Use fictional people and employers in examples. Do not persist interview quotations or confidential descriptions; at most use a short, de-identified excerpt when necessary for a specific finding. Course availability and URL, approval to use company data and applicable company policy remain `미확인` until checked. Send the evidence-backed competencies and uncertainties to `roadmap`.