elanous 0.2.4 → 0.2.6

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`.

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

@@ -0,0 +1,8 @@
+---
+name: enterprise-needs
+description: Extract evidence-backed organizational learning needs from a fictional enterprise interview without claiming that a requested course is the solution.
+---
+
+Use after `interview-to-profile` in enterprise mode (`intake` → `needs`). Read the enterprise interview headings `## 기업 개요`, `## 교육 대상`, `## 현업 과제`, `## 교육 목표`, `## 현재 역량`, `## 교육 제약`. Distinguish what the organization requested from what its workflow evidence supports. For each need, record the affected learner group, task or bottleneck, desired observable outcome, evidence section and missing information. Keep unsupported causes and target levels `미확인`; ask for missing evidence rather than invent a baseline or learner count. A request for AI training is not proof that AI is the best intervention.
+
+Use only fictional employer and learner details in examples. Summarize or cite interview sections instead of reproducing interview paragraphs; if an excerpt is essential, quote only a short relevant fragment without names or identifiers. Never print the raw interview or credentials into graph stdout. Company approval and data-use policy, NCS mappings, named courses and course URLs remain `미확인` until independently verified. Hand needs and unresolved questions to `task`, not a prematurely selected course.

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

@@ -0,0 +1,8 @@
+---
+name: enterprise-roadmap
+description: Sequence evidence-backed enterprise learning and assessment into a conditional roadmap, not an approved company policy.
+---
+
+Use after `enterprise-competency` at the `roadmap` stage. Order learning activities by prerequisite and task: baseline check, guided practice, task-based pilot with human review, then observable assessment. For each phase, show the learner group, supported task or verified NCS requirement, expected work artifact, success measure, responsible reviewer if known and prerequisites. If time, budget, data access, approval or baseline are absent from `## 교육 제약`, mark them `미확인` and describe the recommendation as conditional; do not invent durations, headcounts, policy approvals or guaranteed outcomes. Pass the ordered phases to `spec` for training specification and `routing` for delivery options. A course recommendation needs an inspected publisher page describing an actual course, direct URL and relevance to the cited unit; otherwise record course and URL as `미확인`, not a plausible link.
+
+All examples must be fictional. Cite interview headings instead of copying raw interview text; any essential quote must be short, relevant and de-identified. NCS codes, course details and organization policy not independently confirmed remain `미확인`. Do not label this proposed roadmap an adopted company plan.

package/plugins/job-coach/skills/enterprise-task-analysis/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: enterprise-task-analysis
+description: Turn enterprise learning needs into traceable tasks and evidence requirements for NCS matching.
+---
+
+Use at the enterprise `task` stage after `enterprise-needs`. For each interview-backed work task, capture the learner role, input, action, output, observable performance criterion and interview section that supports it. Separate a concrete work description from a hypothesized task; mark absent frequency, tools, access permissions and proficiency `미확인`. Return job candidate keywords and bounded task descriptions for the existing `ncs-match` stage. A job title is a search candidate, not a confirmed NCS classification. Let `ncs-match` verify a code, name, level and source from the NCS service; never manufacture a code or promote a loose search hit to a confirmed unit.
+
+In examples use fictional roles and organizations. Do not pass raw interview paragraphs into graph stdout: cite the heading or use a brief de-identified excerpt only where necessary. Do not invent internal company policy, course names or course URLs; write `미확인` if absent. If no concrete task is documented, state that the task basis is `미확인` and request clarification instead of drawing an unsupported NCS match.

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

@@ -3,4 +3,21 @@ name: interview-to-profile
 description: Extract career candidates, experience and self-reported skills from a Korean interview.
 ---
 
-Read the interview Markdown. Extract, without invention, `jobs` (target job candidates), `skills` (self-reported capabilities) and `experienceCount` (number of concrete work or project descriptions). Do not persist the raw descriptions in graph stdout. Record unknowns as missing rather than extrapolating. Never print or log the original interview. For the packaged graph, prepare headings `## 희망 직무`, `## 경험`, `## 보유 역량`; list items for experience and comma-separated skills. A job is a candidate, not a confirmed NCS code.
+Read the interview Markdown without inventing evidence. Never print or log the original interview; keep quotations out of graph stdout and persistent run context. Where a report needs a quotation, use only a short, relevant excerpt necessary to support the claim, without identifying details; otherwise paraphrase and cite the interview section. Mark unknown NCS codes or units, course names or URLs, and company policy details `미확인` rather than guessing.
+
+## Personal mode (existing contract)
+
+Extract `jobs` (target job candidates), `skills` (self-reported capabilities) and `experienceCount` (number of concrete work or project descriptions). Do not persist the raw descriptions in graph stdout. Record unknowns as missing rather than extrapolating. For the personal graph, prepare headings `## 희망 직무`, `## 경험`, `## 보유 역량`; list items for experience and comma-separated skills. A job is a candidate, not a confirmed NCS code.
+
+## Enterprise mode (interview-to-profile input)
+
+Use a fictional organization in packaged examples. Prepare the interview under these headings, separating statements made by the organization from independently confirmed facts:
+
+- `## 기업 개요`: fictional organization, sector and team; omit real employer and employee identifiers.
+- `## 교육 대상`: roles, learner group and scope; do not infer headcount or proficiency.
+- `## 현업 과제`: concrete tasks and workflow bottlenecks, not a presumed diagnosis.
+- `## 교육 목표`: requested outcomes and observable success measures, if stated.
+- `## 현재 역량`: self-reported capabilities and evidence; not a verified competency rating.
+- `## 교육 제약`: time, budget, data access and approvals only when actually supplied; otherwise `미확인`.
+
+For the enterprise graph, summarize only the minimum necessary organization context, job candidates, tasks, goals, current skills and constraints for downstream steps. Do not copy interview paragraphs or identifying quotations into run outputs. Keep a stated need distinct from an observed task and from a recommended intervention. An interview alone does not verify NCS classifications, course existence or URLs, applicability of AI to confidential data, or internal policy approval: mark each unknown `미확인` until independently verified. Do not present a suggested training plan as an approved company policy.

package/scripts/backup/elanous-backup.sh

@@ -505,7 +505,10 @@ BACKUP_OK=1
 if [ "${ELANOUS_BACKUP_NO_HEARTBEAT:-0}" = "1" ]; then
   echo "  (심박 끔 — ELANOUS_BACKUP_NO_HEARTBEAT=1 · 시험 전용)" >&2
 elif [ -n "$HB_REPO" ] && [ -f "$HB_REPO/scripts/botlab/heartbeat-emit.sh" ]; then
-  bash "$HB_REPO/scripts/botlab/heartbeat-emit.sh" backup "$BACKUP_OK" "$HB_REPO" "$BACKUP_SOURCE"
+  # 심박은 «운영» 우주로 — 백업이 뜨는 것이 운영 ~/.elanous 이다. 크론은 환경변수가 없고 소스 트리는
+  # 트리 파생 시험 우주로 풀려(`where` layer=tree-derived) 심박이 «격리라 안 밀었다»로 3일 멎었다(09-30).
+  ELANOUS_STATE_DIR="${ELANOUS_STATE_DIR:-$HOME/.elanous}" ELANOUS_CONFIG_DIR="${ELANOUS_CONFIG_DIR:-$HOME/.elanous}" \
+    bash "$HB_REPO/scripts/botlab/heartbeat-emit.sh" backup "$BACKUP_OK" "$HB_REPO" "$BACKUP_SOURCE"
 else
   echo "  ⚠️ 심박을 «못 보냈다» — 저장소 자리를 못 찾았다(HB_REPO=${HB_REPO:-없음})" >&2
 fi

package/scripts/build-docs-site.ts

@@ -60,11 +60,12 @@ export const TRACK_SCRUBS: { pattern: RegExp; replace: string; why: string }[] =
 /** 잔여 표식 — 하나라도 남으면 rc=1 */
 const TRACK_REGISTRY = JSON.parse(
   readFileSync(join(import.meta.dir, 'coord-tracks.json'), 'utf8'),
-) as { tracks: { id: string; mark: string }[] };
+) as { tracks: { id: string; mark: string; alias?: string }[] };
 const TRACK_MARKS = TRACK_REGISTRY.tracks.map((t) => t.mark).join('');
-const TRACK_IDS = TRACK_REGISTRY.tracks.map((t) => t.id).join('');
+/** 2글자 신원(OP·MK·TC·UX) ⊕ 옛 한 글자 별칭(S·T·O·F) — 둘 다 공개 문서에 남으면 안 된다. */
+const TRACK_NAMES = [...new Set(TRACK_REGISTRY.tracks.flatMap((t) => [t.id, t.alias ?? '']).filter(Boolean))].join('|');
 /** 잔여 표식 — 트랙 정본(`coord-tracks.json`)에서 파생한다. 트랙을 더해도 여기는 고치지 않는다. */
-export const TRACK_RESIDUE = new RegExp(`[${TRACK_MARKS}]|(?<![\\w\\]])\\[[${TRACK_IDS}]\\](?!\\()`, 'gu');
+export const TRACK_RESIDUE = new RegExp(`[${TRACK_MARKS}]|(?<![\\w\\]])\\[(?:${TRACK_NAMES})\\](?!\\()`, 'gu');
 
 export function scrubTrackMarks(md: string): { text: string; applied: string[] } {
   let text = md;

package/scripts/coord-channel-watch.sh

@@ -107,13 +107,20 @@ fi
 # 🆕 2026-09-24 (🅞 보고): 「나에게 온 «요청»」 표지가 🅢 로 고정돼 있었다 — `--track O` 감시에서 🅢·🅣 앞 요청이
 #   «🅞 에게 온 요청»으로 뜨고, 🅞 앞 요청은 일반어(부탁드립니다)가 없으면 안 떴다.
 #   ⇒ 표지를 트랙 정본(scripts/coord-tracks.json)에서 $TRACK 으로 찾아 식을 짓는다. 일반어는 «내 표지와 함께»일 때만.
-MARK=$(grep -o "\"id\": *\"$TRACK\", *\"mark\": *\"[^\"]*\"" "$(dirname "$0")/coord-tracks.json" 2>/dev/null | sed 's/.*"mark": *"//; s/"$//')
+#   🆕 09-30 역할 재편: 신원이 2글자 id(TC) ⊕ 직함(CTO) ⊕ 옛 alias(O) 셋이다 — --track 은 id·alias 어느 쪽도 받고,
+#   «내 글» 거르기와 «나에게 온 요청» 표지는 셋을 다 본다(전환기엔 옛 접두로 쓴 글도 내 글이다).
+ENTRY=$(jq -c --arg t "$TRACK" '[.tracks[] | select(.id == $t or .alias == $t)][0] // empty' "$(dirname "$0")/coord-tracks.json" 2>/dev/null)
+MARK=$(printf '%s' "$ENTRY" | jq -r '.mark // empty' 2>/dev/null)
+SELF_ID=$(printf '%s' "$ENTRY" | jq -r '.id // empty' 2>/dev/null); SELF_ID=${SELF_ID:-$TRACK}
+SELF_ALIAS=$(printf '%s' "$ENTRY" | jq -r '.alias // empty' 2>/dev/null); SELF_ALIAS=${SELF_ALIAS:-$SELF_ID}
+SELF_TITLE=$(printf '%s' "$ENTRY" | jq -r '.title // empty' 2>/dev/null)
+NAMES_ADDR="\\\\[$SELF_ID\\\\] 님|\\\\[$SELF_ALIAS\\\\] 님|$SELF_ID 님|$SELF_ID 께${SELF_TITLE:+|$SELF_TITLE 님|$SELF_TITLE 께}"
 if [ -n "$MARK" ]; then
-  REQ_ADDR="$MARK 께|$MARK 에게|$MARK 께서|$MARK 에 요청|$MARK 님|\\\\[$TRACK\\\\] 님"
+  REQ_ADDR="$MARK 께|$MARK 에게|$MARK 께서|$MARK 에 요청|$MARK 님|$NAMES_ADDR"
   REQ_MARK="$MARK"
 else
   echo "⚠️ 트랙 정본에서 $TRACK 의 표지를 못 찾았다 — 요청 표지는 [$TRACK] 님 만 본다" >&2
-  REQ_ADDR="\\\\[$TRACK\\\\] 님"
+  REQ_ADDR="$NAMES_ADDR"
   REQ_MARK="\\\\[$TRACK\\\\]"
 fi
 
@@ -123,6 +130,9 @@ LOCKDIR="$TMP/ch${PR_NUM}-$TRACK.lock"
 # 본문 기준선 — ⭐ 프로세스가 아니라 «파일»에 둔다. 그래서 감시가 죽어 있던 구간의 본문 변경도
 # 부활 «첫 주기»에 뜬다(매뉴얼 §「부활 구간은 못 본다」의 **본문 축만** 닫힌다 — 코멘트 축은 그대로).
 BODYFILE="$TMP/ch${PR_NUM}-$TRACK.body"
+# 코멘트 기준선(since)도 «파일»에 둔다(RFC-coordination-cost §7a · C1 · 09-30) — 재기동·30분 만기 재무장 뒤에도
+# 끊긴 자리부터 이어 읽는다. 24시간보다 오래된 기준선은 버리고 지금부터(한 번에 쏟아지는 것 방지).
+SINCEFILE="$TMP/ch${PR_NUM}-$TRACK.since"
 
 # 기동시각 — 소유 판정의 유일한 근거(PID 는 재사용된다). 공백은 정규화해서 비교한다.
 proc_started() {
@@ -416,7 +426,7 @@ fetch_comments() {   # $1=since(ISO8601) → stdout=포맷된 신규 행 · rc=0
   #     그 글은 필터를 «통과»했고 창에도 떴다 — 그런데 다른 글 사이에 섞여 «요청»으로 안 보였다.
   #   🔑 그러므로 결손은 「고르기」가 아니라 ***「고른 뒤 «구분»하지 않은 것」***이다.
   #   ⛔ 표지를 «본문 앞»에 둔다 — 뒤에 두면 BODY_CHARS 절단에 잘려 사라진다.
-  fmt="select(((.body | sub(\"^[[:space:]#]+\"; \"\")) | (startswith(\"**[$TRACK]\") or startswith(\"[$TRACK]\"))) | not)
+  fmt="select(((.body | sub(\"^[[:space:]#]+\"; \"\")) | (startswith(\"**[$SELF_ID]\") or startswith(\"[$SELF_ID]\") or startswith(\"**[$SELF_ALIAS]\") or startswith(\"[$SELF_ALIAS]\"))) | not)
        | \"[#$PR_NUM 신규 id=\" + (.id|tostring) + \" \" + .created_at + \" @\" + .login + \"]\"
          + (if ((.body | test(\"$REQ_ADDR\")) or ((.body | test(\"$REQ_MARK\")) and (.body | test(\"부탁드립니다|부탁합니다\")))) then \" 🙋‼️ 나에게 온 «요청»\" else \"\" end)
          + \" \" + (.body[:$BODY_CHARS] | gsub(\"\n\"; \" ⏎ \"))"
@@ -501,6 +511,14 @@ watch_loop() {
     echo "  📄 «본문» 감시 ON · 기준선 «없음» ⇒ 첫 주기를 기준선으로 삼고 이벤트를 안 낸다"
   fi
   last=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+  if [ -s "$SINCEFILE" ]; then
+    local saved; saved=$(head -1 "$SINCEFILE" 2>/dev/null)
+    if [[ "$saved" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$ ]] \
+       && [ -z "$(find "$SINCEFILE" -mmin +1440 2>/dev/null)" ]; then
+      last="$saved"
+      echo "  🔁 코멘트 기준선 이어 읽기 since=$last (파일 $SINCEFILE) — 죽어 있던 구간도 첫 주기에 뜬다"
+    fi
+  fi
   while true; do
     sleep "$INTERVAL"
     now=$(date -u +%Y-%m-%dT%H:%M:%SZ)
@@ -530,6 +548,7 @@ watch_loop() {
       fi
       [ -n "$out" ] && printf '%s\n' "$out"
       last="$now"
+      printf '%s\n' "$last" > "$SINCEFILE" 2>/dev/null || true
       # ⭐ 실패하다 «돌아왔으면» 한 줄로 말한다 — 조용히 복구되면 아무도 «공백 구간»이 있었음을 모른다.
       if [ "$WATCH_FAILS" -gt 0 ]; then
         printf '✅ [#%s 조회 «회복» %s] 연속 실패 %s회 뒤 성공 — 그 사이도 since=%s 로 «이어 붙였다»(놓친 것 없음)\n' \

package/scripts/coord-post.sh

@@ -41,25 +41,44 @@ grep -q '{{TS}}' "$BODY" || echo "⚠️ 본문에 {{TS}} 자리표시가 «없
 
 # 트랙 신원은 «정본 한 곳»에서 읽는다 — scripts/coord-tracks.json. 못 읽으면 추측하지 않고 선다.
 TRACKS_FILE="$(dirname "$0")/coord-tracks.json"
-TRACKS=$(grep -o '"id": *"[A-Z]"' "$TRACKS_FILE" 2>/dev/null | grep -o '[A-Z]"$' | tr -d '"\n')
-[ -n "$TRACKS" ] || { echo "⛔ 트랙 정본을 읽지 못했다: $TRACKS_FILE — 발신하지 않는다" >&2; exit 4; }
+# 신원 = 2글자 id(OP·MK·TC·UX…) ⊕ 옛 한 글자 alias(S·T·O·F — 전환기엔 받되 경고). 목록은 정본에서만.
+IDS=$(grep -o '"id": *"[A-Z][A-Z]*"' "$TRACKS_FILE" 2>/dev/null | sed 's/.*"\([A-Z]*\)"$/\1/' | tr '\n' ' ')
+ALIASES=$(grep -o '"alias": *"[A-Z][A-Z]*"' "$TRACKS_FILE" 2>/dev/null | sed 's/.*"\([A-Z]*\)"$/\1/' | tr '\n' ' ')
+[ -n "$IDS" ] || { echo "⛔ 트랙 정본을 읽지 못했다: $TRACKS_FILE — 발신하지 않는다" >&2; exit 4; }
 ID="${COORD_ID:-S}"
-if [ "${#ID}" -ne 1 ] || [ "${TRACKS#*"$ID"}" = "$TRACKS" ]; then
-  echo "⛔ COORD_ID 는 트랙 정본($TRACKS_FILE)의 신원 [$TRACKS] 중 하나여야 한다(받은 값: $ID)" >&2; exit 4
-fi
+case " $IDS " in
+  *" $ID "*) ;;
+  *) case " $ALIASES " in
+       *" $ID "*) NEW=$(grep -o "\"id\": *\"[A-Z]*\", *\"title\": *\"[A-Z]*\", *\"alias\": *\"$ID\"" "$TRACKS_FILE" | sed 's/^"id": *"\([A-Z]*\)".*/\1/')
+                  echo "⚠️ 옛 한 글자 신원 [$ID] — 새 신원은 [${NEW:-?}] 다(전환기라 받는다)" >&2 ;;
+       *) echo "⛔ COORD_ID 는 트랙 정본($TRACKS_FILE)의 신원 [$IDS] (옛 [$ALIASES]) 중 하나여야 한다(받은 값: $ID)" >&2; exit 4 ;;
+     esac ;;
+esac
 FIRST=$(head -1 "$BODY")
+OTHER=""
+for T in $IDS $ALIASES; do
+  [ "$T" = "$ID" ] && continue
+  case "$FIRST" in "**[$T]**"*) OTHER="$T" ;; esac
+done
 case "$FIRST" in
   "**[$ID]**"*) ;;
-  \*\*\[[$TRACKS]\]\*\**)
-    echo "⛔ 신원 접두가 «내 것이 아니다» — 첫 줄이 ${FIRST%%\*\* *}** 로 시작한다(내 신원 = [$ID])." >&2
-    echo "   ⛔ 감시자는 startswith 로 고른다 ⇒ 상대는 이 글을 «자기 글»로 보고 건너뛴다. 발신하지 않는다." >&2
-    echo "   ✅ 수신자는 본문에 적어라: **[$ID]** … [T] 님께 …" >&2
-    exit 5 ;;
   *)
+    if [ -n "$OTHER" ]; then
+      echo "⛔ 신원 접두가 «내 것이 아니다» — 첫 줄이 **[$OTHER]** 로 시작한다(내 신원 = [$ID])." >&2
+      echo "   ⛔ 감시자는 startswith 로 고른다 ⇒ 상대는 이 글을 «자기 글»로 보고 건너뛴다. 발신하지 않는다." >&2
+      echo "   ✅ 수신자는 본문에 적어라: **[$ID]** … MK 님께 …" >&2
+      exit 5
+    fi
     echo "⛔ 첫 줄이 «**[$ID]**» 신원 접두로 시작하지 않는다 — 상대 감시자가 이 글을 못 고른다. 발신하지 않는다." >&2
     exit 5 ;;
 esac
 
+# 봉투 v2(RFC-coordination-cost §2 · C1 · 09-30): 첫 줄에 종류 다섯 중 하나 — 막지 않고 «알린다».
+case "$FIRST" in
+  *요청*|*결정*|*사고*|*보고*|*정정*) ;;
+  *) echo "⚠️ 첫 줄에 글 종류(요청·결정·사고·보고·정정)가 없다 — 받는 쪽 감시자가 즉시/모아 읽기를 못 가른다(발신은 한다)" >&2 ;;
+esac
+
 TS=$(TZ=Asia/Seoul date '+%Y-%m-%d %H:%M KST')
 TMP=$(mktemp "${TMPDIR:-/tmp}/coord-post.XXXXXX") || { echo "⛔ mktemp 실패 — 발신하지 않는다" >&2; exit 7; }
 DATA=$(mktemp "${TMPDIR:-/tmp}/coord-post-data.XXXXXX") || { rm -f "$TMP"; echo "⛔ mktemp 실패 — 발신하지 않는다" >&2; exit 7; }
@@ -125,8 +144,26 @@ fi
 POST_OUTPUT=$(bun bin/elanous.mjs gh pr comment "$PR" --body-file "$TMP" 2>&1)
 RC=$?
 printf '%s\n' "$POST_OUTPUT" | tail -2
+VIA=""
+# `gh pr comment` goes through GraphQL; its secondary rate limit can block while REST still answers (GIT-S83).
+# 09-30: 채널 코멘트 1,500 뒤 GraphQL 이 «Something went wrong» 으로 연속 실패하고 REST 는 201 — 이 내부 오류도 REST 로 물러선다.
+#   ⛔ 다른 실패(PR 못 찾음 등)는 물러서지 않는다. 물러서기 전에 같은 첫 줄이 이미 올라갔는지 본다(부분 성공 → 이중 발신 방지).
+if [ "$RC" -ne 0 ] && printf '%s' "$POST_OUTPUT" | grep -qiE 'rate limit|Something went wrong'; then
+  echo "⚠️ GraphQL 실패(한도·내부 오류) — REST 로 한 번 물러선다(GIT-S83)" >&2
+  FIRSTOUT=$(head -1 "$TMP")
+  # issues 코멘트 목록은 오래된 순이고 정렬 인자를 안 받는다 ⇒ 최근 10분만 since 로 자른다.
+  SINCE10=$(date -u -v-10M +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -d '-10 min' +%Y-%m-%dT%H:%M:%SZ)
+  if bun bin/elanous.mjs gh api "repos/{owner}/{repo}/issues/$PR/comments?since=$SINCE10&per_page=100" --jq '.[].body | split("\n")[0]' 2>/dev/null | grep -qxF -- "$FIRSTOUT"; then
+    echo "[coord-post] 같은 첫 줄이 이미 채널에 있다 — GraphQL 이 실제로는 올렸다(이중 발신 안 함)" >&2
+    exit 0
+  fi
+  POST_OUTPUT=$(bun bin/elanous.mjs gh api -X POST "repos/{owner}/{repo}/issues/$PR/comments" -F "body=@$TMP" -q .html_url 2>&1)
+  RC=$?
+  printf '%s\n' "$POST_OUTPUT" | tail -2
+  VIA=" · REST 폴백"
+fi
 if [ "$RC" -ne 0 ]; then
-  echo "⛔ 발신 실패 rc=$RC — «보냈다고 읽지 마라»" >&2
+  echo "⛔ 발신 실패 rc=$RC$VIA — «보냈다고 읽지 마라»" >&2
   exit "$RC"
 fi
-echo "[coord-post] 발신 성공 · 채널 #$PR · 신원 [$ID] · 시각 $TS" >&2
+echo "[coord-post] 발신 성공$VIA · 채널 #$PR · 신원 [$ID] · 시각 $TS" >&2

package/scripts/coord-tracks.json

@@ -1,10 +1,10 @@
 {
-  "_comment": "조율 채널 트랙 신원의 정본. 트랙을 더하려면 여기 한 줄만 더한다 — scripts/coord-post.sh 와 scripts/build-docs-site.ts 가 이 파일을 읽는다.",
+  "_comment": "조율 채널 세션 신원의 정본(09-30 역할 재편). id = 2글자 신원(발신 접두 **[TC]**) · title = 직함 · alias = 옛 한 글자(기록 읽기·전환기 발신용) · mark = 옛 표지. 세션을 더하려면 여기 한 줄만 더한다 — coord-post.sh · coord-channel-watch.sh · build-docs-site.ts · mission-phase-track.ts 가 이 파일을 읽는다.",
   "tracks": [
-    { "id": "S", "mark": "🅢", "owns": ["기획", "총괄", "전략", "소구점", "로드맵", "plan", "strategy"] },
-    { "id": "T", "mark": "🅣", "owns": ["영상", "비디오", "티저", "하이퍼프레임", "HyperFrames", "렌더", "video", "teaser", "render", "B-roll"] },
-    { "id": "F", "mark": "🅕", "owns": ["PWA", "웹", "웹사이트", "elanous.ai", "탭", "화면", "UI", "프론트엔드", "frontend", "web", "tab"] },
-    { "id": "O", "mark": "🅞", "owns": ["블로그", "매뉴얼", "문서", "흡수", "Obsidian", "승인", "blog", "manual", "docs"] },
+    { "id": "OP", "title": "COO", "alias": "S", "mark": "🅢", "owns": ["판올림", "컷", "체크리스트", "분배", "통합", "로드맵", "기획", "총괄", "전략", "인계", "release cut", "roadmap", "plan", "strategy"] },
+    { "id": "MK", "title": "CMO", "alias": "T", "mark": "🅣", "owns": ["블로그", "콘텐츠", "발행", "광고", "프로모션", "소구점", "마케팅", "영상", "비디오", "티저", "하이퍼프레임", "렌더", "blog", "content", "marketing", "ads", "video", "teaser", "render", "B-roll", "상표", "변리사", "브랜드", "trademark", "brand", "홈페이지", "웹사이트", "elanous.ai", "elanvital.ai", "website"] },
+    { "id": "TC", "title": "CTO", "alias": "O", "mark": "🅞", "owns": ["하니스", "게이트", "원장", "리뷰", "관측", "릴리스 루프", "흡수", "Obsidian", "매뉴얼", "문서", "기술", "harness", "gate", "ledger", "review", "observability", "intake", "manual", "docs"] },
+    { "id": "UX", "title": "CXO", "alias": "F", "mark": "🅕", "owns": ["PWA", "웹", "탭", "화면", "UI", "프론트엔드", "안드로이드", "아이폰", "데스크톱", "텔레그램", "디스코드", "메신저", "봇", "frontend", "web", "tab", "android", "ios", "desktop", "telegram", "discord", "bot"] },
     { "id": "E", "mark": "🅔", "owns": [] }
   ]
 }