@pghoya2956/livemap 1.0.1 → 1.1.1

package/src/adapters/roadmap.mjs

@@ -1,33 +1,103 @@
-// 로드맵 어댑터: tasks/roadmap.md 의 `## 제목` 절마다 milestone 노드를 만든다. 절의 첫 문단은 목표, `- 키: 값` 목록은 속성이다.
-// 순서는 파일 안 위치다. 장면·작업·선행은 문자열로만 남기고 해석(존재 확인)은 derive·check가 한다.
-const KEYS = { id: 'id', 상태: 'status', '진행 방식': 'mode', 작업: 'tasks', 장면: 'scenes', 선행: 'deps', '결정 대기': 'waitingOn', '완료 기준': 'done' };
+// 로드맵 어댑터: tasks/roadmap.md 의 `## 제목` 절마다 milestone 노드(로드맵 항목)를 만든다. 절의 첫 문단은 목표, `- 키: 값` 목록은 속성이다.
+// `## 마일스톤: 제목` 절은 release 노드(마일스톤, 1.x 임시 이름)이고, 항목의 `마일스톤` 키가 release → milestone contains 엣지가 된다.
+// 순서는 파일 안 위치다. 항목 order·자동 id는 항목 절만 센다. 장면·작업·선행은 문자열로만 남기고 해석(존재 확인)은 derive·check가 한다.
+// 완료일(completedAt)·결정 대기 시작일(waitingSince)은 로드맵 파일의 git 이력에서 계산한다.
+const KEYS = { id: 'id', 상태: 'status', '진행 방식': 'mode', 작업: 'tasks', 장면: 'scenes', 선행: 'deps', '결정 대기': 'waitingOn', '완료 기준': 'done', 마일스톤: 'milestone' };
+const RELEASE_KEYS = { id: 'id', 상태: 'status', 완료일: 'completedOn', 목표일: 'targetOn', '결정 대기': 'waitingOn' };
 const LISTS = new Set(['tasks', 'scenes', 'deps']);
+const RELEASE_HEAD = /^마일스톤\s*[:：]\s*(.*)$/;
+const SHALLOW = '얕은 클론: 완료일·결정 대기 시작일 생략';
 
-export default function roadmap(g, fs, cfg) {
-  const file = cfg.roadmap?.file;
-  if (!file) return null;
-  if (!fs.has(file)) return `로드맵 파일 없음: ${file}`;
-  const text = fs.read(file);
-  let n = 0;
+// 로드맵 본문 → { items, releases }. 이력의 옛 판도 같은 규칙으로 읽는다.
+function parse(text) {
+  const items = [], releases = [];
   for (const block of text.split(/^## /m).slice(1)) {
     const [head, ...lines] = block.split('\n');
-    const title = head.trim();
-    const props = { order: n + 1, goal: '', status: '', mode: '', tasks: [], scenes: [], deps: [], waitingOn: '', done: '' };
+    const rel = head.trim().match(RELEASE_HEAD);
+    const keys = rel ? RELEASE_KEYS : KEYS;
+    const props = rel
+      ? { order: releases.length + 1, goal: '', status: '', completedOn: '', targetOn: '', waitingOn: '' }
+      : { order: items.length + 1, goal: '', status: '', mode: '', tasks: [], scenes: [], deps: [], waitingOn: '', done: '', milestone: null };
     const goal = [];
     for (const line of lines) {
       const m = line.match(/^- ([^:]+):\s*(.*)$/);
-      if (m && KEYS[m[1].trim()]) {
-        const key = KEYS[m[1].trim()];
+      if (m && keys[m[1].trim()]) {
+        const key = keys[m[1].trim()];
         const value = m[2].replace(/`/g, '').trim();
-        props[key] = LISTS.has(key) ? value.split(/[,，]\s*/).map((x) => x.trim()).filter((x) => x && x !== '—') : value;
+        props[key] = LISTS.has(key) ? value.split(/[,，]\s*/).map((x) => x.trim()).filter((x) => x && x !== '—') : key === 'milestone' ? value || null : value;
       } else if (!line.startsWith('- ') && line.trim()) goal.push(line.trim());
     }
     props.goal = goal.join(' ');
-    const id = props.id || `m${n + 1}`;
+    const declared = props.id;
     delete props.id;
-    g.add('milestone', id, title, props, { file, line: fs.lineOf(text, `## ${head}`), rule: 'roadmap:## 제목 + - 키: 값' });
-    for (const t of props.tasks) g.link('milestone', id, 'tracks', 'task', t);
-    n += 1;
+    if (rel) releases.push({ id: declared || `r${props.order}`, idMissing: !declared, title: rel[1].trim(), head, props });
+    else items.push({ id: declared || `m${props.order}`, title: head.trim(), head, props });
+  }
+  return { items, releases };
+}
+
+// 이력 날짜: 마지막 완료 전이 커밋, 결정 대기 연속 구간의 시작 커밋(작성 시각, UTC ISO). 키는 'item:<id>'·'release:<id>'.
+function historyDates(fs, cfg, file) {
+  if (!fs.hasGit()) return { dates: null };
+  if (fs.git('rev-parse', '--is-shallow-repository') === 'true') return { dates: null, note: SHALLOW };
+  const ref = fs.resolveRef(cfg.git?.branch || 'main');
+  if (!ref) return { dates: null };
+  // --reverse와 --follow를 함께 주면 git이 이름 바꾸기를 따라가지 않는다(git 2.53 실측). 최신순으로 받아 뒤집는다.
+  const log = fs.git('log', '--follow', '--name-only', '--format=%H|%ad', '--date=iso-strict', ref, '--', file);
+  const completedAt = new Map(), waitingSince = new Map();
+  let prev = new Map();
+  let commit = null;
+  const apply = (sha, date, path) => {
+    const { items, releases } = parse(fs.git('show', `${sha}:${path}`));
+    const iso = new Date(date).toISOString();
+    const now = new Map([...items.map((x) => [`item:${x.id}`, x.props]), ...releases.map((x) => [`release:${x.id}`, x.props])]);
+    for (const [k, p] of now) {
+      const before = prev.get(k);
+      if (k.startsWith('item:')) {
+        if (p.status !== '완료') completedAt.delete(k);
+        else if (!before || before.status !== '완료') completedAt.set(k, iso);
+      }
+      if (!p.waitingOn) waitingSince.delete(k);
+      else if (!before || !before.waitingOn) waitingSince.set(k, iso);
+    }
+    for (const k of [...completedAt.keys()]) if (!now.has(k)) completedAt.delete(k);
+    for (const k of [...waitingSince.keys()]) if (!now.has(k)) waitingSince.delete(k);
+    prev = now;
+  };
+  const commits = [];
+  for (const line of log.split('\n')) {
+    const h = line.match(/^([0-9a-f]{40})\|(.+)$/);
+    if (h) { commit = { sha: h[1], date: h[2], path: null }; commits.push(commit); continue; }
+    if (commit && !commit.path && line.trim()) commit.path = line.trim();
+  }
+  for (const c of commits.reverse()) if (c.path) apply(c.sha, c.date, c.path);
+  return { dates: { completedAt, waitingSince } };
+}
+
+export default function roadmap(g, fs, cfg) {
+  const file = cfg.roadmap?.file;
+  if (!file) return null;
+  if (!fs.has(file)) return `로드맵 파일 없음: ${file}`;
+  const text = fs.read(file);
+  const { items, releases } = parse(text);
+  const hist = items.length || releases.length ? historyDates(fs, cfg, file) : { dates: null };
+  const d = hist.dates;
+  const rule = 'roadmap:## 제목 + - 키: 값';
+  const seen = new Map();
+  for (const r of releases) {
+    if (seen.has(r.id)) { seen.get(r.id).props.duplicates += 1; continue; }
+    const waitingSince = r.props.waitingOn && d?.waitingSince.get(`release:${r.id}`) || null;
+    const node = g.add('release', r.id, r.title, { ...r.props, idMissing: r.idMissing, duplicates: 0, waitingSince }, { file, line: fs.lineOf(text, `## ${r.head}`), rule: 'roadmap:## 마일스톤: 제목 + - 키: 값' });
+    seen.set(r.id, node);
+  }
+  for (const it of items) {
+    const p = it.props;
+    p.completedAt = p.status === '완료' && d?.completedAt.get(`item:${it.id}`) || null;
+    p.waitingSince = p.waitingOn && d?.waitingSince.get(`item:${it.id}`) || null;
+    g.add('milestone', it.id, it.title, p, { file, line: fs.lineOf(text, `## ${it.head}`), rule });
+    for (const t of p.tasks) g.link('milestone', it.id, 'tracks', 'task', t);
+    if (p.milestone && seen.has(p.milestone)) g.link('release', p.milestone, 'contains', 'milestone', it.id);
   }
-  return n === 0 ? '로드맵 항목 0건' : null;
+  if (items.length === 0) return '로드맵 항목 0건';
+  return hist.note || null;
 }

package/src/adapters/tasks.mjs

@@ -31,16 +31,23 @@ export default function tasks(g, fs, cfg) {
       : mention('실행 대기·중단') ? '대기'
       : mention('현재 작업') ? '진행' : '기록';
     const title = heading(plan) || heading(`${base}/spec/final.md`) || heading(`${base}/spec/initial.md`) || heading(`${base}/README.md`) || heading(`${base}/${mdIn(base)[0] || ''}`) || name.slice(9);
+    // 수는 파일 하나에서만 센다: 계획 항목은 체크하는 계획 문서, 결정·열린 질문은 spec/final.md.
+    // 스펙에 적은 계획 초안 체크박스는 실행 중 체크되지 않아 더하면 분모만 부푼다. 노드는 두 문서 모두에서 만들되 세는 문서를 먼저 읽는다.
+    const finalSpec = `${base}/spec/final.md`;
     let dec = 0, pnDone = 0, pnOpen = 0, oq = 0;
-    for (const f of [`${base}/spec/final.md`, plan].filter((f) => f && fs.has(f))) {
+    for (const f of [finalSpec, plan].filter((f) => f && fs.has(f))) {
+      const t = fs.read(f);
+      for (const m of t.matchAll(/^- (DEC-\d+)/gm)) { if (f === finalSpec) dec += 1; if (!g.get('decision', m[1])) { g.add('decision', m[1], m[1], { kind: 'spec-dec', file: f }, { file: f, line: fs.lineOf(t, m[0]), rule: 'tasks:- DEC-nn' }); g.link('task', name, 'defines', 'decision', m[1]); } }
+      if (f === finalSpec) oq += (t.match(/^\| OQ-\d+ \|/gm) || []).length;
+    }
+    for (const f of [plan, finalSpec].filter((f) => f && fs.has(f))) {
       const t = fs.read(f);
-      for (const m of t.matchAll(/^- (DEC-\d+)/gm)) { dec += 1; if (!g.get('decision', m[1])) { g.add('decision', m[1], m[1], { kind: 'spec-dec', file: f }, { file: f, line: fs.lineOf(t, m[0]), rule: 'tasks:- DEC-nn' }); g.link('task', name, 'defines', 'decision', m[1]); } }
       for (const m of t.matchAll(/^- \[(x| )\] ((?:PN|P\d)-\d+)/gim)) {
-        const done = m[1].toLowerCase() === 'x'; if (done) pnDone += 1; else pnOpen += 1;
+        const done = m[1].toLowerCase() === 'x';
+        if (f === plan) { if (done) pnDone += 1; else pnOpen += 1; }
         const pid = m[2].toUpperCase();
         if (!g.get('decision', pid)) { g.add('decision', pid, pid, { kind: 'plan-item', done, file: f }, { file: f, line: fs.lineOf(t, m[0]), rule: 'tasks:- [ ] PN-nn' }); g.link('task', name, 'defines', 'decision', pid); }
       }
-      oq += (t.match(/^\| OQ-\d+ \|/gm) || []).length;
     }
     const ref = fs.hasGit() ? fs.resolveRef(cfg.git?.branch || 'main') : null;
     const recent = ref ? Number(fs.git('rev-list', '--count', ref, `--since=${cfg.git?.sinceDays || 14} days ago`, '--', base) || 0) : 0;

package/src/check.mjs

@@ -30,9 +30,27 @@ export function check(d, cfg) {
     for (const p of m.problems) err(`로드맵 ${m.title}: ${p}`);
     if (m.status === '진행' && !m.tasks.length) warn(`로드맵 ${m.title}: 진행인데 작업 폴더가 없음`);
   }
+  // 마일스톤: 문장은 derive가 만든다. 마일스톤 절이 없으면 줄이 없다
+  for (const m of d.milestones || []) { for (const p of m.problems) err(p); for (const w of m.warnings) warn(w); }
+  const running = (d.milestones || []).filter((m) => m.status === '진행');
+  if (running.length > 1) warn(`진행 마일스톤 ${running.length}개: ${running.map((m) => m.title).join(', ')}`);
+  for (const m of d.roadmap || []) {
+    if (m.status !== '진행') continue;
+    if ((d.milestones || []).length && !m.milestone) warn(`로드맵 ${m.title}: 진행인데 마일스톤 없음`);
+    const open = (m.deps || []).filter((x) => x.status !== '완료');
+    if (open.length) warn(`로드맵 ${m.title}: 진행인데 선행 미완 ${open.map((x) => x.title).join(', ')}`);
+  }
+  // 배우 사전: 여정 배우, 여정과 다른 단계 배우가 사전 키에 없으면 경고(사전이 없는 프로젝트는 건너뜀)
+  const actors = d.semantic.actors || {};
+  if (Object.keys(actors).length) for (const j of d.semantic.journeys) {
+    if (j.actor && !(j.actor in actors)) warn(`${j.title}: 배우 사전에 없는 값 ${j.actor}`);
+    for (const s of j.steps) if (s.actor && s.actor !== j.actor && !(s.actor in actors)) warn(`${j.title} › ${s.label}: 배우 사전에 없는 값 ${s.actor}`);
+  }
   if (d.orphans.screens.length) warn(`여정에 없는 화면 ${d.orphans.screens.length}: ${d.orphans.screens.join(', ')}`);
   if (d.orphans.apis.length) warn(`어느 화면도 부르지 않는 API ${d.orphans.apis.length}: ${d.orphans.apis.join(', ')}`);
   if (d.orphans.tests.length) warn(`라우트·API에 붙지 않는 검사 ${d.orphans.tests.length}: ${d.orphans.tests.join(', ')}`);
   if (d.deploy && d.deploy.behind === null) warn('배포 sha가 main 이력에 없어 뒤처짐을 계산하지 못함');
+  // 어댑터가 g.issue로 낸 문제: 기존 검사 뒤에 그대로 싣는다. error는 종료 코드 1에 센다.
+  for (const i of d.issues || []) (i.level === 'error' ? err : warn)(`${i.label}: ${i.message}`);
   return out;
 }

package/src/cli.mjs

@@ -61,7 +61,7 @@ export async function build(root = process.cwd(), out = resolve(root, 'map/.out'
   mkdirSync(out, { recursive: true });
   writeFileSync(join(out, 'graph.json'), JSON.stringify(r.g.toJSON()));
   writeFileSync(join(out, 'data.json'), JSON.stringify(r.data));
-  writeFileSync(join(out, 'overview.json'), JSON.stringify(overviewSlice(r.data)));
+  writeFileSync(join(out, 'overview.json'), JSON.stringify(overviewSlice(r.data, { sinceDays: r.cfg.git?.sinceDays })));
   return r;
 }
 

package/src/derive.mjs

@@ -1,6 +1,42 @@
 // 파생: 그래프(코드 사실) + 여정 파일(뜻)을 합쳐 화면이 읽는 뷰 모델을 만든다. 화면은 여기서 만든 것만 그린다.
 const ROADMAP_STATUS = ['완료', '진행', '다음', '대기', '이후'];
 const RANK = { live: 0, partial: 1, mixed: 1, mock: 2, planned: 3, next: 4, static: 5 };
+const DAY = /^(\d{4})-(\d{2})-(\d{2})$/;
+// YYYY-MM-DD 이고 달력에 있는 날짜인가
+export const isDay = (s) => { const m = String(s ?? '').match(DAY); if (!m) return false; const t = new Date(Date.UTC(+m[1], +m[2] - 1, +m[3])); return t.getUTCFullYear() === +m[1] && t.getUTCMonth() === +m[2] - 1 && t.getUTCDate() === +m[3]; };
+
+// 문구 정리: 링크 글자만, 강조·백틱 제거, 공백 정리, n자(코드 포인트) 넘으면 말줄임
+export function plain(text, n) {
+  const s = String(text ?? '').replace(/\[([^\]]+)\]\([^)]+\)/g, '$1').replace(/\*\*|`/g, '').replace(/\s+/g, ' ').trim();
+  const cp = [...s];
+  return n && cp.length > n ? cp.slice(0, n - 1).join('') + '…' : s;
+}
+// 변경 종류: 커밋 제목의 관례 접두어(`feat(범위)!:`)만 본다. 프로젝트의 영역 이름을 가정하지 않는다
+const KINDS = { feat: '기능', fix: '수정', docs: '문서', test: '검사', refactor: '정리', perf: '정리', style: '정리', build: '운영', ci: '운영', chore: '운영', deploy: '운영', release: '운영' };
+const PREFIX = /^([a-z]+)(\([^)]*\))?!?:\s*/i;
+export function changeKind(subject) {
+  const m = String(subject ?? '').match(PREFIX);
+  return (m && KINDS[m[1].toLowerCase()]) || '변경';
+}
+// 커밋 제목 정리: 접두어·[skip ci]·내부 ID·식별자 낱말을 지우고 괄호·끝 기호를 정리한다. 2자 미만이면 "{종류} 변경"
+export function subjectPlain(subject, n) {
+  const kind = changeKind(subject);
+  let s = plain(String(subject ?? '').replace(PREFIX, '').replace(/\[(skip ci|ci skip)\]/gi, ''));
+  s = s.replace(/\b(PN|DEC|OQ|AC|P\d)-\d+(?:\s*[·,~]\s*\d+)*/g, '').replace(/\b(PN|DEC|OQ|AC)\b/g, '').replace(/\bQ\d+\b/g, '');
+  s = s.split(' ').filter((w) => !/^[0-9a-f]{7,40}$/i.test(w) && !w.includes('/api/') && !/\.(tsx|mjs|sql)$/.test(w) && !w.startsWith('web/src')).join(' ');
+  s = s.replace(/\(\s*[,·\s]*/g, '(').replace(/[,·\s]*\)/g, ')').replace(/\(\)/g, '').replace(/\s+/g, ' ').replace(/[\s\-–—:·,]+$/, '').trim();
+  if ([...s].length < 2) s = `${kind} 변경`;
+  return plain(s, n);
+}
+// Asia/Seoul 날짜(YYYY-MM-DD). 커밋 시각의 Z·+09:00 혼용을 Date로 통일한다
+const seoulDay = (t) => new Intl.DateTimeFormat('en-CA', { timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit' }).format(new Date(t));
+const STEP_STATUS = ['live', 'mock', 'planned', 'next'];
+// 결정 대기 "<주체>: <질문>" 나누기. 주체는 콜론 없는 1~20자, 콜론 뒤 공백 필수(URL·시각은 주체가 아니다)
+export function splitWaiting(text) {
+  const t = plain(text);
+  const m = t.match(/^([^:：\s][^:：]{0,19}?)\s*[:：]\s+(.+)$/);
+  return m ? { who: m[1].trim(), what: m[2] } : { who: null, what: t };
+}
 
 export function derive(g, sem, cfg, { captureExists }) {
   const screens = g.of('screen'), apis = g.of('api'), fns = g.of('function'), tests = g.of('test'), commits = g.of('commit').sort((a, b) => b.props.date.localeCompare(a.props.date));
@@ -96,14 +132,55 @@ export function derive(g, sem, cfg, { captureExists }) {
   const stepByRef = Object.fromEntries(journeys.flatMap((j) => j.steps.map((s) => [`${j.id}/${s.id}`, { journey: j.id, step: s.id, label: `${j.title} › ${s.label}`, status: s.status, grade: s.grade, fixed: s.screenNodes.some((n) => (n.fixedVia || []).length) }])));
   const milestones = g.of('milestone').sort((a, b) => a.props.order - b.props.order);
   const milestoneIds = new Set(milestones.map((m) => m.id));
+  const releases = g.of('release').sort((a, b) => a.props.order - b.props.order);
+  const releaseIds = new Set(releases.map((r) => r.id));
   const roadmap = milestones.map((m) => {
     const p = m.props;
     const scenes = p.scenes.map((r) => stepByRef[r] ? { ref: r, ...stepByRef[r] } : { ref: r, missing: true });
     const trackedTasks = p.tasks.map((name) => { const t = taskView.find((x) => x.name === name); return t ? { name, title: t.title, stage: t.stage, status: t.status, pnDone: t.pnDone, pnOpen: t.pnOpen } : { name, missing: true }; });
     const problems = [...scenes.filter((s) => s.missing).map((s) => `장면 없음: ${s.ref}`), ...trackedTasks.filter((t) => t.missing).map((t) => `작업 폴더 없음: ${t.name}`), ...p.deps.filter((d) => !milestoneIds.has(d)).map((d) => `선행 항목 없음: ${d}`)];
     if (!ROADMAP_STATUS.includes(p.status)) problems.push(`알 수 없는 상태: ${p.status || '(비어 있음)'}`);
+    if (p.milestone && !releaseIds.has(p.milestone)) problems.push(`마일스톤 없음 ${p.milestone}`);
     const live = scenes.filter((s) => s.status === 'live').length;
-    return { id: m.id, order: p.order, title: m.label, status: p.status, mode: p.mode, goal: p.goal, waitingOn: p.waitingOn, done: p.done, deps: p.deps.map((d) => ({ id: d, title: milestones.find((x) => x.id === d)?.label || d, status: milestones.find((x) => x.id === d)?.props.status || null })), scenes, tasks: trackedTasks, progress: { live, total: scenes.length, fixed: scenes.filter((s) => s.fixed).length }, problems, src: m.src };
+    const deps = p.deps.map((d) => ({ id: d, title: milestones.find((x) => x.id === d)?.label || d, status: milestones.find((x) => x.id === d)?.props.status || null }));
+    const waiting = splitWaiting(p.waitingOn);
+    // 막힘: 결정 대기(비완료), 선행 미완(진행·다음), 추적 작업 대기
+    const blockedBy = [];
+    if (p.status !== '완료' && p.waitingOn) blockedBy.push('waiting');
+    if (['진행', '다음'].includes(p.status) && deps.some((d) => d.status !== '완료')) blockedBy.push('deps');
+    if (trackedTasks.some((t) => t.status === '대기')) blockedBy.push('task');
+    return { id: m.id, order: p.order, title: m.label, status: p.status, mode: p.mode, goal: p.goal, waitingOn: p.waitingOn, done: p.done, deps, scenes, tasks: trackedTasks, progress: { live, total: scenes.length, fixed: scenes.filter((s) => s.fixed).length }, problems, src: m.src,
+      milestone: p.milestone ?? null, completedAt: p.completedAt ?? null, waitingSince: p.waitingSince ?? null, waitingWho: waiting.who, waitingWhat: waiting.what, blockedBy };
+  });
+  for (const t of taskView) t.roadmapItems = roadmap.filter((m) => m.tasks.some((x) => x.name === t.name)).map((m) => m.id);
+
+  // ---- 마일스톤(release 노드): 소속 항목·진척·막힘. problems·warnings는 check가 그대로 싣는 완성 문장이다 ----
+  const itemIds = new Set(roadmap.map((m) => m.id));
+  const milestoneView = releases.map((r) => {
+    const p = r.props;
+    const items = roadmap.filter((m) => m.milestone === r.id);
+    const sceneRefs = new Map(items.flatMap((m) => m.scenes.filter((s) => !s.missing)).map((s) => [s.ref, s]));
+    const planTasks = new Map(items.flatMap((m) => m.tasks.filter((t) => !t.missing)).map((t) => [t.name, t]));
+    const waiting = splitWaiting(p.waitingOn);
+    const at = `마일스톤 ${r.label}: `;
+    const problems = [], warnings = [];
+    if (p.idMissing) problems.push(`${at}id 없음`);
+    if (p.duplicates || itemIds.has(r.id)) problems.push(`마일스톤 id 중복: ${r.id}`);
+    if (!ROADMAP_STATUS.includes(p.status)) problems.push(`${at}알 수 없는 상태 ${p.status || '(비어 있음)'}`);
+    for (const [key, v] of [['완료일', p.completedOn], ['목표일', p.targetOn]]) if (v && !isDay(v)) problems.push(`${at}날짜 형식 ${key} ${v}`);
+    const open = items.filter((m) => m.status !== '완료');
+    if (p.status === '완료' && open.length) warnings.push(`${at}완료인데 미완료 항목 ${open.length}`);
+    if (p.status !== '완료' && items.length && !open.length) warnings.push(`${at}항목이 모두 완료인데 상태 ${p.status}`);
+    if (['다음', '대기', '이후'].includes(p.status) && items.some((m) => m.status === '진행')) warnings.push(`${at}진행 항목이 있는데 상태 ${p.status}`);
+    if (!items.length) warnings.push(`${at}묶인 항목 없음`);
+    if ((p.status === '완료') !== !!p.completedOn) warnings.push(`${at}완료일과 상태가 맞지 않음`);
+    return {
+      id: r.id, order: p.order, title: r.label, status: p.status, goal: p.goal, completedOn: p.completedOn || null, targetOn: p.targetOn || null,
+      waitingOn: p.waitingOn, waitingWho: waiting.who, waitingWhat: waiting.what, waitingSince: p.waitingSince ?? null,
+      items: items.map((m) => m.id), progress: { live: [...sceneRefs.values()].filter((s) => s.status === 'live').length, total: sceneRefs.size },
+      plans: { done: [...planTasks.values()].reduce((n, t) => n + (t.pnDone || 0), 0), total: [...planTasks.values()].reduce((n, t) => n + (t.pnDone || 0) + (t.pnOpen || 0), 0) },
+      blocked: !!p.waitingOn || open.some((m) => m.blockedBy.length > 0), problems, warnings, src: r.src,
+    };
   });
 
   const plans = taskView.filter((t) => t.pnDone + t.pnOpen > 0).map((t) => ({ task: t.name, title: t.title, done: t.pnDone, open: t.pnOpen, oq: t.oq }));
@@ -122,17 +199,94 @@ export function derive(g, sem, cfg, { captureExists }) {
     adapters: g.toJSON().adapters, semantic: { actors: sem.actors || {}, statusLegend: sem.statusLegend || {}, journeys },
     summary, orphans, coverage, tasks: taskView, roadmap, ledger, decisions: decisionView, plans, commits: commitView, areaCounts,
     screens: screenView, apis: apiView, functions: fnView, migrations: migView, tests: testView,
+    milestones: milestoneView, issues: g.issues.map((i) => ({ ...i })), sources: { semantic: cfg.semantic, roadmap: cfg.roadmap?.file ?? null },
   };
 }
 
 // 첫 화면 전용 조각: 시스템 식별자(경로·파일·sha)를 뺀다. 개요는 이것만 받는다.
-export function overviewSlice(d) {
+// 창은 generatedAt의 Asia/Seoul 날짜로 끝나는 opts.sinceDays(기본 14)일, 커밋 수는 작성자가 [bot]으로 끝나지 않는 사람 커밋만 센다.
+export function overviewSlice(d, opts = {}) {
   const A = d.semantic.actors;
+  const days = opts.sinceDays ?? 14;
+  const lastDay = Date.parse(`${seoulDay(d.generatedAt)}T00:00:00+09:00`);
+  const dates = Array.from({ length: days }, (_, i) => seoulDay(lastDay - (days - 1 - i) * 864e5));
+  const dayIndex = new Map(dates.map((x, i) => [x, i]));
+  const zeros = () => new Array(days).fill(0);
+  const sum = (xs) => xs.reduce((a, b) => a + b, 0);
+  const isBot = (c) => /\[bot\]$/.test(c.author || '');
+  const inWindow = (d.commits || []).filter((c) => dayIndex.has(seoulDay(c.date)));
+  const human = inWindow.filter((c) => !isBot(c));
+  const act = { commits: zeros(), runtime: zeros(), bots: zeros() };
+  for (const c of inWindow) { const i = dayIndex.get(seoulDay(c.date)); if (isBot(c)) act.bots[i] += 1; else { act.commits[i] += 1; if (c.runtime) act.runtime[i] += 1; } }
+
+  // 기능별 계열, 단계 hits, 기능 쌍 연결(닿은 기능이 2개 이상·전체 절반 이하인 커밋만)
+  const nJourneys = d.semantic.journeys.length;
+  const series = {}, hits = {}, pairs = new Map();
+  for (const c of human) {
+    const i = dayIndex.get(seoulDay(c.date));
+    const js = [...new Set(c.journeys.map((x) => x.journey))];
+    for (const j of js) (series[j] ||= zeros())[i] += 1;
+    for (const k of new Set(c.journeys.map((x) => `${x.journey}/${x.step}`))) hits[k] = (hits[k] || 0) + 1;
+    if (js.length >= 2 && js.length <= Math.floor(nJourneys / 2)) {
+      for (let a = 0; a < js.length; a++) for (let b = a + 1; b < js.length; b++) { const k = [js[a], js[b]].sort().join('|'); pairs.set(k, (pairs.get(k) || 0) + 1); }
+    }
+  }
+  const links = [...pairs].map(([k, n]) => { const [a, b] = k.split('|'); return { a, b, n }; }).sort((x, y) => y.n - x.n || `${x.a}${x.b}`.localeCompare(`${y.a}${y.b}`)).slice(0, 30);
+
+  // 로드맵 항목·마일스톤: 문구는 plain으로 줄이고, 항목 문구는 비완료만 싣는다
+  const milestoneList = d.milestones || [];
+  const milestoneById = new Map(milestoneList.map((m) => [m.id, m]));
+  const roadmapItems = (d.roadmap || []).slice().sort((a, b) => a.order - b.order).map((r) => {
+    const done = r.status === '완료';
+    const waitingOn = done ? '' : plain(r.waitingOn, 140);
+    const w = splitWaiting(waitingOn);
+    const scenes = (r.scenes || []).filter((s) => !s.missing);
+    return {
+      id: r.id, order: r.order, title: r.title, status: r.status, mode: r.mode, milestone: milestoneById.has(r.milestone) ? r.milestone : null,
+      goal: done ? '' : plain(r.goal, 140), waitingOn, waitingWho: w.who, waitingWhat: w.what, waitingSince: waitingOn ? r.waitingSince ?? null : null, completedAt: r.completedAt ?? null,
+      sceneCounts: Object.fromEntries(STEP_STATUS.map((k) => [k, scenes.filter((s) => s.status === k).length])),
+      tasks: (r.tasks || []).filter((t) => !t.missing).map((t) => ({ name: t.name, title: plain(t.title, 60), stage: t.stage, status: t.status, pnDone: t.pnDone, pnOpen: t.pnOpen })),
+      blockedBy: r.blockedBy || [],
+    };
+  });
+  const milestones = milestoneList.map((m) => {
+    const waitingOn = plain(m.waitingOn, 140);
+    const w = splitWaiting(waitingOn);
+    return {
+      id: m.id, order: m.order, title: m.title, status: m.status, goal: plain(m.goal, 140), completedOn: isDay(m.completedOn) ? m.completedOn : null, targetOn: isDay(m.targetOn) ? m.targetOn : null,
+      waitingWho: w.who, waitingWhat: w.what, waitingSince: waitingOn ? m.waitingSince ?? null : null, items: m.items, steps: m.progress, plans: m.plans, blocked: m.blocked,
+    };
+  });
+  const currentMilestone = (milestones.find((m) => m.status === '진행') || milestones.find((m) => m.status === '다음'))?.id ?? null;
+  const openItems = (d.roadmap || []).filter((r) => r.status !== '완료').sort((a, b) => a.order - b.order);
+
+  const captures = [];
+  for (const j of d.semantic.journeys) {
+    const s = j.steps.find((x) => x.status === 'live' && x.captureFile && !captures.some((c) => c.file === x.captureFile));
+    if (s && captures.length < 5) captures.push({ file: s.captureFile, journey: j.id, step: s.id });
+  }
+  const changes = human.slice().sort((a, b) => Date.parse(b.date) - Date.parse(a.date)).slice(0, 20).map((c) => {
+    const touched = new Set(c.journeys.map((x) => x.journey));
+    const titles = d.semantic.journeys.filter((j) => touched.has(j.id)).map((j) => j.title).slice(0, 3);
+    return { date: new Date(c.date).toISOString(), kind: changeKind(c.subject), subject: subjectPlain(c.subject, 70), journeys: titles, journeysMore: touched.size - titles.length };
+  });
+  const stepCounts = Object.fromEntries(STEP_STATUS.map((k) => [k, 0]));
+  for (const j of d.semantic.journeys) for (const s of j.steps) if (s.status in stepCounts) stepCounts[s.status] += 1;
   const lastRun = d.testreport ? { fresh: d.testreport.fresh, failures: d.testreport.failures, total: d.testreport.total, at: d.testreport.at } : null;
   return {
     generatedAt: d.generatedAt, project: d.project, headDate: d.head?.date || null,
     line: summaryLine(d),
-    journeys: d.semantic.journeys.map((j) => ({ id: j.id, title: j.title, actor: A[j.actor] || j.actor, lane: j.lane, status: j.status, warnings: j.warnings, steps: j.steps.map((s) => ({ id: s.id, label: s.label, status: s.status, grade: s.grade, warn: s.warnings.length > 0 })) })),
+    journeys: d.semantic.journeys.map((j) => {
+      const item = openItems.find((r) => (r.scenes || []).some((s) => !s.missing && s.journey === j.id));
+      const ms = item && milestoneById.get(item.milestone);
+      const js = series[j.id] || zeros();
+      return {
+        id: j.id, title: j.title, actor: A[j.actor] || j.actor, lane: j.lane, status: j.status, warnings: j.warnings,
+        steps: j.steps.map((s) => ({ id: s.id, label: s.label, status: s.status, grade: s.grade, warn: s.warnings.length > 0, hits: hits[`${j.id}/${s.id}`] || 0 })),
+        goal: plain(j.goal, 80), counts: j.counts, roadmapItem: item ? { id: item.id, title: item.title, status: item.status } : null, milestone: ms ? { id: ms.id, title: ms.title, status: ms.status } : null,
+        commits: sum(js), week: sum(js.slice(-7)), series: js,
+      };
+    }),
     running: d.ledger.running.map((r) => ({ work: r.work, owner: r.owner })),
     roadmap: d.roadmap.filter((m) => m.status !== '완료').slice(0, 4).map((m) => ({ id: m.id, title: m.title, status: m.status, mode: m.mode, live: m.progress.live, total: m.progress.total, waiting: !!m.waitingOn })),
     roadmapDone: d.roadmap.filter((m) => m.status === '완료').length, roadmapTotal: d.roadmap.length,
@@ -143,11 +297,16 @@ export function overviewSlice(d) {
       tests: lastRun ? (lastRun.failures ? 'fail' : lastRun.fresh ? 'ok' : 'stale') : 'none', lastRun,
       adapters: d.adapters.some((a) => a.status === 'failed') ? 'fail' : d.adapters.some((a) => a.status === 'partial') ? 'partial' : 'ok', adapterNotes: d.adapters.filter((a) => a.status !== 'ok').map((a) => `${a.name}: ${a.error}`),
       warnings: d.summary.warnings, orphans: d.summary.orphans, gated: d.tests.filter((t) => t.gated).reduce((n, t) => n + t.count, 0),
+      deployBehindAll: d.deploy?.behind ?? null,
     },
-    counts: { stepsLive: d.summary.stepsLive, stepsTotal: d.summary.stepsTotal, screensLive: d.summary.liveRoutes, screensFixed: d.summary.fixedRoutes, screens: d.summary.routes, apis: d.summary.apis, functions: d.summary.dbFunctions, tests: d.summary.tests, pnDone: d.summary.pnDone, pnTotal: d.summary.pnDone + d.summary.pnOpen, oq: d.summary.oq, decisions: d.decisions.filter((x) => x.status === 'current').length, proposed: d.decisions.filter((x) => x.status === 'proposed').length, grades: d.summary.grades },
+    counts: { stepsLive: d.summary.stepsLive, stepsTotal: d.summary.stepsTotal, screensLive: d.summary.liveRoutes, screensFixed: d.summary.fixedRoutes, screens: d.summary.routes, apis: d.summary.apis, functions: d.summary.dbFunctions, tests: d.summary.tests, pnDone: d.summary.pnDone, pnTotal: d.summary.pnDone + d.summary.pnOpen, oq: d.summary.oq, decisions: d.decisions.filter((x) => x.status === 'current').length, proposed: d.decisions.filter((x) => x.status === 'proposed').length, grades: d.summary.grades,
+      steps: stepCounts, journeys: nJourneys, journeysLive: d.semantic.journeys.filter((j) => j.status === 'live').length, tasksRunning: d.tasks.filter((t) => t.status === '진행').length },
     areas: Object.entries(d.areaCounts).sort((a, b) => b[1] - a[1]).slice(0, 6),
     recent: d.commits.filter((c) => c.journeys.length).slice(0, 6).map((c) => ({ date: c.date, subject: c.subject, scenes: c.journeys.map((x) => x.label) })),
     openQuestions: d.plans.filter((p) => p.oq).map((p) => ({ title: p.title, oq: p.oq })),
+    roadmapItems, milestones, currentMilestone,
+    activity: { sinceDays: days, days: dates.map((date, i) => ({ date, commits: act.commits[i], runtime: act.runtime[i], bots: act.bots[i] })), total: sum(act.commits), runtime: sum(act.runtime), bots: sum(act.bots) },
+    changes, links, captures,
   };
 }
 

package/src/lib/graph.mjs

@@ -1,10 +1,11 @@
 // 그래프 모델. 어댑터는 노드·엣지만 넣고, 화면은 파생 뷰만 읽는다.
 // 노드: { kind, id, label, props, src: { file, line, rule } }  엣지: { from, to, kind }
-export const NODE_KINDS = ['journey', 'step', 'screen', 'api', 'function', 'table', 'migration', 'test', 'commit', 'decision', 'task', 'ledger', 'deploy', 'testreport', 'milestone'];
+// 문제: { level: 'error'|'warn', label, message, adapter } — 어댑터가 g.issue로 낸 오류·경고. check가 줄로 출력한다.
+export const NODE_KINDS = ['journey', 'step', 'screen', 'api', 'function', 'table', 'migration', 'test', 'commit', 'decision', 'task', 'ledger', 'deploy', 'testreport', 'milestone', 'release'];
 export const EDGE_KINDS = ['has_step', 'shows', 'uses', 'calls', 'invokes', 'touches', 'covers', 'changes', 'refs', 'defines', 'contains', 'tracks'];
 
 export class Graph {
-  constructor() { this.nodes = new Map(); this.edges = []; this.adapters = []; }
+  constructor() { this.nodes = new Map(); this.edges = []; this.adapters = []; this.issues = []; this.adapter = null; }
   key(kind, id) { return `${kind}:${id}`; }
   add(kind, id, label, props = {}, src = null) {
     if (!NODE_KINDS.includes(kind)) throw new Error(`unknown node kind ${kind}`);
@@ -30,19 +31,28 @@ export class Graph {
     const to = this.key(kind, id);
     return this.edges.filter((e) => e.to === to && (!edgeKind || e.kind === edgeKind)).map((e) => this.nodes.get(e.from)).filter(Boolean);
   }
+  // 어댑터가 발견한 문제를 기록한다. level이 틀리면 throw해 그 어댑터가 failed가 된다. adapter는 runAdapter가 설정한 실행 중 이름.
+  issue(level, label, message) {
+    if (level !== 'error' && level !== 'warn') throw new Error(`issue level은 'error' 또는 'warn': ${level}`);
+    if (typeof label !== 'string' || typeof message !== 'string') throw new Error('issue label·message는 문자열');
+    this.issues.push({ level, label, message, adapter: this.adapter });
+  }
   report(name, status, count, error = null) { this.adapters.push({ name, status, count, error }); }
   toJSON() {
-    return { schemaVersion: 1, adapters: this.adapters, nodes: [...this.nodes.values()], edges: this.edges };
+    return { schemaVersion: 1, adapters: this.adapters, nodes: [...this.nodes.values()], edges: this.edges, issues: this.issues };
   }
 }
 
 // 어댑터 실행 래퍼: 실패해도 그래프 생성이 멈추지 않고 failed로 기록된다(빈 표를 "없음"으로 오해하지 않게).
 export function runAdapter(graph, name, fn) {
   const before = graph.nodes.size;
+  graph.adapter = name;
   try {
     const partial = fn(graph);
     graph.report(name, partial ? 'partial' : 'ok', graph.nodes.size - before, partial || null);
   } catch (e) {
     graph.report(name, 'failed', graph.nodes.size - before, String(e.message || e));
+  } finally {
+    graph.adapter = null;
   }
 }

package/templates/README.md

@@ -1,6 +1,6 @@
 # 프로젝트 상황판
 
-제품 오너가 코드를 읽지 않고 "어디까지 실제로 동작하나, 지금 무엇을 하나, 무엇이 바뀌었나"를 한 화면에서 보고, 여정 → 장면 → 화면·API·DB·검사·결정·작업으로 파고드는 뷰다. 엔진은 npm 패키지 `@pghoya2956/livemap`이고, 이 폴더에는 프로젝트 소유 파일만 둔다. 배포본 주소: `<배포 주소>/map/`. 실시간은 로컬 `npm run map:serve`.
+처음 보는 동료·외부 독자가 코드를 읽지 않고 "지금 어느 마일스톤이고 얼마나 왔나, 무엇이 동작하고 무엇이 남았나, 무엇을 기다리나, 최근 얼마나 바뀌었나"를 한 화면에서 보고, 기능 → 단계 → 화면·API·DB·검사·결정·작업으로 파고드는 뷰다. 엔진은 npm 패키지 `@pghoya2956/livemap`이고, 이 폴더에는 프로젝트 소유 파일만 둔다. 배포본 주소: `<배포 주소>/map/`. 실시간은 로컬 `npm run map:serve`.
 
 ## 명령
 
@@ -18,7 +18,7 @@
 | 파일 | 내용 |
 |---|---|
 | `config.json` | 어댑터 입력 경로·바닥값·화면 예산. `engine`은 엔진 major |
-| `semantic/journeys.json` | 손으로 유지하는 유일한 층: 배우·목표·장면. 장면 상태가 바뀌는 병합은 같은 커밋에서 이 파일을 고친다 |
+| `semantic/journeys.json` | 여정 파일: 배우·목표·장면. 장면 상태가 바뀌는 병합은 같은 커밋에서 이 파일을 고친다. 사람이 적는 곳은 이 파일과 로드맵(`config.json`의 `roadmap.file`, 마일스톤 포함)·작업 장부·작업 폴더 문서다 |
 | `captures/*.jpg` | 장면 캡처 |
 | `adapters/<이름>.mjs` | 이 프로젝트만의 어댑터(선택). 참조 어댑터와 이름이 같으면 참조 어댑터를 가린다 |