@kaydash9999/banker-plugins 0.23.2 → 0.24.0

package/skills/progress-mon/scripts/pm-check.mjs

@@ -3,7 +3,9 @@
 // 구성도와 workflow 기하는 렌더와 같은 배치 계산(archLayout, archFlaws, flowLayout)에 검사한다.
 // 밀도(4.9절)는 init 이 만든 자료 폴더(state.json 의 memory)나 inventory.json 이 있을 때만 재고, 미달은 WARN(종료 코드 영향 없음).
 // 항목마다 재는 밀도 미달 줄은 끝에 못 채운 대상 이름을 붙인다(`: a, b 외 n`).
-// 끝에 `density <탭> ok|low` 4줄. 형식 시험 자료와 옮긴 자료(둘 다 init 기록 없음)는 밀도를 재지 않는다.
+// ADR(adr.json)의 스키마, 참조, docs/adr 갈라짐은 pm-adr.mjs 가 검사한다.
+// 끝에 `density <탭> ok|low` 5줄(init 기록이 있을 때)과 늘 `adr 근거 없음 n칸, 미검증 n, 구현 못 함 n, 참조 없는 서술 n` 한 줄. ADR 밀도는 adr.json 이 있으면 늘 잰다.
+// 형식 시험 자료와 옮긴 자료(둘 다 init 기록 없음)는 밀도를 재지 않는다.
 import fs from 'node:fs';
 import path from 'node:path';
 import { loadConfig, noBom, readRegular, UsageError } from './pm-config.mjs';
@@ -12,6 +14,7 @@ import { ITEM_STATUS, STAGE_STATUS } from './pm-data.mjs';
 import { archLayout, archFlaws, flowLayout, nameFits, FLOW } from './pm-render.mjs';
 import { color, finite, textW, wrap, TABS } from './pm-html.mjs';
 import { memoryWarnings } from './pm-memory.mjs';
+import { checkAdr, adrRows, cleanAdr, adrTally } from './pm-adr.mjs';
 
 const arr = (v) => (Array.isArray(v) ? v : []);
 const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : null);
@@ -438,7 +441,8 @@ const lines23 = (n) => n >= 2 && n <= 3;
 
 // 돌려줌: { rows: [{tab, item, value, min, miss}], low: Set(탭) }. value < min 이면 미달.
 // miss 는 항목마다 재는 줄(상자, 단계, 흐름, 명세, 기타 항목)에서 기준을 못 채운 대상 이름. 수만 재는 줄은 빈 배열.
-export function density({ arch, flow, req, items, inv, storyCount }) {
+// adr: adr.json 값, adrBare: check 가 참조 확인으로 잰 참조 없는 서술 칸(없으면 적힌 참조로 잼).
+export function density({ arch, flow, req, items, inv, storyCount, adr, adrBare }) {
   const rows = [];
   const add = (tab, item, value, min, miss = []) => rows.push({ tab, item, value, min, miss });
   // 대상마다 ok 를 재어 값, 하한(대상 수), 못 채운 대상 이름을 한 줄로.
@@ -479,6 +483,13 @@ export function density({ arch, flow, req, items, inv, storyCount }) {
   each('workflow', '실패분기', lanes, (l) => arr(l.branches).length, (l) => l.id);
   each('workflow', '외부', lanes, (l) => arr(l.externals).length, (l) => l.id);
   each('workflow', '흐름설명', lanes, (l) => sentences(l.note) >= 3, (l) => `${l.id}(${sentences(l.note)}문장)`);
+  reqRows({ add, each }, req, items, storyCount);
+  rows.push(...adrRows(adr, adrBare));
+  return { rows, low: new Set(rows.filter((x) => x.value < x.min).map((x) => x.tab)) };
+}
+
+// 요구, 명세, 기록 탭 줄. add, each: density 의 줄 추가 함수.
+function reqRows({ add, each }, req, items, storyCount) {
   const at = (x, alt) => (req.where && req.where.get(x)) || alt;
   if (req.users.length) each('req', '요구', req.users, (u) => str(u.text) && str(u.source), (u, i) => at(u, `users[${i}]`));
   else add('req', '요구', 0, 1);
@@ -488,7 +499,6 @@ export function density({ arch, flow, req, items, inv, storyCount }) {
   const stated = req.specs.filter((x) => x.state !== undefined);
   each('req', '비고', stated, (x) => str(x.note), (x) => at(x, `specs[${req.specs.indexOf(x)}]`));
   each('history', '비고', items, (x) => str(x.note), (x, i) => (str(x.key) ? x.key : `items[${i}]`));
-  return { rows, low: new Set(rows.filter((x) => x.value < x.min).map((x) => x.tab)) };
 }
 
 // 밀도 미달 줄. 못 채운 대상이 있으면 `: ` 뒤에 앞 10개, 넘으면 `외 n`.
@@ -503,6 +513,24 @@ export function densityLine(x) {
 
 // ---------- 실행 ----------
 
+// state.json 의 memory(init 기록). 없거나 깨졌으면 null.
+function memoryOf(ctx) {
+  try {
+    const state = obj(JSON.parse(readRegular(path.join(ctx.dataDir, 'state.json'))));
+    return (state && obj(state.memory)) || null;
+  } catch {
+    return null;
+  }
+}
+
+// 메모리 경고를 WARN 줄로. 경고 줄에 뒤따르는 대안 줄은 그 WARN 한 줄에 붙인다.
+function memoryInto(r, memory, project, env) {
+  for (const l of memoryWarnings(memory, project, env)) {
+    if (l.startsWith('경고: ')) r.warn('state.json', 'memory', l.slice(4));
+    else if (r.lines.length) r.lines[r.lines.length - 1].msg += `. ${l}`;
+  }
+}
+
 // 검사 전체. 돌려줌: { lines: [출력 줄], fails }
 export function runCheck(ctx, env = process.env) {
   const r = sink();
@@ -514,35 +542,35 @@ export function runCheck(ctx, env = process.env) {
   const req = checkReq(ctx.dataDir, r, ids);
   const flow = checkFlow(ctx.dataDir, r);
   const arch = checkArch(ctx.dataDir, r, config.text.plannedPrefix);
+  const got = checkAdr(ctx, config, r);
+  const adr = got && got.value;
+  const adrBare = got ? got.bare : [];
   const inv = checkInventory(ctx, r);
-  let state = null;
-  try {
-    state = obj(JSON.parse(readRegular(path.join(ctx.dataDir, 'state.json'))));
-  } catch {
-    state = null;
-  }
-  const memory = state && obj(state.memory);
-  // 경고 줄에 뒤따르는 대안 줄을 붙여 WARN 한 줄로.
-  for (const l of memoryWarnings(memory, ctx.project, env)) {
-    if (l.startsWith('경고: ')) r.warn('state.json', 'memory', l.slice(4));
-    else if (r.lines.length) r.lines[r.lines.length - 1].msg += `. ${l}`;
-  }
+  const memory = memoryOf(ctx);
+  memoryInto(r, memory, ctx.project, env);
   const out = r.lines.map((x) => `${x.level} ${x.file} ${x.path} ${x.msg}`);
   if (config.sources.workflowDirs === 'auto' && !workflowRoots(config, ctx, env).length) out.push('WARN workflowDirs auto: 찾은 폴더 0');
-  let dens = null;
-  if (inv || memory) {
-    dens = density({ arch, flow, req, items: items.items, inv, storyCount: ids.length });
-    for (const x of dens.rows) if (x.value < x.min) out.push(densityLine(x));
-  }
+  // 밀도는 init 기록이나 inventory.json 이 있을 때만. 다만 ADR 밀도는 adr.json 이 있으면 늘 낸다
+  const dens = inv || memory ? density({ arch, flow, req, items: items.items, inv, storyCount: ids.length, adr, adrBare }) : null;
+  const rows = dens ? dens.rows : adr ? adrRows(adr, adrBare) : [];
+  return finish(out, rows, dens, adrTally(adr, adrBare).text);
+}
+
+// 밀도 미달 줄, 합계 줄, 탭별 밀도 요약, ADR 집계(근거 없음 칸, 미검증, 구현 못 함, 참조 없는 서술. 늘 한 줄)를 붙인다. 돌려줌: { lines, fails }
+function finish(out, rows, dens, tally) {
+  for (const x of rows) if (x.value < x.min) out.push(densityLine(x));
   const fails = out.filter((l) => l.startsWith('FAIL ')).length;
   out.push(`check: FAIL ${fails}, WARN ${out.length - fails}`);
   if (dens) for (const [k] of TABS) out.push(`density ${k} ${dens.low.has(k) ? 'low' : 'ok'}`);
+  out.push(`adr ${tally}`);
   return { lines: out, fails };
 }
 
+// --adr-cleanup: 검사 전에 init 정리 단계(pm-adr.mjs cleanAdr)를 적용한다. 그 밖에는 자료를 바꾸지 않는다.
 export async function command(cmd, ctx, o, io) {
   if (cmd !== 'check') throw new UsageError(`${cmd} 는 pm-check.mjs 가 맡지 않음`);
   if (o._.length > 1) throw new UsageError(`check 는 위치 인자를 받지 않음: ${o._.slice(1).join(' ')}`);
+  if (o['adr-cleanup'] && ctx.exists) for (const l of await cleanAdr(ctx, loadConfig(ctx).config)) io.out(l);
   const { lines, fails } = runCheck(ctx);
   for (const l of lines) io.out(l);
   return fails ? 1 : 0;

package/skills/progress-mon/scripts/pm-data.mjs

@@ -284,7 +284,7 @@ function storyChange(o, now, configIds) {
 
 // ---------- init ----------
 
-const NEXT = ['다음 할 일', '  1. references/authoring.md 를 읽고 req-spec.json, reqs.json, flow.json, arch.json 작성', '  2. check 로 검사. FAIL 0 까지 최대 3회', '  3. start 로 서버 시작'];
+const NEXT = ['다음 할 일', '  1. references/authoring.md 를 읽고 req-spec.json, reqs.json, flow.json, arch.json, adr.json 작성', '  2. check 로 검사. FAIL 0 까지 최대 3회', '  3. start 로 서버 시작'];
 
 const slash = (p) => p.split(path.sep).join('/');
 const realOr = (p) => {

package/skills/progress-mon/scripts/pm-html.mjs

@@ -71,6 +71,7 @@ export const TABS = [
   ['req', '구현요건'],
   ['workflow', 'workflow'],
   ['arch', '구성도'],
+  ['adr', 'ADR'],
 ];
 
 // 서버 화면의 탭 머리. cur 는 켜진 탭 id.

package/skills/progress-mon/scripts/pm-memory.mjs

@@ -1,4 +1,5 @@
 // pm-memory.mjs: 메모리 규칙 등록(계획 6.2절). 표식으로 중복을 막고 사용자 파일은 끝에 덧붙이기만 한다.
+// 예외: 표식이 붙은 우리 줄(앞머리로 가린 규칙 줄과 색인 줄)이 지금 판과 다르면 그 줄만 제자리에서 바꾼다(첫 원본은 .progress-mon.bak).
 // 대상 파일은 에이전트가 넘긴다(--memory, --memory-dir). 스크립트는 HOME 아래 쓰기 경로를 스스로 만들지 않는다.
 // 덧붙인 뒤 규칙 로드 한도를 재고 경고 줄을 낸다(종료 코드는 그대로). status, check 도 같은 측정을 다시 한다.
 import fs from 'node:fs';
@@ -14,22 +15,33 @@ const KINDS = ['claude-md', 'agents-md', 'auto-memory', 'none'];
 // 규칙 줄. 경로는 자료 폴더 기준 상대 표기뿐(스킬 폴더 절대 경로는 state.json 의 skillDir).
 export function ruleLine(runtime) {
   if (runtime === 'codex') {
-    return `진척도 화면(progress-mon): 모든 명령에 --runtime codex 를 붙임. 단계는 stage, 스토리는 story, 그 밖 작업은 item 으로 갱신. .omx/progress-mon/state.json 의 skillDir 아래 scripts/progress-mon.mjs 를 node 로 직접 실행하고, 실패하면 banker-progress-mon 스킬(플러그인 설치는 banker:progress-mon)로 호출. 세션 시작 때 status, 꺼져 있으면 start. start, stop, status 는 sandbox_permissions "require_escalated" 로 승인 요청. 세션을 닫아도 화면을 두려면 사용자 터미널에서 serve 실행을 안내. ${MARKER}`;
+    return `진척도 화면(progress-mon): 모든 명령에 --runtime codex 를 붙임. 단계는 stage, 스토리는 story, 그 밖 작업은 item 으로 갱신. 결정이 생기거나 스토리가 끝나면 .omx/progress-mon/adr.json(ADR 탭)을 고치고 check. .omx/progress-mon/state.json 의 skillDir 아래 scripts/progress-mon.mjs 를 node 로 직접 실행하고, 실패하면 banker-progress-mon 스킬(플러그인 설치는 banker:progress-mon)로 호출. 세션 시작 때 status, 꺼져 있으면 start. start, stop, status 는 sandbox_permissions "require_escalated" 로 승인 요청. 세션을 닫아도 화면을 두려면 사용자 터미널에서 serve 실행을 안내. ${MARKER}`;
   }
-  return `진척도 화면(progress-mon): 단계는 stage, 스토리는 story, 그 밖 작업은 item 으로 갱신. .omc/progress-mon/state.json 의 skillDir 아래 scripts/progress-mon.mjs 를 node 로 직접 실행하고, 실패하면 progress-mon 스킬로 호출. 세션 시작 때 status, 꺼져 있으면 start. ${MARKER}`;
+  return `진척도 화면(progress-mon): 단계는 stage, 스토리는 story, 그 밖 작업은 item 으로 갱신. 결정이 생기거나 스토리가 끝나면 .omc/progress-mon/adr.json(ADR 탭)을 고치고 check. .omc/progress-mon/state.json 의 skillDir 아래 scripts/progress-mon.mjs 를 node 로 직접 실행하고, 실패하면 progress-mon 스킬로 호출. 세션 시작 때 status, 꺼져 있으면 start. ${MARKER}`;
 }
 
 // 자동 메모리 규칙 파일(새로 만들 때)과 MEMORY.md 색인 줄.
 const ruleFile = (runtime) => `---
 name: progress-mon
-description: 진척도 화면(progress-mon) 갱신 규칙. 단계, 스토리, 그 밖 작업을 stage, story, item 으로 기록
+description: 진척도 화면(progress-mon) 갱신 규칙. 단계, 스토리, 그 밖 작업을 stage, story, item 으로, 결정은 adr.json 에 기록
 metadata:
   type: feedback
 ---
 
 ${ruleLine(runtime)}
 `;
-const INDEX_LINE = `- [진척도 화면 갱신 규칙](progress-mon.md) - stage, story, item 으로 progress-mon 갱신 ${MARKER}`;
+export const INDEX_LINE = `- [진척도 화면 갱신 규칙](progress-mon.md) - stage, story, item 과 adr.json 으로 progress-mon 갱신 ${MARKER}`;
+
+// 표식 줄 가운데 우리가 쓴 줄을 가리는 앞머리. 규칙 줄의 런타임은 `--runtime codex` 가 있으면 codex.
+const RULE_HEAD = '진척도 화면(progress-mon):';
+const INDEX_HEAD = '- [진척도 화면 갱신 규칙](progress-mon.md)';
+// 표식 줄이 지금 판에서 되어야 할 줄. 앞머리가 다른 표식 줄(사용자가 쓴 줄 등)은 null(손대지 않음).
+export function currentLine(line) {
+  if (!line.includes(MARKER)) return null;
+  if (line.startsWith(INDEX_HEAD)) return INDEX_LINE;
+  if (line.startsWith(RULE_HEAD)) return ruleLine(line.includes('--runtime codex') ? 'codex' : 'claude');
+  return null;
+}
 
 // ---------- 한도 ----------
 
@@ -250,6 +262,8 @@ function inspect(file, name, base, alt = '') {
   return { exists: true, text, eol: text.includes('\r\n') ? '\r\n' : '\n' };
 }
 
+const changedError = (file) => new UsageError(`${path.basename(file)} 이 검사 뒤 하드링크나 특수 파일로 바뀌어 쓰지 않음`);
+
 // 원본 바이트를 그대로 두고 끝에 줄을 덧붙인다. 마지막 줄에 줄바꿈이 없으면 먼저 넣는다.
 // 연 fd 를 fstat 으로 다시 본다: 검사(inspect)와 쓰기 사이에 하드링크나 특수 파일로 바뀌었으면 쓰지 않는다.
 function append(file, info, lines) {
@@ -258,10 +272,20 @@ function append(file, info, lines) {
   // O_NONBLOCK: 검사 뒤 FIFO 로 바뀐 자리에서 open 이 읽는 쪽을 기다리며 멈추지 않게 한다(Windows 에는 없어 0)
   const { O_WRONLY, O_APPEND, O_CREAT, O_EXCL } = fs.constants;
   const flags = O_WRONLY | (fs.constants.O_NONBLOCK || 0) | O_CREAT | (info.exists ? O_APPEND : O_EXCL);
-  const fd = fs.openSync(file, flags, 0o666);
+  const changed = () => changedError(file);
+  let fd;
+  try {
+    fd = fs.openSync(file, flags, 0o666);
+  } catch (e) {
+    // 읽는 쪽이 없는 FIFO(ENXIO)는 검사 뒤 바뀐 자리다. EAGAIN 은 막힌 특수 파일이나 다른 프로세스의 잠금(lease)일 수 있다.
+    // 둘 다 날 오류 대신 거부 문구로 끝낸다
+    if (e.code === 'ENXIO') throw changed();
+    if (e.code === 'EAGAIN') throw new UsageError(`${path.basename(file)} 이 검사 뒤 바뀌었거나 다른 프로세스가 잡고 있어 쓰지 않음`);
+    throw e;
+  }
   try {
     const st = fs.fstatSync(fd);
-    if (!st.isFile() || st.nlink > 1) throw new UsageError(`${path.basename(file)} 이 검사 뒤 하드링크나 특수 파일로 바뀌어 쓰지 않음`);
+    if (!st.isFile() || st.nlink > 1) throw changed();
     fs.writeFileSync(fd, body); // 다 쓸 때까지 반복
   } finally {
     fs.closeSync(fd);
@@ -302,32 +326,103 @@ export function planMemory({ kind, memoryDir, project, runtime }) {
   return { kind, runtime, steps: [{ file: t.file, name, info: inspect(t.file, name, root, AGENTS_ALT), what: 'block' }], memory: { kind, path: t.file } };
 }
 
+// 표식 줄 가운데 우리 줄만 지금 판으로 바꾼 글. 줄 끝(CRLF, LF)과 나머지 줄은 그대로. 돌려줌: { text, changed }
+function refreshText(text) {
+  let changed = 0;
+  const out = text.split('\n').map((seg) => {
+    const cr = seg.endsWith('\r') ? '\r' : '';
+    const line = cr ? seg.slice(0, -1) : seg;
+    const want = currentLine(line);
+    if (want === null || want === line) return seg;
+    changed++;
+    return want + cr;
+  });
+  return { text: out.join('\n'), changed };
+}
+
+const RENAME_CODES = new Set(['EPERM', 'EBUSY', 'EACCES']);
+const pause = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+
+// 같은 파일을 원자적으로 다시 쓴다: 대상(링크면 실제 파일) 옆 임시 파일에 쓰고 권한을 맞춘 뒤 rename.
+// 쓰기 전에 대상을 다시 보고 하드링크나 특수 파일로 바뀌었으면 쓰지 않는다. 실패하면 임시 파일을 지우고 원본 그대로.
+function rewrite(file, body) {
+  const real = fs.realpathSync(file);
+  const st = fs.statSync(real);
+  if (!st.isFile() || st.nlink > 1) throw changedError(file);
+  const tmp = `${real}.${process.pid}.${Date.now().toString(36)}.tmp`;
+  try {
+    fs.writeFileSync(tmp, body, { flag: 'wx', mode: st.mode & 0o777 });
+    fs.chmodSync(tmp, st.mode & 0o7777);
+    for (let i = 0; ; i++) {
+      try {
+        fs.renameSync(tmp, real);
+        return;
+      } catch (e) {
+        if (i >= 4 || !RENAME_CODES.has(e.code)) throw e;
+        pause(50); // Windows 에서 다른 프로세스가 잠깐 쥔 파일
+      }
+    }
+  } catch (e) {
+    fs.rmSync(tmp, { force: true });
+    throw e instanceof UsageError ? e : new UsageError(`${path.basename(file)} 쓰기 실패(${e.code || e.message}). 원본 그대로`);
+  }
+}
+
+// 첫 원본 백업. 이미 있으면 덮지 않는다. 만들지 못하면 바꾸지 않고 거부.
+function backup(file, buf) {
+  const bak = `${file}.progress-mon.bak`;
+  try {
+    fs.writeFileSync(bak, buf, { flag: 'wx' });
+  } catch (e) {
+    if (e.code !== 'EEXIST') throw new UsageError(`${path.basename(bak)} 백업을 만들지 못해 규칙 줄을 바꾸지 않음(${e.code || e.message})`);
+  }
+  return bak;
+}
+
+// 표식이 이미 있는 파일. 우리 줄이 지금 판과 다를 때만 그 줄을 바꾸고 백업을 남긴다. BOM 과 나머지 바이트는 그대로.
+// 검사 뒤 UTF-8 이 아니게 바뀐 파일은 바꾸지 않고 경고 줄(U+FFFD 로 바뀐 바이트를 쓰지 않게).
+function refreshStep(s) {
+  const buf = fs.readFileSync(s.file);
+  const bom = buf.length >= 3 && buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf;
+  let text;
+  try {
+    text = new TextDecoder('utf-8', { fatal: true }).decode(bom ? buf.subarray(3) : buf);
+  } catch {
+    return `경고: ${s.name} 이 UTF-8 이 아니라 규칙 줄을 바꾸지 않음`;
+  }
+  const r = refreshText(text);
+  if (!r.changed) return `규칙 이미 있음: ${s.name}`;
+  const bak = backup(s.file, buf);
+  rewrite(s.file, Buffer.concat([bom ? buf.subarray(0, 3) : Buffer.alloc(0), Buffer.from(r.text, 'utf8')]));
+  return `규칙 줄 교체(백업 ${bak}): ${s.name}`;
+}
+
+// 표식이 없는 파일에 규칙을 더한다. 돌려줌: 출력 줄.
+function addStep(s, runtime) {
+  const { info } = s;
+  const fresh = !info.exists;
+  const made = fresh ? '새로 만듦, ' : '';
+  if (s.what === 'rule-file') {
+    if (fresh) fs.writeFileSync(s.file, ruleFile(runtime), { flag: 'wx' });
+    else append(s.file, info, [ruleLine(runtime)]);
+    return `규칙 추가: ${s.name} (${fresh ? '새로 만듦' : '1줄'})`;
+  }
+  if (s.what === 'index') {
+    append(s.file, info, [INDEX_LINE]);
+    return `규칙 추가: ${s.name} (${made}색인 1줄)`;
+  }
+  if (s.what === 'line') {
+    append(s.file, info, [ruleLine(runtime)]);
+    return `규칙 추가: ${s.name} (${made}1줄)`;
+  }
+  append(s.file, info, [OMX_OPEN, ruleLine(runtime), OMX_CLOSE]);
+  return `규칙 추가: ${s.name} (${made}3줄)`;
+}
+
 // 계획대로 쓴다. 돌려줌: 출력 줄 목록(규칙 줄, 경고 줄).
 export function applyMemory(plan, project, env = process.env) {
   if (plan.kind === 'none') return ['규칙 등록 안 함(--memory none)'];
-  const out = [];
   if (plan.dir) fs.mkdirSync(plan.dir, { recursive: true });
-  for (const s of plan.steps) {
-    const { info } = s;
-    if (info.text.includes(MARKER)) {
-      out.push(`규칙 이미 있음: ${s.name}`);
-      continue;
-    }
-    const fresh = !info.exists;
-    if (s.what === 'rule-file') {
-      if (fresh) fs.writeFileSync(s.file, ruleFile(plan.runtime), { flag: 'wx' });
-      else append(s.file, info, [ruleLine(plan.runtime)]);
-      out.push(`규칙 추가: ${s.name} (${fresh ? '새로 만듦' : '1줄'})`);
-    } else if (s.what === 'index') {
-      append(s.file, info, [INDEX_LINE]);
-      out.push(`규칙 추가: ${s.name} (${fresh ? '새로 만듦, ' : ''}색인 1줄)`);
-    } else if (s.what === 'line') {
-      append(s.file, info, [ruleLine(plan.runtime)]);
-      out.push(`규칙 추가: ${s.name} (${fresh ? '새로 만듦, ' : ''}1줄)`);
-    } else {
-      append(s.file, info, [OMX_OPEN, ruleLine(plan.runtime), OMX_CLOSE]);
-      out.push(`규칙 추가: ${s.name} (${fresh ? '새로 만듦, ' : ''}3줄)`);
-    }
-  }
+  const out = plan.steps.map((s) => (s.info.text.includes(MARKER) ? refreshStep(s) : addStep(s, plan.runtime)));
   return [...out, ...memoryWarnings(plan.memory, project, env)];
 }

package/skills/progress-mon/scripts/pm-render.mjs

@@ -1,4 +1,4 @@
-// pm-render.mjs: 4탭(진척도, 구현요건, workflow, 구성도)과 단일 HTML 스냅숏, workflow 배치와 구성도 자동 배치.
+// pm-render.mjs: 5탭(진척도, 구현요건, workflow, 구성도, ADR)과 단일 HTML 스냅숏, workflow 배치와 구성도 자동 배치.
 // 옛 진척도 서버의 클래스 이름과 DOM 구조를 그대로 둔다. 저장소 고유 값은 config.json 에서 읽는다.
 // 시각은 now 인자로만 받는다. CLI 하위 명령 export 도 여기서 맡는다.
 import fs from 'node:fs';
@@ -6,6 +6,7 @@ import path from 'node:path';
 import { esc, color, finite, textW, wrap, FAVICON, CSS, TABS, tabsHtml } from './pm-html.mjs';
 import { configOrFail, loadConfig, UsageError, DEFAULT_REQ_RULE, STORYLESS_REQ_RULE } from './pm-config.mjs';
 import { collect, parseTime, agentJudge } from './pm-sources.mjs';
+import { adrBody } from './pm-adr.mjs';
 
 const two = (n) => String(n).padStart(2, '0');
 const hm = (ms) => (ms == null ? '-' : Math.floor(ms / 3600e3) + ':' + two(Math.floor((ms % 3600e3) / 60000)));
@@ -1540,13 +1541,14 @@ ${legend ? `<h2>읽는 법</h2><ul class="meta">${legend}</ul>` : ''}
 export const tabKey = (tab) => (tab === 'flow' ? 'workflow' : TABS.some((t) => t[0] === tab) ? tab : 'history');
 
 function tabBody(m, config, k, now) {
+  if (k === 'adr') return adrBody(m, emptyNotice);
   if (k === 'arch') return archBody(m, config);
   if (k === 'workflow') return flowBody(m);
   if (k === 'req') return reqBody(m, config);
   return historyBody(m, config, now);
 }
 
-// 모은 자료(m)로 탭 하나의 HTML. workflow 와 구성도는 움직임이 있고 자주 바뀌지 않아 자동 갱신하지 않는다.
+// 모은 자료(m)로 탭 하나의 HTML. workflow, 구성도, ADR 은 자주 바뀌지 않아 자동 갱신하지 않는다.
 export function pageFrom(m, config, tab, now) {
   const k = tabKey(tab);
   const refresh = k === 'history' || k === 'req' ? `<meta http-equiv="refresh" content="${config.refreshSec};url=/?tab=${k}">` : '';
@@ -1560,8 +1562,8 @@ ${tabsHtml(k)}
 ${tabBody(m, config, k, now)}</body></html>`;
 }
 
-// 단일 HTML 스냅숏: 네 탭을 한 파일에. 서버, 자동 갱신, 외부 자원 없이 file:// 로 열린다.
-// 탭 전환은 주소의 #history, #req, #workflow, #arch 와 짧은 인라인 스크립트. 스크립트가 꺼져 있으면 네 탭을 모두 보인다.
+// 단일 HTML 스냅숏: 다섯 탭을 한 파일에. 서버, 자동 갱신, 외부 자원 없이 file:// 로 열린다.
+// 탭 전환은 주소의 #history, #req, #workflow, #arch, #adr 와 짧은 인라인 스크립트. 스크립트가 꺼져 있으면 다섯 탭을 모두 보인다.
 export function snapshotFrom(m, config, now) {
   const tabs = TABS.map(([k, name]) => `<a href="#${k}" data-tab="${k}">${esc(name)}</a>`).join('');
   const secs = TABS.map(([k, name]) => `<section id="tab-${k}" class="tab"><h2 class="tt">${esc(name)}</h2>\n\n${tabBody(m, config, k, now)}</section>`).join('\n');

package/skills/progress-mon/scripts/pm-server.mjs

@@ -102,24 +102,30 @@ function openLog(file, append = true) {
   return fd;
 }
 
-// 한도를 넘은 server.log 를 server.log.1 로 옮기고 새 fd 를 돌려준다(rename 은 링크를 따라가지 않음).
-// 옮기지 못하면(그 자리에 폴더 등) 로그를 버리지 않도록 연 fd(일반 파일로 확인함)를 비우고 계속 쓰며, 그 사실을 onWarn 으로 한 번 알린다.
-function rotateLog(file, fd, warn) {
+// 한도를 넘은 server.log 를 server.log.1 로 옮기고 새 fd 를 돌려준다(rename 은 링크를 따라가지 않음). 옮기면 ok() 를 부른다.
+// 옮긴 뒤 새 파일을 못 열면 그 오류를 던진다(옮기기는 된 것이라 쓰기 실패로 알림).
+function rotateLog(file, fd, warn, ok) {
   fs.closeSync(fd);
   try {
     fs.renameSync(file, `${file}.1`);
-    return openLog(file);
   } catch (e) {
-    const again = openLog(file, false);
-    try {
-      fs.ftruncateSync(again, 0);
-    } catch (t) {
-      fs.closeSync(again);
-      throw t;
-    }
-    warn(`server.log 를 server.log.1 로 옮기지 못함(${e.code || e.message}). 대신 server.log 를 비우고 계속 기록. server.log.1 자리를 치우면 다시 옮김`);
-    return again;
+    return keepLog(file, e, warn);
   }
+  ok();
+  return openLog(file);
+}
+
+// 옮기지 못하면(그 자리에 폴더 등) 로그를 버리지 않도록 server.log(일반 파일로 확인함)를 비우고 계속 쓰며, 그 사실을 warn 으로 알린다.
+function keepLog(file, e, warn) {
+  const again = openLog(file, false);
+  try {
+    fs.ftruncateSync(again, 0);
+  } catch (t) {
+    fs.closeSync(again);
+    throw t;
+  }
+  warn(`server.log 를 server.log.1 로 옮기지 못함(${e.code || e.message}). 대신 server.log 를 비우고 계속 기록. server.log.1 자리를 치우면 다시 옮김`);
+  return again;
 }
 
 // server.log 를 못 쓴 까닭의 경고 문구. 링크, 특수 파일, 하드링크 거부와 fs 오류를 나눈다.
@@ -128,34 +134,79 @@ function logFailure(e) {
   return `server.log 에 기록하지 못함(${(e && (e.code || e.message)) || e}). 서버는 계속`;
 }
 
+const PENDING_KEEP = 10; // 쓰지 못하고 쌓아 두는 경고와 회복 줄은 앞 10줄과 뒤 10줄만 남기고 가운데는 개수만 남긴다
+
+// server.log 경고 상태. 종류별 칸이 따로 있다: 'fail' 은 기록이 멈춘 경고라 쓰기가 다시 되면 지우고, 'rotate' 는 다음 옮기기가 되면 지운다.
+// 같은 까닭은 한 번만 알리고, 까닭이 바뀌면 다시 알린다. status 에는 fail 이 있으면 fail, 없으면 rotate 를 보인다(바뀔 때만 onWarn).
+// 알림과 회복 줄은 쌓아 두었다가 다음에 쓰는 줄과 함께 쓴다. 쓰기에 성공한 뒤에만 비운다
+function logWarnings(onWarn) {
+  const shown = { fail: null, rotate: null };
+  let lines = [];
+  let dropped = 0;
+  let droppedAt = ''; // 처음 빠진 줄의 시각. 생략 줄에 써서 로그 시각이 거꾸로 가지 않게 한다
+  const current = () => shown.fail || shown.rotate;
+  const set = (kind, text) => {
+    const before = current();
+    shown[kind] = text;
+    if (current() !== before) onWarn(current());
+  };
+  // 처음 까닭과 최신 까닭(회복 줄 포함)이 함께 남도록 넘치면 가운데 줄을 뺀다
+  const note = (text) => {
+    lines.push(`${new Date().toISOString()} ${text}\n`);
+    if (lines.length > PENDING_KEEP * 2) {
+      const [gone] = lines.splice(PENDING_KEEP, 1);
+      if (!dropped) droppedAt = gone.slice(0, gone.indexOf(' '));
+      dropped++;
+    }
+  };
+  const omitted = () => (dropped ? [`${droppedAt} 경고: 쓰지 못한 경고와 회복 줄 ${dropped}개 생략\n`] : []);
+  return {
+    warn(kind, text) {
+      if (shown[kind] === text) return;
+      set(kind, text);
+      note(`경고: ${text}`);
+    },
+    clear(kind) {
+      if (!shown[kind]) return false;
+      note(`회복: 앞의 경고가 풀림(${shown[kind]})`);
+      set(kind, null);
+      return true;
+    },
+    head: () => [...lines.slice(0, PENDING_KEEP), ...omitted(), ...lines.slice(PENDING_KEEP)].join(''),
+    sent() {
+      lines = [];
+      dropped = 0;
+    },
+  };
+}
+
 // server.log 한 줄 덧붙이기. 덧붙이면 max(1 MB)를 넘을 때 먼저 server.log.1 로 옮긴다(대상을 자르지 않음).
-// 링크이거나 일반 파일이 아니면 쓰지 않는다. 옮기지 못한 일은 onWarn(서버의 status 경고)과 로그의 경고 줄로 한 번 알린다. 실패해도 서버는 계속.
+// 링크이거나 일반 파일이 아니면 쓰지 않는다. 못 쓰거나 옮기지 못한 일은 onWarn(서버의 status 경고)과 로그의 경고 줄로 알리고,
+// 회복하면 onWarn(null) 로 status 경고를 지운다. 실패해도 서버는 계속.
 export function makeLogger(dataDir, max = LOG_MAX, onWarn = () => {}) {
   const file = logPath(dataDir);
-  let warned = false;
-  let pending = ''; // 다음 줄 앞에 남길 경고 한 줄
-  const warn = (w) => {
-    if (warned) return;
-    warned = true;
-    onWarn(w);
-    pending = `${new Date().toISOString()} 경고: ${w}\n`;
-  };
+  const w = logWarnings(onWarn);
+  const rotateWarn = (text) => w.warn('rotate', text);
+  const rotateOk = () => w.clear('rotate');
   return (msg) => {
     const line = `${new Date().toISOString()} ${msg}\n`;
     let fd = null;
     try {
       fd = openLog(file);
-      if (fs.fstatSync(fd).size + Buffer.byteLength(line) > max) {
+      if (fs.fstatSync(fd).size + Buffer.byteLength(w.head() + line) > max) {
         const old = fd;
         fd = null;
-        fd = rotateLog(file, old, warn);
+        fd = rotateLog(file, old, rotateWarn, rotateOk);
+      }
+      fs.writeSync(fd, w.head() + line);
+      w.sent();
+      if (w.clear('fail')) {
+        fs.writeSync(fd, w.head());
+        w.sent();
       }
-      if (pending) fs.writeSync(fd, pending);
-      pending = '';
-      fs.writeSync(fd, line);
     } catch (e) {
-      // 로그를 못 써도 응답은 계속. 기록이 멈춘 것을 까닭과 함께 한 번 알린다(status 경고)
-      warn(logFailure(e));
+      // 로그를 못 써도 응답은 계속. 기록이 멈춘 것을 까닭과 함께 알린다(status 경고)
+      w.warn('fail', logFailure(e));
     } finally {
       if (fd !== null) fs.closeSync(fd);
     }
@@ -729,7 +780,7 @@ function tabData(dataDir) {
       return e.code === 'ENOENT' ? '없음' : '깨짐';
     }
   };
-  return `진척도 ${has('items.json')}, 구현요건 ${has('req-spec.json')}, workflow ${has('flow.json')}, 구성도 ${has('arch.json')}`;
+  return `진척도 ${has('items.json')}, 구현요건 ${has('req-spec.json')}, workflow ${has('flow.json')}, 구성도 ${has('arch.json')}, ADR ${has('adr.json')}`;
 }
 
 // 서버를 띄운 뒤 config.json 의 port, portStrict, hosts 가 바뀌었으면 경고 한 줄(그 값은 다시 띄워야 적용).
@@ -764,6 +815,7 @@ export async function status(ctx, io) {
   const run = await runningServer(ctx.dataDir);
   if (!run) {
     io.out(`꺼짐(자료 폴더: ${label})`);
+    io.out(`탭 자료: ${tabData(ctx.dataDir)}`);
     statusWarnings(ctx, io);
     return 3;
   }

package/skills/progress-mon/scripts/pm-sources.mjs

@@ -497,5 +497,6 @@ export function collect(ctx, config, now, inject = {}) {
     reqs: tab('reqs.json'),
     flow: tab('flow.json'),
     arch: tab('arch.json'),
+    adr: tab('adr.json'),
   };
 }

package/skills/progress-mon/scripts/progress-mon.mjs

@@ -27,7 +27,8 @@ export const HELP = `progress-mon: 프로젝트 진척도 웹 화면
   note      --key <k> [--note <t>] [--issue <t>]
   stage     --id <id> --status started|done|skipped|failed|stopped [--label <t>]
   story     --id <id> (--status todo|doing|done | --commit <hash>) [--name <t>]
-  check     자료 파일 검사. FAIL, WARN 한 줄씩
+  check     [--adr-cleanup]
+            자료 파일 검사. FAIL, WARN 한 줄씩. --adr-cleanup 은 먼저 adr.json 정리(참조 FAIL 은 gap, 스키마 FAIL 이 남으면 adr.json.rejected-<시각> 으로 옮김)
 
 공통 인자
   --runtime claude|codex    자료 폴더 기본값(.omc/progress-mon/, .omx/progress-mon/)
@@ -39,7 +40,7 @@ export const HELP = `progress-mon: 프로젝트 진척도 웹 화면
 
 // 값을 받는 인자와 값 없는 인자.
 const VALUE_FLAGS = new Set(['runtime', 'project', 'data', 'port', 'host', 'memory', 'memory-dir', 'title', 'now', 'key', 'status', 'text', 'note', 'issue', 'id', 'label', 'commit', 'name', 'at']);
-const BOOL_FLAGS = new Set(['port-strict', 'help']);
+const BOOL_FLAGS = new Set(['port-strict', 'help', 'adr-cleanup']);
 
 // 서버 밖 명령을 맡는 모듈. 쓰는 명령에서만 적재한다.
 const MODS = {