leerness 1.36.86 → 1.36.89

package/lib/bugfix.js

@@ -0,0 +1,335 @@
+// lib/bugfix.js — bugfix 완료 영수증 (1.36.87, P-0005 · codex+자체 이중검토 통과분만 구현).
+//
+// 문제(사용자 제기 + 실사용 프로젝트 실측): 버그 수정을 요청하면 증상만 고치고 "고쳤다"고 판정한다.
+//   읽기 전용으로 스캔한 실사용 저장소에서: 주문 상태 오판정이 플랫폼을 갈아가며 8회 반복,
+//   한 파일이 22회 수정, 그 프로젝트 lessons 11건은 전부 개별 API 특이사항이고 **클래스 교훈은 0건**.
+//
+// 검토에서 **기각된 것**(만들지 않는다):
+//   · 재오픈 ID 경고 — 실측 정밀도 19%(후속 커밋 37건 중 문서 14·확장 4·되돌림 1). 80% 오탐이라 차단 불가.
+//   · 파일 hotspot 경고 — 원래 자주 바뀌는 파일(라우팅·registry·lock)과 구분 불가. dirty worktree 에서
+//     "이번 버그가 손댈 파일"을 추론하면 즉시 오염된다.
+//   · 형제 분기 자동 제시 — **구문 분기 ≠ 도메인 형제**. 같은 파일 안에서도 플랫폼마다 수집 단위·조기반환이
+//     다르고, 공통 규칙은 분기 뒤에 다시 적용된다. 어떤 invariant 를 고치느냐에 따라 형제 범위가 달라지므로
+//     기계가 발명할 수 없다. 0-deps 로 TS 의미구조를 얻으려면 자체 파서가 필요하고 정규식은 과다/과소 포함된다.
+//
+// 채택한 유일한 개입: **`--status done` 전이**. leerness 는 이미 debug 렌즈와 review-request 로 올바른 절차를
+//   안내하지만 그건 조언 텍스트일 뿐 완료 시점에 소비되지 않는다. 조언을 더 만드는 것이야말로 증상 처방이다.
+//
+// 정직성 계약: 여기서 **기계적으로 검증되는 것은 probe 뿐**이다(수정 전 2회 연속 실패 → 수정 후 통과).
+//   근본원인·형제범위는 **선언**이며 leerness 는 그 내용의 진위를 판정하지 않는다. 출력에 그대로 표시한다.
+//
+// 신뢰 경계(명시): 스토어(.harness/bugfix-receipts.json)는 **프로젝트가 신뢰하는 설정 파일**이고,
+//   등록된 probe 명령은 done 전이에서 셸로 실행된다. 저장소에 쓰기 권한이 있는 주체는 이 게이트를
+//   우회할 수 있다 — 이 기능은 "성실한 작업자의 성급한 완료"를 막지, 적대적 우회를 막지 않는다.
+//   그래서 등록 시 실행 사실을 고지하고(⚠), 형상 무효 스토어는 완료를 보류한다.
+'use strict';
+const cp = require('child_process');
+const path = require('path');
+const { absRoot, exists, read, writeUtf8, mkdirp, log, ok, warn, failJson, now } = require('./io');
+
+function _storePath(root) { return path.join(absRoot(root), '.harness', 'bugfix-receipts.json'); }
+
+const _ID_RE = /^[A-Z]+-\d{3,}$/;
+
+// 1.36.87 (codex 26차 #5/#7): baseline 을 **필수**로 만든다. 종전엔 baseline 없는/실패하지 않은 엔트리가
+//   유효로 통과해, (1) 완료 렌더에서 TypeError 로 `task update` 가 통째로 죽고(실측),
+//   (2) 손으로 써 넣은 "재현된 적 없는" probe 가 게이트를 통과했다.
+//   등록 경로(_start)는 실패한 baseline 만 저장하므로, 그 형상을 스토어 계약으로 못 박는다.
+function _entryValid(e) {
+  if (!e || typeof e !== 'object' || Array.isArray(e)) return false;
+  if (typeof e.id !== 'string' || !_ID_RE.test(e.id)) return false;
+  if (typeof e.repro !== 'string' || !e.repro.trim()) return false;
+  if (typeof e.expectBad !== 'string' || !e.expectBad.trim()) return false;
+  const b = e.baseline;
+  if (!b || typeof b !== 'object' || Array.isArray(b)) return false;
+  if (b.failed !== true) return false;                       // 재현되지 않은 probe 는 등록될 수 없다
+  if (typeof b.exit !== 'number') return false;
+  if (e.siblingScope != null && (typeof e.siblingScope !== 'object' || Array.isArray(e.siblingScope))) return false;
+  if (e.siblingScope && e.siblingScope.checked != null && !Array.isArray(e.siblingScope.checked)) return false;
+  if (e.rootCause != null && typeof e.rootCause !== 'string') return false;
+  return true;
+}
+
+// 형제범위가 "기록됨"인지의 **단일 술어** — 목록·게이트가 갈라지면 사용자가 통과할 줄 알았다가 막힌다.
+//   빈 배열은 기록이 아니다(`--siblings ","` 가 checked:[] 를 만들던 공허 영수증).
+function _siblingScopeOk(sc) {
+  if (!sc || typeof sc !== 'object') return false;
+  if (Array.isArray(sc.checked) && sc.checked.length > 0) return true;
+  return typeof sc.notApplicable === 'string' && !!sc.notApplicable.trim();
+}
+
+// 손상/형상무효 스토어는 빈 목록으로 오인하지 않는다(referee/previews 와 동일 규율).
+function _loadChecked(root) {
+  const f = _storePath(root);
+  if (!exists(f)) return { list: [], invalid: false };
+  try {
+    const j = JSON.parse(read(f));
+    if (!Array.isArray(j) || j.some(e => !_entryValid(e))) return { list: [], invalid: true };
+    return { list: j, invalid: false };
+  } catch { return { list: [], invalid: true }; }
+}
+// 1.36.87 (codex 26차 #6): 종전엔 읽은 목록 전체를 그대로 덮어써서, 두 등록이 겹치면 나중 쓰기가
+//   앞의 등록을 지웠다 — 지워진 task 는 "미등록"이 되어 게이트가 **조용히 꺼진다**(fail-open).
+//   쓰기 직전 재로드 후 id 기준 병합하고, 임시파일 rename 으로 부분 기록도 막는다.
+//   락은 호출부에서 주입한다(rules/decisions/teams/referee 와 동일 규율) — 재로드+병합만으로는 부족했다:
+//   4개 동시 등록 실측에서 2건이 사라졌다.
+function _atomicWrite(f, list) {
+  mkdirp(path.dirname(f));
+  const tmp = f + '.tmp' + process.pid;
+  writeUtf8(tmp, JSON.stringify(list, null, 2) + '\n');
+  require('fs').renameSync(tmp, f);
+}
+function _locked(deps, f, fn) { return (deps && typeof deps._withLock === 'function') ? deps._withLock(f, fn) : fn(); }
+function _upsert(root, entry, deps) {
+  const f = _storePath(root);
+  return _locked(deps, f, () => {
+    const cur = _loadChecked(root);   // 락 안에서 재로드 — 밖에서 읽은 목록은 이미 낡았을 수 있다
+    const list = (cur.invalid ? [] : cur.list).filter(x => x.id !== entry.id).concat([entry]);
+    _atomicWrite(f, list);
+    return list;
+  });
+}
+function _remove(root, id, deps) {
+  const f = _storePath(root);
+  return _locked(deps, f, () => {
+    const cur = _loadChecked(root);
+    if (cur.invalid) return null;
+    const list = cur.list.filter(x => x.id !== String(id));
+    if (list.length === cur.list.length) return null;
+    _atomicWrite(f, list);
+    return list;
+  });
+}
+
+function _run(cmd, cwd) {
+  const t0 = Date.now();
+  const r = cp.spawnSync(cmd, { cwd, shell: true, encoding: 'utf8', timeout: 600000, maxBuffer: 8 * 1024 * 1024 });
+  const out = ((r.stdout || '') + '\n' + (r.stderr || '')).trim();
+  const code = r.error ? String(r.error.code || r.error.message) : null;
+  return {
+    status: (r.status == null ? (r.error ? -1 : 1) : r.status),
+    // 1.36.88 (출하전 헌트 #4/#10): ENOBUFS 는 "명령이 실행되지 못한 것"이 아니라 **출력이 한도를 넘어
+    //   잘린 것**이다. 종전엔 launcher 실패로 분류해, 수정을 마쳐 통과하는 probe 를 "실행 실패"라는
+    //   사실과 다른 사유로 차단했다. 판정 불가는 판정 불가라고 말해야 한다.
+    overflow: code === 'ENOBUFS',
+    spawnError: (code && code !== 'ENOBUFS') ? code : null,
+    timedOut: !!(r.error && String(r.error.code) === 'ETIMEDOUT'),
+    output: out,
+    sample: out.slice(0, 4000),
+    ms: Date.now() - t0,
+  };
+}
+
+// referee 와 같은 규율: 명령 자체가 실행되지 못한 것은 "버그 재현"이 아니다.
+//   **하드 신호만** 본다(spawn 실패 · 127 · 9009). 출력 문자열은 보지 않는다 — 아래 _toolErrorHint 참조.
+function _launcherFailure(r) {
+  if (!r) return null;
+  if (r.spawnError) return `실행 실패(${r.spawnError})`;
+  if (r.status === 127 || r.status === 9009) return `명령을 찾을 수 없음(exit ${r.status})`;
+  return null;
+}
+
+// 출력 문자열 기반 추정 — **등록 시점의 비차단 경고로만** 쓴다.
+//   1.36.87 실측: 종전에는 출력에 `SyntaxError:` 가 있으면 런처 오류로 단정했다. 그런데 수정을 끝내
+//   exit 0 인 probe 라도 앱이 그 문자열을 정상 출력하면(예: 11번가가 JSON 대신 HTML 을 주는 케이스의
+//   재현 로그) `probe_unrunnable` 로 **완료가 막혔다** — 이 기능을 만들게 한 바로 그 도메인에서의 오차단.
+//   게이트 휴리스틱은 false-PASS 로 기울여야지 false-BLOCK 으로 기울면 안 된다.
+function _toolErrorHint(r) {
+  if (!r || r.status === 0) return null;
+  if (/(?:command not found|not recognized as an internal or external command|cannot find module)/i.test(r.output || '')) {
+    return '출력이 도구/경로 오류처럼 보입니다 — 버그 재현이 아닐 수 있으니 probe 를 확인하세요';
+  }
+  return null;
+}
+
+// `leerness bugfix start <ID> --repro "<cmd>" --expect-bad "<신호>"`
+//   수정 **전에** 실행한다. 지금 실패해야 하고, 기대 신호가 출력에 있어야 한다.
+//   이 두 조건이 probe 의 탐지력이다 — 통과해버리는 probe 는 나중에 무엇도 증명하지 못한다.
+function _start(root, id, deps) {
+  const { arg, has } = deps;
+  const json = !!(has && has('--json'));
+  const repro = (arg ? arg('--repro', '') : '') || '';
+  const expectBad = (arg ? arg('--expect-bad', '') : '') || '';
+  if (!_ID_RE.test(String(id || ''))) { failJson(json, 'invalid_id', `task id 형식이 아님: ${JSON.stringify(id)} (예: T-0007)`); return; }
+  // 1.36.88 (출하전 헌트 #3/#19): 존재하지 않는 id 로도 등록에 성공해, 오타 하나면 "보호받는다고 믿는데
+  //   실제로는 아무것도 막지 않는" 상태가 됐다. 등록 시점에 tracker 에 있는지 확인한다.
+  if (typeof deps._taskExists === 'function' && !deps._taskExists(root, String(id))) {
+    failJson(json, 'task_not_found', `progress-tracker 에 없는 task: ${id} — 먼저 leerness task add "<제목>" (오타면 leerness task list 로 확인)`);
+    return;
+  }
+  if (!repro.trim()) { failJson(json, 'missing_repro', '--repro "<버그를 재현하는 명령>" 필요 — 지금 실패해야 합니다'); return; }
+  if (!expectBad.trim()) { failJson(json, 'missing_expect', '--expect-bad "<기대 실패 신호>" 필요 — 없으면 무관한 실패와 진짜 재현을 구분할 수 없습니다'); return; }
+
+  const chk = _loadChecked(root);
+  if (chk.invalid) { failJson(json, 'store_invalid', `bugfix-receipts.json 형상 무효 — 덮어쓰기 거부: ${_storePath(root)}`); return; }
+
+  const r = _run(repro, absRoot(root));
+  const lf = _launcherFailure(r);
+  const matched = r.output.includes(expectBad);
+  const reasons = [];
+  if (r.overflow) reasons.push('probe 출력이 한도(8MB)를 넘어 재현 여부를 판정할 수 없습니다 — 출력을 줄이거나 파일로 보내세요');
+  if (lf) reasons.push(`${lf} — 심어둔 버그가 아니라 명령이 실행되지 못했습니다`);
+  else if (r.status === 0) reasons.push('probe 가 지금 **통과**합니다(exit 0) — 버그가 재현되지 않으면 수정 후 통과는 아무것도 증명하지 못합니다');
+  if (!lf && !matched) reasons.push(`출력에 기대 신호 "${expectBad}" 없음 — 무관한 실패일 수 있습니다`);
+  // 1.36.87 (codex 26차 #3): **두 번** 돌려 둘 다 실패해야 한다. 한 번만 보면 상태를 남기는 probe —
+  //   예: `if(!exists(marker)){write(marker); exit 1}` — 가 등록 때만 실패하고 이후 항상 통과해,
+  //   제품 코드를 한 줄도 고치지 않고 완료 게이트를 통과시킨다(1회성 probe = 탐지력 0).
+  let r2 = null;
+  if (!reasons.length) {
+    r2 = _run(repro, absRoot(root));
+    if (_launcherFailure(r2) || r2.status === 0 || !r2.output.includes(expectBad)) {
+      reasons.push(`두 번째 실행에서 재현되지 않았습니다(exit ${r2.status}) — 상태를 남기는 1회성 probe 는 수정 여부와 무관하게 통과하므로 등록하지 않습니다`);
+    }
+  }
+
+  const entry = {
+    id: String(id), repro, expectBad,
+    baseline: { at: now(), failed: !lf && r.status !== 0, exit: r.status, expectMatched: matched, reproduced: 2, ms: r.ms, sample: reasons.length ? r.sample.slice(0, 400) : undefined },
+    rootCause: null, siblingScope: null, previousGuardGap: null,
+  };
+  if (reasons.length) {
+    if (json) { log(JSON.stringify({ ok: false, code: 'probe_not_reproducing', id: entry.id, reasons }, null, 2)); }
+    else { warn(`probe 가 버그를 재현하지 못했습니다 — 등록하지 않습니다`); reasons.forEach(x => log(`  - ${x}`)); }
+    if (typeof process !== 'undefined') process.exitCode = 1;
+    return;
+  }
+  const hint = _toolErrorHint(r);   // 비차단 — 등록은 진행하되 사용자에게 알린다
+  _upsert(root, entry, deps);
+  // 1.36.87 (codex 26차 #1): 게이트는 기본 OFF 다. 토글 상태를 보지 않고 "done 때 통과해야 합니다"라고
+  //   쓰면, 실제로는 아무것도 강제되지 않는데 강제된다고 **약속하는 문구**가 된다.
+  const gateOn = require('./toggles').toggleOn(root, 'bugfix-receipt');
+  if (json) { log(JSON.stringify({ ok: true, id: entry.id, baseline: entry.baseline, gateEnabled: gateOn, hint: hint || undefined }, null, 2)); return; }
+  ok(`bugfix probe 등록: ${entry.id} — 지금 재현됨(2회 연속 exit ${r.status} · 신호 일치)`);
+  if (hint) warn(`  ${hint}`);
+  log(`  ⚠ 이 명령은 앞으로 \`--status done\` 시 자동 실행됩니다 — 저장 위치: ${_storePath(root)}`);
+  if (gateOn) log(`  → 수정 후 \`leerness task update ${entry.id} --status done\` 시 같은 probe 가 통과해야 합니다.`);
+  else warn(`  이 프로젝트에서 완료 게이트는 **꺼져 있습니다** — 지금은 기록만 되고 done 은 막히지 않습니다.\n     켜기: leerness toggle set bugfix-receipt on`);
+  log(`  → 근본원인/형제범위 기록: leerness bugfix receipt ${entry.id} --root-cause "..." --siblings "..."`);
+}
+
+// `leerness bugfix receipt <ID> --root-cause "..." [--siblings "..." | --siblings-na "사유"] [--previous-gap "..."]`
+//   **선언**이다. leerness 는 내용의 진위를 판정하지 않는다 — 존재와 문구만 기록한다.
+function _receipt(root, id, deps) {
+  const { arg, has } = deps;
+  const json = !!(has && has('--json'));
+  const chk = _loadChecked(root);
+  if (chk.invalid) { failJson(json, 'store_invalid', `bugfix-receipts.json 형상 무효 — 덮어쓰기 거부: ${_storePath(root)}`); return; }
+  const e = chk.list.find(x => x.id === String(id));
+  if (!e) { failJson(json, 'probe_not_found', `bugfix probe 없음: ${id} — 먼저 leerness bugfix start ${id} --repro "..." --expect-bad "..."`); return; }
+  const rc = (arg ? arg('--root-cause', '') : '') || '';
+  const sib = (arg ? arg('--siblings', '') : '') || '';
+  const sibNa = (arg ? arg('--siblings-na', '') : '') || '';
+  const gap = (arg ? arg('--previous-gap', '') : '') || '';
+  if (rc.trim()) e.rootCause = rc.trim();
+  // 1.36.87 실측: `--siblings ","` 는 checked=[] 를 만들면서 "형제범위 기록됨"으로 통과했다(공허 영수증).
+  //   빈 목록은 기록이 아니다 — 거부한다.
+  const parsed = sib.trim() ? sib.split(',').map(s => s.trim()).filter(Boolean) : [];
+  if (sib.trim() && !parsed.length) { failJson(json, 'empty_siblings', `--siblings 값에 항목이 없습니다: ${JSON.stringify(sib)} — 쉼표로 구분된 형제 지점을 적거나, 없으면 --siblings-na "<사유>"`); return; }
+  if (parsed.length) e.siblingScope = { checked: parsed };
+  else if (sibNa.trim()) e.siblingScope = { notApplicable: sibNa.trim() };
+  if (gap.trim()) e.previousGuardGap = gap.trim();
+  _upsert(root, e, deps);
+  if (json) { log(JSON.stringify({ ok: true, id: e.id, rootCause: e.rootCause, siblingScope: e.siblingScope, previousGuardGap: e.previousGuardGap }, null, 2)); return; }
+  ok(`bugfix 영수증 갱신: ${e.id}`);
+  log(`  ⓘ 근본원인·형제범위는 **선언**입니다 — leerness 는 내용의 진위를 판정하지 않습니다(검증되는 것은 probe 뿐).`);
+}
+
+// `--status done` 전이에서 호출. 토글 OFF 이거나 probe 미등록이면 **아무 영향 없음**(기존 동작 보존).
+//   반환: { blocked, code, message, lines } — 호출부가 렌더/exit 를 결정한다.
+function checkDoneTransition(root, id) {
+  const chk = _loadChecked(root);
+  if (chk.invalid) {
+    return { blocked: true, code: 'store_invalid', message: `bugfix-receipts.json 형상 무효 — 완료 판정을 보류합니다: ${_storePath(root)}` };
+  }
+  const e = chk.list.find(x => x.id === String(id));
+  if (!e) return { blocked: false };   // bugfix 로 선언되지 않은 task 는 무영향
+  const r = _run(e.repro, absRoot(root));
+  const lf = _launcherFailure(r);
+  const lines = [];
+  if (lf) return { blocked: true, code: 'probe_unrunnable', message: `재현 probe 를 실행할 수 없습니다 — ${lf}: ${e.repro}` };
+  // 출력 초과는 실행 실패가 아니다 — 통과/실패를 **알 수 없는** 상태이므로 그대로 말하고 보류한다(사실과 다른 사유 금지).
+  if (r.overflow) {
+    return {
+      blocked: true, code: 'probe_output_too_large',
+      message: `probe 출력이 한도(8MB)를 넘어 통과 여부를 판정할 수 없습니다 — 출력을 줄이거나 파일로 보내세요(예: > out.log): ${e.repro}`,
+    };
+  }
+  if (r.status !== 0) {
+    return {
+      blocked: true, code: 'probe_still_failing',
+      message: `재현 probe 가 아직 실패합니다(exit ${r.status}) — 버그가 남아 있거나 probe 자체가 깨졌습니다(아래 출력 확인): ${e.repro}`,
+      lines: [r.sample.split('\n').slice(0, 6).join('\n')],
+    };
+  }
+  const missing = [];
+  if (!e.rootCause) missing.push('--root-cause');
+  if (!_siblingScopeOk(e.siblingScope)) missing.push('--siblings 또는 --siblings-na');
+  if (missing.length) {
+    return {
+      blocked: true, code: 'receipt_incomplete',
+      message: `영수증 미완: ${missing.join(' · ')} — leerness bugfix receipt ${e.id} ${missing.map(m => m.split(' ')[0] + ' "..."').join(' ')}`,
+    };
+  }
+  // baseline 은 _entryValid 가 요구하지만, 렌더는 방어적으로 — 종전엔 여기서 TypeError 로 task update 가 통째로 죽었다(실측).
+  const wasExit = (e.baseline && e.baseline.exit != null) ? `수정 전 exit ${e.baseline.exit} → ` : '';
+  lines.push(`✓ 재현 probe 통과(${wasExit}지금 exit 0): ${e.repro}`);
+  // 1.36.87 (codex 26차 #2): exit 0 인데 등록 당시의 실패 신호가 출력에 그대로 있으면 "증상만 덮은" 신호다.
+  //   다만 **막지는 않는다** — 신호가 성공 메시지에 정상 등장할 수 있고, 여기서 잘못 막으면 이미 고쳐진
+  //   probe 를 재등록할 방법이 없어(등록은 실패를 요구) 사용자가 빠져나올 수 없다. 경고로 노출한다.
+  if (e.expectBad && r.output.includes(e.expectBad)) {
+    lines.push(`⚠ exit 는 0 이지만 등록 당시 실패 신호 "${e.expectBad}" 가 출력에 아직 있습니다 — probe 가 정말 그 버그를 보고 있는지 확인하세요.`);
+  }
+  lines.push(`ⓘ 아래는 **선언**이며 내용의 진위는 검증하지 않았습니다:`);
+  lines.push(`   근본원인: ${e.rootCause}`);
+  lines.push(`   형제범위: ${e.siblingScope.notApplicable ? 'not-applicable — ' + e.siblingScope.notApplicable : (e.siblingScope.checked || []).join(', ')}`);
+  if (e.previousGuardGap) lines.push(`   이전 검증이 놓친 이유: ${e.previousGuardGap}`);
+  return { blocked: false, lines };
+}
+
+// 1.36.88 (출하전 헌트 #1/#17): 게이트를 호출부마다 배선하면 반드시 빠뜨린다 — 실측으로
+//   `task sync --from`(TodoWrite 왕복, 하네스가 직접 지시하는 정규 경로)이 게이트를 통째로 우회했다.
+//   그래서 판정은 progress 행을 쓰는 **단일 병목**에서 하고, 막힐 때는 조용히 무시할 수 없도록 던진다.
+//   (반환값 무시로 인한 무언 통과가 이 클래스의 재발 양식이다.)
+class BugfixBlocked extends Error {
+  constructor(res, id) {
+    super((res && res.message) || 'bugfix 완료 게이트에 의해 보류');
+    this.name = 'BugfixBlocked';
+    this.taskId = String(id);
+    this.code = (res && res.code) || 'blocked';
+    this.lines = (res && res.lines) || [];
+  }
+}
+
+function bugfixCmd(root, sub, rest, deps = {}) {
+  const { has } = deps;
+  root = absRoot(root);
+  const json = !!(has && has('--json'));
+  if (!exists(path.join(root, '.harness'))) { failJson(json, 'harness_missing', `leerness 미설치: ${root} — 먼저 leerness init`); return; }
+  const id = (rest || [])[0];
+  if (sub === 'start') return _start(root, id, deps);
+  if (sub === 'receipt') return _receipt(root, id, deps);
+  // 1.36.87 (codex 26차 #9): 등록을 되돌릴 길이 필요하다 — probe 스크립트가 사라졌거나 계약이 바뀌면
+  //   done 이 영구히 막히고(등록은 "지금 실패"를 요구하므로 재등록도 불가) 스토어도 무한히 자란다.
+  if (sub === 'drop') {
+    const chk = _loadChecked(root);
+    if (chk.invalid) { failJson(json, 'store_invalid', `bugfix-receipts.json 형상 무효 — 수정 거부: ${_storePath(root)}`); return; }
+    const left = _remove(root, id, deps);
+    if (left === null) { failJson(json, 'probe_not_found', `bugfix probe 없음: ${id}`); return; }
+    if (json) { log(JSON.stringify({ ok: true, id: String(id), remaining: left.length }, null, 2)); return; }
+    ok(`bugfix probe 삭제: ${id} (남은 ${left.length}건) — 이 task 는 다시 완료 게이트 무영향이 됩니다`);
+    return;
+  }
+  if (sub === 'list' || !sub) {
+    const chk = _loadChecked(root);
+    if (json) { log(JSON.stringify({ ok: !chk.invalid, invalid: chk.invalid, receipts: chk.list.map(e => ({ id: e.id, repro: e.repro, baselineFailed: !!(e.baseline && e.baseline.failed), rootCause: e.rootCause, siblingScope: e.siblingScope })) }, null, 2)); return; }
+    if (chk.invalid) { warn(`bugfix-receipts.json 형상 무효: ${_storePath(root)}`); return; }
+    if (!chk.list.length) { log('등록된 bugfix probe 없음 — leerness bugfix start <T-ID> --repro "..." --expect-bad "..."'); return; }
+    // 1.36.88 (출하전 헌트 #12): 목록과 게이트가 **같은 술어**를 써야 한다 — 빈 checked 를 목록은 "기록됨",
+    //   게이트는 "영수증 미완"으로 판정해, 사용자가 목록을 보고 통과할 줄 알았다가 막혔다.
+    chk.list.forEach(e => log(`  ${e.id}  probe=${e.repro.slice(0, 50)}  근본원인=${e.rootCause ? '기록됨' : '미기록'}  형제범위=${_siblingScopeOk(e.siblingScope) ? '기록됨' : '미기록'}`));
+    return;
+  }
+  failJson(json, 'unknown_subcommand', `알 수 없는 bugfix 하위명령: ${sub} (가능: start, receipt, drop, list)`);
+}
+
+module.exports = { bugfixCmd, checkDoneTransition, BugfixBlocked, _storePath, _loadChecked };

package/lib/routing.js

@@ -0,0 +1,279 @@
+// lib/routing.js — 작업 난이도별 모델 라우팅 (1.36.89, P-0007 · 사용자 승인 범위 = **제안 + 확인 후 실행**).
+//
+// 사용자 요청: "codex/claude 등의 CLI 설치·사용 가능 여부에 따라 작업 난이도별 AI 모델을 라우팅, 켜고 끌 수 있게".
+//
+// 검토(codex 27차 + 자체)에서 **기각/제한한 것**:
+//   · 자유 텍스트로부터의 **조용한 자동 라우팅** — 잘못된 등급이 조용히 선택되면 사용자는 알 수 없고,
+//     비싼 등급이 선택되면 과금이 발생한다. 그래서 기본은 제안이고, 실행은 명시 확인(--dispatch)이 필요하다.
+//   · **모델 이름 하드코딩** — 벤더 모델은 몇 달마다 바뀐다. 정책은 추상 역할(architect/commander/coder/reviewer)로만
+//     쓰고, 역할→provider+model 매핑은 사용자 설정(`leerness roles set`)에 맡긴다.
+//   · **"설치됨 = 사용 가능"** — `--version` 이 도는 것은 인증·모델 사용권한·쿼터·비대화형 동작·과금 권한을
+//     아무것도 증명하지 않는다. 그래서 상태를 그대로 라벨링하고, 검증하지 않은 것은 검증하지 않았다고 적는다.
+//   · **변경 파일 수 기준 라우팅** — 일이 끝나야 알 수 있는 값이라 초기 라우팅 근거가 될 수 없다.
+//
+// 정직성 계약: 여기서 판정하는 것은 **텍스트에 대한 결정적 규칙 매칭**뿐이다. 난이도를 "측정"하지 않는다.
+//   규칙이 겹치거나(오타 수정인데 인증 도메인) 신호가 약하면 그 사실을 그대로 노출하고 보수적으로 normal 이상을 준다.
+'use strict';
+const path = require('path');
+const { absRoot, exists, read, writeUtf8, mkdirp, log, ok, warn, failJson, now } = require('./io');
+
+const TIERS = ['tiny', 'normal', 'high-risk'];
+
+// 고위험 도메인 — 결정적 규칙. 여기 걸리면 tiny 로 내려가지 않는다(과대평가는 비용, 과소평가는 사고).
+//   한글은 단어경계(\b)가 동작하지 않으므로 부분일치를 쓰고, 영문만 경계를 건다.
+//   1.36.89 (codex 28차 #5): 종전엔 `\b(auth|permission|concurren|idempoten)\b` 처럼 **뒤쪽 \b** 를 붙여
+//   `authentication` · `authorization` · `permissions` · `concurrency` · `idempotency` 가 전부 매치되지 않았다.
+//   그 결과 "fix typo in authentication middleware" 가 **tiny** 로 떨어졌다(실측). 어간 + `\w*` 로 바꾼다.
+//   오탐 가드: `author`(글쓴이)는 매치되면 안 되므로 authentic/authoriz 어간을 따로 적고,
+//   `tokenizer`(파서 용어)를 피하려 token 뒤 `iz` 를 제외한다.
+const HIGH_RISK = [
+  { id: 'auth', ko: '인증·인가', re: /\b(auth|authn|authz|authentic\w*|authoriz\w*|authoris\w*|login|log in|logout|sign in|session\w*|token(?!iz)\w*|jwt|oauth|sso|permission\w*|privilege\w*|rbac|acl)\b|인증|인가|로그인|세션|토큰|권한/i },
+  { id: 'payment', ko: '결제·정산', re: /\b(payment\w*|billing|checkout|invoice\w*|refund\w*|subscription\w*|stripe|paypal)\b|결제|정산|환불|청구|구독/i },
+  { id: 'data-migration', ko: '데이터 마이그레이션·스키마', re: /\b(migrat\w*|schema\w*|alter table|drop table|backfill\w*)\b|마이그레이션|스키마|백필/i },
+  { id: 'pii', ko: '개인정보', re: /\b(pii|gdpr|personal data|ssn|passport)\b|개인정보|주민등록|여권/i },
+  { id: 'secrets', ko: '시크릿·키', re: /\b(secret\w*|credential\w*|api key|private key|password\w*)\b|시크릿|비밀번호|자격증명|비밀키/i },
+  { id: 'public-api', ko: '공개 API 계약', re: /\b(public api|breaking change\w*|api contract|versioning)\b|공개 api|하위호환|호환성 깨/i },
+  { id: 'concurrency', ko: '동시성·트랜잭션', re: /\b(concurren\w*|transaction\w*|race condition\w*|deadlock\w*|idempoten\w*|mutex|semaphore)\b|동시성|트랜잭션|경쟁 상태|교착|멱등/i },
+  { id: 'infra', ko: '인프라·배포', re: /\b(deploy\w*|infra\w*|terraform|kubernetes|k8s|dockerfile|ci\/cd|pipeline\w*)\b|배포|인프라|파이프라인/i },
+  { id: 'destructive', ko: '파괴적 작업', re: /\b(delete all|truncate\w*|rm -rf|purge\w*|wipe\w*)\b|전체 삭제|일괄 삭제|초기화/i },
+];
+
+// 초소형 — **범위가 명시적으로 좁을 때만**. 고위험 신호가 하나라도 있으면 적용하지 않는다.
+const TINY = [
+  { id: 'typo', ko: '오타·문구', re: /\b(typo\w*|wording|copy fix)\b|오타|문구 수정|띄어쓰기/i },
+  { id: 'rename', ko: '이름 변경', re: /\b(rename|변수명|함수명)\b|이름 변경|네이밍/i },
+  { id: 'style', ko: '포맷·린트·CSS', re: /\b(lint\w*|format\w*|prettier|eslint|css|padding|margin|색상)\b|포맷|린트|여백|스타일/i },
+  { id: 'comment', ko: '주석·문서 문구', re: /\b(comment\w*|docstring\w*)\b|주석/i },
+  { id: 'single-test', ko: '테스트 1건', re: /\b(add a test|one test|테스트 한|테스트 1)\b/i },
+];
+
+// 1.36.89 (codex 28차 #4): 초소형 키워드가 **하나라도** 있으면 tiny 로 떨어지던 것 —
+//   "Rewrite the entire compiler, replace the storage engine, and also fix one typo" 가 tiny 였다(실측).
+//   tiny 는 "범위가 좁다"는 주장이므로, 광범위 신호가 있거나 설명이 길면 그 주장을 인정하지 않는다.
+const BROAD = /\b(entire|whole|all |everything|rewrite|overhaul|refactor all|across the|end.to.end)\b|전체|전면|모든|갈아엎|재작성|통째/i;
+const TINY_MAX_LEN = 80;
+
+function _norm(s) { return String(s == null ? '' : s).trim(); }
+
+// 사용자에게 반복 노출되는 고지 — **이 모듈이 실제로 한 일만** 말한다.
+//   1.36.89 (codex 28차 #7): 종전 문구는 "설치·활성 여부만 확인했습니다"였는데, 이 모듈은 역할 매핑만 읽고
+//   설치 확인(`--version`)을 **한 번도 하지 않는다**. 하지 않은 확인을 했다고 말하는 것이 바로 이 제품이 잡는 결함이다.
+const _AVAIL_NOTE = '이 명령은 역할 매핑(leerness roles)만 읽습니다 — 해당 CLI 의 설치·인증·모델 사용권한·쿼터·과금 권한은 확인하지 않았습니다(확인: leerness agents check).';
+const _CLASS_NOTE = '난이도는 텍스트 규칙 매칭 결과이며 측정값이 아닙니다.';
+const _EXEC_NOTE = 'leerness 는 여기서 외부 CLI 를 실행하지 않습니다 — 계획을 확정하고 기록할 뿐입니다.';
+
+// 난이도 판정 — 순서가 곧 정책이다. (1) 사용자 명시 (2) 고위험 도메인 (3) 초소형 (4) 기본 normal
+function classify(text, opts = {}) {
+  const t = _norm(text);
+  const declared = _norm(opts.tier).toLowerCase();
+  const high = HIGH_RISK.filter(r => r.re.test(t));
+  const tiny = TINY.filter(r => r.re.test(t));
+  const signals = [
+    ...high.map(r => ({ kind: 'high-risk', id: r.id, ko: r.ko })),
+    ...tiny.map(r => ({ kind: 'tiny', id: r.id, ko: r.ko })),
+  ];
+  const reasons = [];
+
+  // 1.36.89 (codex 28차 #3): 빈 작업 검사가 declared 분기 **뒤에** 있어, `--tier tiny` 만 주면
+  //   빈 작업이 통과했다(실측). 어떤 경로로도 빈 작업은 받지 않는다.
+  if (!t) return { ok: false, code: 'empty_task', error: '작업 설명이 비어 있습니다 — leerness agents route "<작업 설명>"' };
+
+  if (declared) {
+    if (!TIERS.includes(declared)) return { ok: false, code: 'invalid_tier', error: `--tier 는 ${TIERS.join('|')} (받음: ${declared})` };
+    reasons.push(`사용자가 --tier ${declared} 로 명시 — 규칙 판정보다 우선합니다`);
+    if (declared !== 'high-risk' && high.length) {
+      reasons.push(`⚠ 고위험 신호(${high.map(r => r.ko).join(', ')})가 있는데 ${declared} 로 지정됐습니다 — 의도한 것인지 확인하세요`);
+    }
+    return { ok: true, tier: declared, confidence: 'declared', signals, reasons, conflict: declared !== 'high-risk' && high.length > 0 };
+  }
+
+  if (high.length) {
+    // 고위험 + 초소형 신호 동시 매칭(예: "인증 문서 오타 수정")은 규칙만으로 못 가른다 — 사실을 노출하고 보수적으로 간다.
+    const conflict = tiny.length > 0;
+    reasons.push(`고위험 도메인 규칙 매칭: ${high.map(r => r.ko).join(', ')}`);
+    if (conflict) reasons.push(`동시에 초소형 신호(${tiny.map(r => r.ko).join(', ')})도 있습니다 — 규칙으로는 가릴 수 없어 보수적으로 high-risk 로 둡니다. 사소한 작업이면 --tier tiny 로 낮추세요`);
+    return { ok: true, tier: 'high-risk', confidence: conflict ? 'low' : 'high', signals, reasons, conflict };
+  }
+
+  // 신호가 없고 설명이 짧으면 판정 근거가 없는 것이다 — tiny 로 내리지 않고 normal 로 둔다(과소평가 금지).
+  if (!tiny.length) {
+    const weak = t.length < 12;
+    reasons.push(weak
+      ? '매칭된 규칙이 없고 설명이 짧습니다 — 판정 근거가 부족해 기본값 normal 로 둡니다'
+      : '매칭된 고위험/초소형 규칙 없음 — 기본값 normal');
+    return { ok: true, tier: 'normal', confidence: weak ? 'low' : 'medium', signals, reasons, conflict: false };
+  }
+
+  // tiny 는 "범위가 좁다"는 주장이다 — 광범위 신호가 있거나 설명이 길면 그 주장을 인정하지 않는다.
+  const broad = BROAD.test(t);
+  const longText = t.length > TINY_MAX_LEN;
+  if (broad || longText) {
+    reasons.push(`초소형 신호(${tiny.map(r => r.ko).join(', ')})가 있지만 ${broad ? '광범위 신호가 함께 있어' : `설명이 ${t.length}자로 길어(기준 ${TINY_MAX_LEN}자)`} 좁은 범위로 볼 수 없습니다 — normal 로 둡니다`);
+    return { ok: true, tier: 'normal', confidence: 'low', signals, reasons, conflict: true };
+  }
+  reasons.push(`초소형 신호 매칭: ${tiny.map(r => r.ko).join(', ')} · 고위험/광범위 신호 없음`);
+  return { ok: true, tier: 'tiny', confidence: 'medium', signals, reasons, conflict: false };
+}
+
+// 등급별 역할 구성 — **추상 역할 id 만** 쓴다(모델 이름 없음). 매핑은 `leerness roles set` 이 소유한다.
+const TIER_ROLES = {
+  tiny: { roles: ['coder'], humanApproval: false, ko: '작업자 1명 + 기존 테스트' },
+  normal: { roles: ['commander', 'coder', 'reviewer'], humanApproval: false, ko: '지휘·구현·검수' },
+  'high-risk': { roles: ['architect', 'commander', 'coder', 'reviewer'], humanApproval: true, ko: '설계 선행 · 독립 검수 · 사람 승인' },
+};
+
+// 라우팅 계획 — 역할을 사용자 설정으로 해석하고, 해석 못 한 역할과 독립성 결함을 그대로 보고한다.
+function plan(root, cls, deps = {}) {
+  // 알 수 없는 등급은 여기서 크래시할 게 아니라 가장 보수적인 구성으로 떨어뜨린다 —
+  //   상류 검증이 사라져도 "조용히 느슨해지는" 대신 가장 엄격한 쪽으로 실패하게(fail-closed).
+  const spec = TIER_ROLES[cls.tier] || TIER_ROLES['high-risk'];
+  const resolve = typeof deps._resolveRole === 'function' ? deps._resolveRole : () => null;
+  // 1.36.89 (codex 28차 #6): 종전엔 `resolved: !!r` 라 provider 가 빈 문자열이어도 "해석됨"이었다 —
+  //   빈 provider 로 dispatch 가 통과하고 `coder:` 로 표시됐다(실측). 실제로 쓸 수 있는 값인지까지 본다.
+  const assignments = spec.roles.map(role => {
+    const r = resolve(root, role);
+    const provider = r && typeof r.provider === 'string' ? r.provider.trim() : '';
+    return { role, provider: provider || null, model: (r && r.model) || null, resolved: !!provider };
+  });
+  const unresolved = assignments.filter(a => !a.resolved).map(a => a.role);
+  const coder = assignments.find(a => a.role === 'coder');
+  const reviewer = assignments.find(a => a.role === 'reviewer');
+  // 독립 검수: 같은 provider 가 구현과 검수를 겸하면 "검수됨"이라고 말할 수 없다(같은 맹점을 공유한다).
+  const reviewerIndependent = !reviewer || !reviewer.resolved || !coder || !coder.resolved
+    ? null
+    : reviewer.provider !== coder.provider;
+  const blockers = [];
+  if (unresolved.length) blockers.push({ code: 'role_unresolved', message: `역할 미설정: ${unresolved.join(', ')} — leerness roles set <역할> --provider <id>` });
+  if (spec.humanApproval && reviewerIndependent === false) blockers.push({ code: 'reviewer_not_independent', message: `검수자와 구현자가 같은 provider(${coder.provider})입니다 — 고위험 작업에서는 독립 검수라고 볼 수 없습니다` });
+  return { tier: cls.tier, ko: spec.ko, humanApproval: spec.humanApproval, assignments, unresolved, reviewerIndependent, blockers };
+}
+
+function _logPath(root) { return path.join(absRoot(root), '.harness', 'routing-log.json'); }
+const _LOG_CAP = 200;
+
+const _LOG_MAX_BYTES = 4 * 1024 * 1024;   // codex 28차 #9: 파싱 전에 크기를 본다 — 거대 파일을 동기로 읽어 CLI 가 멎으면 안 된다
+
+function _loadLog(root) {
+  const f = _logPath(root);
+  if (!exists(f)) return { list: [], invalid: false };
+  try {
+    const sz = require('fs').statSync(f).size;
+    if (sz > _LOG_MAX_BYTES) return { list: [], invalid: true, reason: `파일이 너무 큽니다(${Math.round(sz / 1048576)}MB > 4MB)` };
+    const j = JSON.parse(read(f));
+    if (!Array.isArray(j)) return { list: [], invalid: true, reason: '최상위가 배열이 아닙니다' };
+    return { list: j, invalid: false };
+  } catch (e) { return { list: [], invalid: true, reason: 'JSON 파싱 실패' }; }
+}
+
+// 감사 기록 — 무엇을 보고 무엇을 골랐는지 남지 않으면 사후에 라우팅을 검증할 수 없다.
+//   1.36.89 (codex 28차 #8): 손상 파일을 `[rec]` 으로 **조용히 덮어썼다**(실측) — 감사 기록을 파괴하는
+//   동작이 감사 기록 기능 안에 있었다. 손상 시에는 쓰지 않고 그 사실을 반환한다(스토어 손상 = 덮어쓰기 거부, 기존 규율).
+function _appendLog(root, rec, deps = {}) {
+  const f = _logPath(root);
+  const write = () => {
+    const cur = _loadLog(root);
+    if (cur.invalid) return { written: false, invalid: true, reason: cur.reason || '형상 무효' };
+    const list = cur.list.concat([rec]).slice(-_LOG_CAP);
+    mkdirp(path.dirname(f));
+    const tmp = f + '.tmp' + process.pid;
+    writeUtf8(tmp, JSON.stringify(list, null, 2) + '\n');
+    require('fs').renameSync(tmp, f);
+    return { written: true, invalid: false, total: list.length };
+  };
+  return (typeof deps._withLock === 'function') ? deps._withLock(f, write) : write();
+}
+
+// `leerness agents route "<작업>" [--tier x] [--dispatch] [--approved-by "이름"] [--json]`
+function routeCmd(root, taskText, deps = {}) {
+  const { has, arg } = deps;
+  root = absRoot(root);
+  const json = !!(has && has('--json'));
+  if (!exists(path.join(root, '.harness'))) { failJson(json, 'harness_missing', `leerness 미설치: ${root} — 먼저 leerness init`); return; }
+
+  if (has && has('--log')) return _showLog(root, json);
+
+  const cls = classify(taskText, { tier: (arg ? arg('--tier', '') : '') || '' });
+  if (!cls.ok) { failJson(json, cls.code, cls.error); return; }
+  const p = plan(root, cls, deps);
+
+  const wantDispatch = !!(has && (has('--confirm') || has('--dispatch')));
+  const approvedBy = _norm(arg ? arg('--approved-by', '') : '');
+  const gateOn = typeof deps._toggleOn === 'function' ? deps._toggleOn(root, 'difficulty-routing') : false;
+
+  // 실행 거부 사유 — 하나라도 있으면 dispatch 하지 않는다(고위험은 fail-closed).
+  const refusals = [];
+  if (wantDispatch && !gateOn) refusals.push({ code: 'routing_disabled', message: '난이도 라우팅 토글이 꺼져 있습니다 — leerness toggle set difficulty-routing on' });
+  if (wantDispatch && p.blockers.length) p.blockers.forEach(b => refusals.push(b));
+  if (wantDispatch && p.humanApproval && !approvedBy) refusals.push({ code: 'human_approval_required', message: '고위험 작업은 사람 승인이 필요합니다 — --approved-by "<승인자>"' });
+
+  // 1.36.89 (codex 28차 #1): 종전 필드명은 `dispatched` 였는데 이 모듈은 **외부 CLI 를 실행하지 않는다** —
+  //   실행했다고 보고하면서 아무것도 실행하지 않는, 이 제품이 가장 경계하는 형태의 거짓말이었다(실측).
+  //   실제로 하는 일은 "계획을 확정하고 실행 명령을 내주는 것"이므로 그대로 `confirmed` 라고 부른다.
+  const confirmed = wantDispatch && !refusals.length;
+  const rec = {
+    at: now(),
+    task: _norm(taskText).slice(0, 300),
+    tier: cls.tier, confidence: cls.confidence, conflict: !!cls.conflict,
+    signals: cls.signals.map(s => `${s.kind}:${s.id}`),
+    assignments: p.assignments.map(a => ({ role: a.role, provider: a.provider, model: a.model })),
+    reviewerIndependent: p.reviewerIndependent,
+    requested: wantDispatch ? 'confirm' : 'suggest',
+    confirmed, executed: false, approvedBy: approvedBy || null,
+    refusals: refusals.map(r => r.code),
+  };
+  const logged = _appendLog(root, rec, deps) || {};
+
+  if (json) {
+    log(JSON.stringify({
+      ok: !wantDispatch || confirmed, tier: cls.tier, confidence: cls.confidence, conflict: !!cls.conflict,
+      signals: cls.signals, reasons: cls.reasons, plan: p, gateEnabled: gateOn,
+      confirmed, executed: false, refusals,
+      auditWritten: logged.written !== false, auditWarning: logged.invalid ? `감사 기록에 남기지 못했습니다(${logged.reason}) — ${_logPath(root)}` : undefined,
+      availabilityNote: _AVAIL_NOTE,
+      classificationNote: _CLASS_NOTE,
+      executionNote: _EXEC_NOTE,
+    }, null, 2));
+    if (wantDispatch && !confirmed) process.exitCode = 1;
+    return { cls, plan: p, confirmed };
+  }
+
+  log(`# leerness agents route — 난이도 ${cls.tier} (신뢰도 ${cls.confidence}${cls.conflict ? ' · 규칙 충돌' : ''})`);
+  cls.reasons.forEach(r => log(`  · ${r}`));
+  log(`\n  구성(${p.ko}):`);
+  p.assignments.forEach(a => log(`    ${a.role.padEnd(10)} ${a.resolved ? `${a.provider}${a.model ? ' / ' + a.model : ''}` : '⚠ 미설정 — leerness roles set ' + a.role + ' --provider <id>'}`));
+  if (p.reviewerIndependent === false) log(`    ⚠ 검수자와 구현자가 같은 provider — 독립 검수가 아닙니다`);
+  log(`\n  ⓘ ${_AVAIL_NOTE}`);
+  log(`  ⓘ ${_CLASS_NOTE} 틀렸다면 --tier ${TIERS.join('|')} 로 지정하세요.`);
+  if (logged.invalid) warn(`  감사 기록에 남기지 못했습니다(${logged.reason}) — ${_logPath(root)} 를 고치거나 삭제하세요`);
+  if (!wantDispatch) {
+    log(`\n  → 이 구성을 확정: leerness agents route "<작업>" --confirm${p.humanApproval ? ' --approved-by "<승인자>"' : ''}${gateOn ? '' : '  (먼저 leerness toggle set difficulty-routing on)'}`);
+  } else if (!confirmed) {
+    warn(`확정하지 않았습니다:`);
+    refusals.forEach(r => log(`    - ${r.message}`));
+    process.exitCode = 1;
+  } else {
+    ok(`라우팅 확정 — ${p.assignments.filter(a => a.resolved).map(a => `${a.role}:${a.provider}`).join(' · ')}`);
+    log(`  ⓘ ${_EXEC_NOTE}`);
+    log(`  아래 명령을 직접 실행하세요:`);
+    p.assignments.filter(a => a.resolved).forEach(a => log(`    leerness agents dispatch "<${a.role} 작업 계약>" --role ${a.role}`));
+    log(`  ⓘ 기록: ${_logPath(root)} (leerness agents route --log 로 열람)`);
+  }
+  return { cls, plan: p, confirmed };
+}
+
+function _showLog(root, json) {
+  const cur = _loadLog(root);
+  // codex 28차 #7: 고지가 --log 경로에는 없어서, 기록만 보는 사용자는 "provider/model 이 검증된 값"으로 읽었다.
+  if (json) { log(JSON.stringify({ ok: !cur.invalid, invalid: cur.invalid, reason: cur.reason, total: cur.list.length, entries: cur.list.slice(-20), availabilityNote: _AVAIL_NOTE, executionNote: _EXEC_NOTE }, null, 2)); if (cur.invalid) process.exitCode = 1; return; }
+  if (cur.invalid) { warn(`routing-log.json 형상 무효(${cur.reason}): ${_logPath(root)}`); process.exitCode = 1; return; }
+  if (!cur.list.length) { log('라우팅 기록 없음 — leerness agents route "<작업 설명>"'); return; }
+  log(`# leerness agents route --log (최근 ${Math.min(20, cur.list.length)} / 총 ${cur.list.length})`);
+  cur.list.slice(-20).forEach(e => {
+    const state = e.executed ? '실행' : e.confirmed ? '확정' : (e.requested === 'confirm' || e.requested === 'dispatch') ? '거부' : '제안';
+    log(`  ${String(e.at).slice(0, 16)}  ${String(e.tier).padEnd(9)} ${String(e.confidence).padEnd(8)} ${state}  ${String(e.task).slice(0, 46)}`);
+  });
+  log(`\n  ⓘ ${_AVAIL_NOTE}`);
+  log(`  ⓘ ${_EXEC_NOTE}`);
+}
+
+module.exports = { routeCmd, classify, plan, TIERS, TIER_ROLES, HIGH_RISK, TINY, _logPath, _loadLog };