genetics-mcp 2.14.0 → 2.16.0

package/skills/gazette-report/scripts/sentbreak.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""sentbreak.py — 한글 문서의 「한 문장 한 줄」 조판을 마크업에 새긴다.
+
+  사용:  python3 sentbreak.py <파일.html>            (예행 — 세기만)
+         python3 sentbreak.py <파일.html> --apply    (적용)
+
+한글 보고서는 마침표에서 줄을 바꾼다. 문장을 이어 붙인 한글 문단은 기계가 쓴 글처럼 읽힌다.
+그런데 **줄만 바꾸면 안 된다** — 실측(report-v2): 문장의 26%가 글줄 폭을 넘어 접히고,
+좁은 여백 주석 단은 54%다. 접히면 둘째 줄과 다음 문장의 첫 줄이 같은 자리에서 시작해
+구별할 수 없다. 그래서 문장마다 블록으로 세우고 이어지는 줄만 내어쓴다:
+
+    .sn { display: block; padding-left: 1em; text-indent: -1em; }
+
+**낱말은 하나도 바뀌지 않는다.** contentdiff.sh 로 확인할 것.
+멱등이다 — 이미 감싼 블록은 건너뛴다.
+
+기각한 대안:
+  · <br /> 만            — 접힌 줄을 구별할 수 없다
+  · text-indent: -1em    — 첫 줄이 아니라 **다음 문장**이 들여써진다 (방향이 거꾸로)
+  · text-indent: … each-line
+      Chrome 은 CSS.supports 에 true 를 돌려주고 계산값도 `-17px each-line` 으로
+      보여 주면서 **렌더에서는 무시한다**(실측). 명세만 있고 구현이 없다.
+"""
+import io, os, re, sys
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from boundary import _mask, _unmask, SENT_END, INITIAL, TAG
+
+# 안에 블록 요소가 또 있으면 그 요소를 따로 처리한다 — 겹쳐 감싸지 않는다
+NESTED = re.compile(r'<(p|li|td|ul|ol|table|div|h[1-6])[\s>]', re.I)
+VOID = {'br', 'img', 'hr', 'input', 'wbr', 'i'}     # i 는 이 문서에서 빈 장식 아이콘
+
+# ── 무엇을 감싸는가 ────────────────────────────────────────────────────────
+# 「긍정 목록」으로 두면 검사기(tone.mjs)보다 좁아져 곧 어긋난다 — 실제로 뼈대의
+# .cover__lead 가 검사에는 걸리고 적용에는 빠졌다. 그래서 **전부 대상, 예외만 명시**로 뒤집는다.
+#
+# 예외 = 라벨-값 양식 행. 실측으로 고른다 — display 가 flex/grid 인 <p> 는
+# 산문이 아니라 「라벨 ｜ 값」 배치다. report-v2 실측: 아래 넷.
+DENY = {'cover__issuer', 'marg__k', 'apx__t', 'colophon__mark'}
+
+# 경계가 있는 블록은 클래스와 무관하게 감싼다 — 그게 규칙 자체다.
+# 아래는 **한 문장짜리도** 감싸는 자리 = 접히면 이어지는 줄을 내어써야 하는 산문.
+# (안 그러면 「두 문장 블록은 들여쓰고 한 문장 블록은 flush」로 두 방식이 섞인다 —
+#  실측: 여백 주석 단에서 Key Point 는 들여쓰고 Advice 는 flush 였다)
+PROSE = {'', 'ask__body', 'part__lede', 'gist__body', 'pt__lede', 'note', 'note--in',
+         'notice__text', 'urgent__t', 'colophon__note', 'marg__t', 'cover__lead'}
+PROSE_SPAN = {'hist__c'}                            # 표 한 칸을 통째로 감싼 인라인 산문
+TAGS = ['p', 'td', 'dd', 'figcaption']
+LIST_SCOPES = ['guide__a', 'limit__list', 'pt__askl']   # 산문 목록만. 차례·색인·표지 메타는 아니다
+
+OPEN = lambda tag: re.compile(r'(<%s\b([^>]*)>)(.*?)(</%s>)' % (tag, tag), re.S)
+SCOPE = lambda cls: re.compile(
+    r'(<(?:ul|ol|dl)\b[^>]*class="[^"]*\b%s\b[^"]*"[^>]*>)(.*?)(</(?:ul|ol|dl)>)' % re.escape(cls), re.S)
+
+def classes(attrs):
+    m = re.search(r'class="([^"]*)"', attrs)
+    return set(m.group(1).split()) if m else {''}
+
+def wrap(inner, single_ok=True):
+    """문장마다 <span class="sn"> 로 감싼다. 낱말은 하나도 바뀌지 않는다."""
+    if 'class="sn"' in inner or NESTED.search(inner):
+        return inner, 0
+
+    # ① 글자 하나하나가 원문 어디에서 왔는지 대응표를 만든다.
+    #    태그를 먼저 지우고 문장을 찾으면 「… 본 것. <small>…」 처럼
+    #    **마침표 뒤에 태그가 오는 경계**를 놓치거나, 자를 자리를 태그 안쪽으로 잡는다.
+    #    깊이 0(인라인 요소 바깥)의 글만 자를 수 있다 —
+    #    <span class="x">첫 문장. 둘째 문장.</span> 을 그냥 자르면 span 짝이 깨진다.
+    plain, at, depth, top_len = [], [], 0, 0
+    pos = 0
+    for m in list(TAG.finditer(inner)) + [None]:
+        end = m.start() if m else len(inner)
+        for k in range(pos, end):
+            plain.append(inner[k]); at.append((k, depth))
+            if depth == 0: top_len += 1
+        if not m: break
+        tag = m.group(0)
+        t = re.match(r'</?\s*([A-Za-z0-9]+)', tag)
+        name = t.group(1).lower() if t else ''
+        if name and name not in VOID and not tag.endswith('/>'):
+            depth += -1 if tag.startswith('</') else 1
+        pos = m.end()
+
+    flat = ''.join(plain)
+    masked, _ = _mask(flat, keep_len=True)   # 날짜를 가리되 길이는 그대로 (위치 대응 유지)
+    cuts = []
+    if True:
+        for m in SENT_END.finditer(masked):
+            if INITIAL.search(masked[:m.start(1)]): continue
+            # 부호와 그 앞 글자가 모두 깊이 0 이어야 자른다
+            if at[m.start(1)][1] != 0: continue
+            cuts.append((at[m.start(1)][0] + 1, m.end(2) - m.end(1)))   # (원문 위치, 지울 공백 수)
+
+    n = len(cuts)
+    if n == 0 and (not single_ok or top_len < 20):
+        return inner, 0
+
+    # ② 뒤에서부터 잘라 넣는다 — 앞 위치가 밀리지 않게
+    out = inner
+    for cut, ws in reversed(cuts):
+        out = out[:cut] + '</span><span class="sn">' + out[cut + ws:]
+
+    lead = re.match(r'\s*', out).group(0)
+    tail = re.search(r'\s*\Z', out).group(0)
+    core = out[len(lead):len(out) - len(tail)] if tail else out[len(lead):]
+    return f'{lead}<span class="sn">{core}</span>{tail}', n
+
+def run(path, write=False):
+    s = io.open(path, encoding='utf-8').read()
+    per = {}
+
+    def make_sub(label_of, allow):
+        def sub(m):
+            open_tag, attrs, inner, close = m.groups()
+            cls = classes(attrs)
+            if cls & DENY: return m.group(0)
+            new, n = wrap(inner, single_ok=bool(cls & allow))
+            if new is not inner:
+                k = label_of(cls); per[k] = per.get(k, 0) + max(n, 0)
+                if n == 0: per[k + ' (한 문장)'] = per.get(k + ' (한 문장)', 0) + 1; per[k] = per[k]
+            return open_tag + new + close
+        return sub
+
+    nm = lambda cls, pre: pre + (sorted(cls - {''})[0] if cls - {''} else '(무클래스)')
+    # 인라인 산문을 먼저 — 바깥 <td> 가 통째로 삼키기 전에
+    s = OPEN('span').sub(make_sub(lambda c: nm(c, 'span.'),
+                                  PROSE_SPAN if True else set()), s) if PROSE_SPAN else s
+    for tag in TAGS:
+        s = OPEN(tag).sub(make_sub(lambda c, t=tag: nm(c, t + '.'), PROSE), s)
+    for sc in LIST_SCOPES:
+        sub = make_sub(lambda c, sc=sc: f'{sc} > li', PROSE)
+        s = SCOPE(sc).sub(lambda mo: mo.group(1) + OPEN('li').sub(sub, mo.group(2)) + mo.group(3), s)
+
+    if write: io.open(path, 'w', encoding='utf-8').write(s)
+    return s, sum(v for k, v in per.items() if '한 문장' not in k), sorted(per.items(), key=lambda kv: -kv[1])
+
+if __name__ == '__main__':
+    path = sys.argv[1]; write = '--apply' in sys.argv
+    s, total, per = run(path, write)
+    for k, v in per:
+        if v: print(f'  {k:<26} {v:>3}')
+    print(f'{"적용" if write else "예행"} 경계 {total}곳 · <span class="sn"> {s.count(chr(60) + "span class=" + chr(34) + "sn" + chr(34))}개')

package/skills/gazette-report/scripts/tone.mjs

@@ -0,0 +1,172 @@
+/* tone.mjs — 보고서 문체 검사
+   사용: node tone.mjs <파일.html|.md>          (모듈로는 `import { analyze }`)
+   ① 경어체 잔존(0 이어야 함) ② 늘어짐 지표(밀도 기반) ②b 문체 유형 ③ 한 문장 한 줄
+
+   ②의 분류·처방은 epoko77-ai/im-not-ai (MIT) 의 「AI 한글 티 분류 체계」에서
+   **관보 보고서에도 그대로 해당하는 항목만** 골라 왔다. 그쪽은 산문 윤문 도구이므로
+   번역투(A)·영어 인용(B)·리듬 균일성(E)은 가져오지 않는다 —
+   개조식은 리듬이 균일한 것이 정상이다.
+
+   ②b(2026-08-27)는 사용자 반려 사유에서 회수한 넷이다 — 학생 보고서투 · 완충어 ·
+   근거 없는 총평 · 단독 부정 종결. 무엇을 재는가의 서술은 genetics-report 스킬
+   references/content-pipeline.md §6.4 에 있고, **집행은 여기뿐이다.**
+   ⚠ 단독 부정 종결에서 「주어가 사람·조직·국가인가」는 기계가 못 본다 —
+   그 판정은 사람의 눈 검수 몫이다(genetics-report references/process.md 7단계).
+
+   심각도: S1 한 번만 나와도 고친다 · S2 밀도 초과 시 고친다 · S3 겹칠 때만 본다 */
+import fs from 'fs';
+import { pathToFileURL } from 'url';
+
+export function analyze(raw0) {
+  const raw = String(raw0)
+    .replace(/<script[\s\S]*?<\/script>/g, '')
+    .replace(/<style[\s\S]*?<\/style>/g, '')
+    .replace(/<!--[\s\S]*?-->/g, '');
+  // 「인라인 강조」는 **문장 안에 박힌** 굵게만 센다.
+  // <b>01-1</b> · <b>표 1-1</b> · <b>Why</b> 같은 구조 라벨은 강조가 아니다 —
+  // 그것까지 세면 라벨이 많은 문서가 전부 지적당한다(스캐폴드 실측: 14건 중 13건이 오탐).
+  // 판정: 여는 태그 앞과 닫는 태그 뒤에 같은 블록 안에서 8자 이상의 글이 있을 때만.
+  const inlineEmph = (() => {
+    const blocks = raw.split(/<\/?(?:p|li|td|th|dd|dt|h[1-6]|figcaption|caption)[ >]/);
+    let n = 0;
+    for (const blk of blocks) {
+      const re = /<(b|strong)[ >][^>]*>([\s\S]*?)<\/\1>/g;
+      let m;
+      while ((m = re.exec(blk))) {
+        const before = blk.slice(0, m.index).replace(/<[^>]+>/g, '').trim();
+        const after = blk.slice(m.index + m[0].length).replace(/<[^>]+>/g, '').trim();
+        if (before.length >= 8 && after.length >= 8) n++;
+      }
+    }
+    return n;
+  })();
+  const txt = raw.replace(/<[^>]+>/g, ' ')
+    .replace(/&#x27;/g, "'").replace(/&amp;/g, '&').replace(/&nbsp;/g, ' ')
+    .replace(/\s+/g, ' ').trim();
+  const K = txt.length / 1000;   // 천 자 단위
+  const lines = [];
+
+  // ── ① 경어체 (S1) ────────────────────────────────────────────
+  const POLITE = /[^<>]{4,}?(?:습니다|십시오|합니다|입니다|됩니다|드립니다|주세요|하세요|해요)[.。]?/g;
+  const polite = txt.match(POLITE) || [];
+  lines.push(`[S1] 경어체 잔존: ${polite.length}건  (0 이어야 함 — 개조식은 ~함 / ~했음 / ~필요)`);
+  polite.slice(0, 12).forEach(h => lines.push('   ✗ ' + h.trim().slice(0, 80)));
+
+  // ── ②b-1 문체 유형 (S1 — 한 번만 나와도 고친다) ─────────────
+  // 「조사」 단독은 제외한다 — 「조사 결과」는 정상 낱말이다. 잡는 것은 서술형이다.
+  const STUDENT = /(사료됨|사료된다|고찰하|살펴보(?:았|고자)|알아보(?:았|고자)|에 대해(?:서)? 조사하|조사하였)/g;
+  // 「양해각서(MOU)」는 완충이 아니라 용어다 — 부분일치 오탐(2026-08-27 리뷰).
+  const BUFFER = /(부득이|양해(?!각서)|유감스럽|안타깝게도|죄송|\bplease\b)/gi;
+  const student = txt.match(STUDENT) || [];
+  const buffer = txt.match(BUFFER) || [];
+  lines.push(`\n[S1] 학생 보고서투: ${student.length}건  (0 이어야 함 — 「무엇을 했다」가 아니라 「무엇을 알아냈다」로)`);
+  student.slice(0, 8).forEach(h => lines.push('   ✗ ' + h));
+  lines.push(`[S1] 완충어: ${buffer.length}건  (0 이어야 함 — 사과 대신 사실 → 이유 → 선택지)`);
+  buffer.slice(0, 8).forEach(h => lines.push('   ✗ ' + h));
+
+  // ── ② 늘어짐 지표 (S2, 밀도) ─────────────────────────────────
+  const CHECKS = [
+    ['문두 접속사',   /(?:^|[.。] )(또한|따라서|즉|나아가|아울러|게다가|더욱이|그리고)\s/g, 1.5,
+     '70% 이상 제거. 논리 흐름은 문장 내용으로 표현'],
+    ['추측·관측 종결', /(보인다|보임|판단된다|판단됨|여겨진다|여겨짐|듯하다|듯함)/g, 1.0,
+     '근거가 있으면 단정. 없으면 「확인하지 못함」으로 범위를 명시'],
+    ['이중 완곡',     /(가능성[^.]{0,8}있을 수|것으로 보여질|수도 있을)/g, 0.2,
+     '완곡은 하나만'],
+    ['「이는 ~」 지시', /(이는 |이 점에서|이 관점에서|이 말은)/g, 1.0,
+     '앞 문장과 통합. 메타 진입 삭제 후 본 서술 직진'],
+    ['형식명사 결합',  /(라는 점에 있|다는 것이|라는 것이|다는 뜻이|할 필요가 있)/g, 1.0,
+     '구체 명사·동사로 치환. 「X는 ~다」 직설로'],
+    ['괄호 부연',     /\([^)]{6,}\)/g, 2.5,
+     '근거·출처 표기는 남기고, 설명 부연은 본문화'],
+    ['낫표 「」',      /「/g, 5.0,
+     '용어 첫 등장 1회만. 이후는 평문'],
+    ['대시 —',        /—/g, 0.5,
+     '쉼표·괄호·별도 문장으로 분해'],
+    // ②b-2 근거 없는 총평 — 등급·수치·절 참조가 할 일을 부사가 대신하면 슬롭이다.
+    ['근거 없는 총평', /(전반적으로|대체로|종합적으로 보면|매우 우수|크게 개선|성공적으로)/g, 1.0,
+     '총평은 등급·수치·절 참조로 대체'],
+  ];
+
+  lines.push(`\n[S2] 늘어짐 지표  (본문 ${txt.length}자 · 천 자당 밀도 · 3회 이상일 때만 지적)`);
+  let over = 0;
+  for (const [name, re, limit, fix] of CHECKS) {
+    const n = (txt.match(re) || []).length;
+    const d = n / K;
+    // 1~2회는 자연스럽다. 3회 이상 반복될 때만 「패턴」이다 —
+    // 최소 횟수가 없으면 짧은 글에서 1건이 밀도를 넘어 오탐이 된다.
+    const bad = d > limit && n >= 3;
+    if (bad) over++;
+    lines.push(`   ${bad ? '✗' : ' '} ${name.padEnd(14)} ${String(n).padStart(3)}건  ${d.toFixed(2)}/천자 (한도 ${limit})${bad ? '  → ' + fix : ''}`);
+  }
+  const ed = inlineEmph / K;
+  const edBad = ed > 5.0 && inlineEmph >= 3;
+  if (edBad) over++;
+  lines.push(`   ${edBad ? '✗' : ' '} ${'인라인 강조'.padEnd(14)} ${String(inlineEmph).padStart(3)}건  ${ed.toFixed(2)}/천자 (한도 5.0)${edBad ? '  → 굵게는 요지에만' : ''}`);
+
+  // ── ③ 한 문장 한 줄 (S1) ─────────────────────────────────────
+  // 한글 보고서는 마침표에서 줄을 바꾼다. 문장을 이어 붙인 한글 문단은 기계가 쓴 글처럼 읽힌다.
+  // 「줄바꿈이 있는가」는 낱말이 아니라 마크업으로 판정한다 — <span class="sn"> 또는 <br>.
+  // 날짜(2026. 8. 21.)·버전(iOS 26.4)·경로(api.php)는 문장 끝이 아니므로 먼저 가린다.
+  const BLOCK = /<(p|li|td|dd|figcaption)\b[^>]*>([\s\S]*?)<\/\1>/g;
+  // 연도 없는 점 날짜(8. 21.)도 문장 끝이 아니다 — 안 가리면 부정 종결의 문맥 창이 밀린다.
+  const DATE  = /\d{4}\.\s*\d{1,2}\.(?:\s*\d{1,2}\.)?|(?<!\d)\d{1,2}\.\s*\d{1,2}\.(?!\s*\d)/g;
+  const BOUND = /(?<=[가-힣0-9)\]」』”'"A-Za-z])[.!?]\s+(?=[가-힣0-9「『※(\[]|[A-Z])/g;
+  const runOn = [];
+  const blockTexts = [];   // ②b-3 이 같은 블록 단위를 다시 쓴다
+  {
+    let m;
+    while ((m = BLOCK.exec(raw))) {
+      const inner = m[2];
+      if (/<(p|li|td|ul|ol|table|div|h[1-6])[\s>]/i.test(inner)) continue;   // 겹친 블록은 안쪽에서 센다
+      const plain = inner.replace(/<[^>]+>/g, '').replace(/&#x27;/g, "'").replace(/\s+/g, ' ').trim();
+      blockTexts.push(plain);
+      const n = (plain.replace(DATE, '·').match(BOUND) || []).length;
+      if (n >= 1 && !/class="sn"|<br/i.test(inner)) runOn.push({ n, t: plain.slice(0, 60) });
+    }
+  }
+  // HTML 블록이 하나도 없으면(.md·평문) 빈 줄로 가른 문단을 블록으로 삼는다.
+  if (!blockTexts.length) blockTexts.push(...raw.split(/\n{2,}/).map(s => s.replace(/\s+/g, ' ').trim()).filter(Boolean));
+  lines.push(`\n[S1] 한 문장 한 줄: 이어 붙인 블록 ${runOn.length}개  (0 이어야 함 — 마침표에서 줄을 바꾼다)`);
+  runOn.slice(0, 10).forEach(r => lines.push(`   ✗ ${r.n + 1}문장 한 덩어리  ${r.t}`));
+  if (runOn.length) lines.push('   → scripts/sentbreak.py <파일> --apply · CSS 에 .sn { display:block; padding-left:1em; text-indent:-1em }');
+
+  // ── ②b-3 단독 부정 종결 (S1) ─────────────────────────────────
+  // 「할 수 없음 / 제외됨」으로 끝나는 문장은, 같은 블록 안(그 문장 자신 포함)에
+  // 이유·기준·재검토·선택지 표지가 없으면 배제 통보로 읽힌다 — 조건 주어 + 넷을 붙여
+  // 고쳐 쓴다(genetics-report content-pipeline §4.2 유형 K).
+  // ⚠ 주어가 사람·조직·국가인지는 여기서 못 본다 — 사람의 눈 검수 몫이다.
+  const NEG_END = /(할 수 없음|불가함|제외됨|제외함|지원하지 않음|미지원임|대상이 아님)\.?$/;
+  // 구제 표지(2026-08-27 리뷰로 조임):
+  //   · 「까지」는 날짜·기간에 붙었을 때만 — 「현재까지/지금까지」가 구제로 오인되던 미탐.
+  //   · 앞 문장은 **인과 표지**(때문·이유·기준·조건)일 때만 문맥이다 — 무관한 「예정」이 구제하던 미탐.
+  //   · 자기·다음 문장은 전 목록을 본다(유형 K 정형: 부정 뒤에 이유·재검토·선택지가 온다).
+  const RESCUE = /(때문|이유|기준|재검토|대신|대안|선택|가능한 것|조건|예정|(?:[0-9일월년주]|분기)\s*까지)/;
+  const CAUSAL = /(때문|이유|기준|조건)/;
+  const negation = [];
+  for (const blk of blockTexts) {
+    // 목록 번호(「1. 」)는 문장이 아니다 — 안 가리면 조각이 문맥 창을 밀어낸다.
+    const masked = blk.replace(DATE, '·').replace(/(^|\s)\d{1,2}\.(?=\s)/g, '$1·');
+    const sents = masked.split(/(?<=[.。!?])\s+/).map(s => s.trim()).filter(Boolean);
+    sents.forEach((s, i) => {
+      if (!NEG_END.test(s)) return;
+      if (RESCUE.test([s, sents[i + 1]].filter(Boolean).join(' '))) return;
+      if (CAUSAL.test(sents[i - 1] || '')) return;
+      negation.push(s.slice(0, 70));
+    });
+  }
+  lines.push(`\n[S1] 이유 없는 부정 종결: ${negation.length}건  (0 이어야 함 — 조건 주어 + 원인·기준·재검토·선택지)`);
+  negation.slice(0, 8).forEach(h => lines.push('   ✗ ' + h));
+
+  const s1extra = student.length + buffer.length + negation.length;
+  lines.push(`\n경어체 ${polite.length}건 · 이어 붙인 블록 ${runOn.length}개 · 밀도 초과 ${over}항 · 학생투 ${student.length} · 완충어 ${buffer.length} · 이유 없는 부정 종결 ${negation.length}`);
+  const fail = Boolean(polite.length || over || runOn.length || s1extra);
+  return { polite, runOn, over, student, buffer, negation, inlineEmph, textLen: txt.length, lines, fail };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const P = process.argv[2];
+  if (!P) { console.error('usage: node tone.mjs <file.html|.md>'); process.exit(1); }
+  const r = analyze(fs.readFileSync(P, 'utf8'));
+  console.log(r.lines.join('\n'));
+  process.exit(r.fail ? 1 : 0);
+}

package/skills/gazette-report/scripts/tone.test.mjs

@@ -0,0 +1,118 @@
+/* tone.test.mjs — 문체 검사기의 계약 (node --test)
+   deploy.sh 관문이 태운다. 양성 표본 수를 출력한다 — 0표본 통과는 통과가 아니다. */
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { analyze } from './tone.mjs';
+
+const wrap = (...ps) => ps.map(t => `<p>${t}</p>`).join('');
+let positives = 0;
+const pos = (n) => { positives += n; return n; };
+
+test('대조군 — 개조식·이유 있는 부정만 있는 문서는 전부 0', () => {
+  // 두 문장 블록은 조판 규칙대로 .sn 으로 세운다 — 안 그러면 「한 문장 한 줄」에 옳게 걸린다.
+  const r = analyze(wrap(
+    '저장이 일어나는 모든 경로를 수정함.',
+    '<span class="sn">라이선스 조항 때문에 그 경로는 쓸 수 없음.</span> <span class="sn">조항이 바뀌면 재검토 예정.</span>',
+    '확인 범위는 주문 목록 화면까지임.'));
+  assert.equal(r.polite.length, 0);
+  assert.equal(r.student.length, 0);
+  assert.equal(r.buffer.length, 0);
+  assert.equal(r.negation.length, 0);
+  assert.equal(r.runOn.length, 0);
+  assert.equal(r.fail, false);
+});
+
+test('경어체 잔존 — 회귀(기존 검사 유지)', () => {
+  const r = analyze(wrap('이번 회차 결과를 정리해 보고드립니다.'));
+  assert.equal(pos(r.polite.length) >= 1, true);
+  assert.equal(r.fail, true);
+});
+
+test('한 문장 한 줄 — 회귀(기존 검사 유지)', () => {
+  const bad = analyze('<p>첫 문장임. 둘째 문장임.</p>');
+  assert.equal(pos(bad.runOn.length), 1);
+  const good = analyze('<p><span class="sn">첫 문장임.</span> <span class="sn">둘째 문장임.</span></p>');
+  assert.equal(good.runOn.length, 0);
+});
+
+test('학생 보고서투 — 교대항 전수(하나를 빼는 뮤테이션은 여기서 죽는다), 「조사 결과」는 안 잡는다', () => {
+  for (const t of ['원인으로 사료됨.', '그 원인으로 사료된다.', '구조를 고찰하였음.', '동작을 살펴보았음.',
+                   '흐름을 살펴보고자 함.', '차이를 알아보았음.', '차이를 알아보고자 함.',
+                   '시장에 대해 조사하기로 함.', '동향을 조사하였음.']) {
+    const r = analyze(wrap(t));
+    assert.equal(pos(r.student.length) >= 1, true, t);
+    assert.equal(r.fail, true, t);
+  }
+  assert.equal(analyze(wrap('조사 결과는 부록 1에 있음.')).student.length, 0);
+});
+
+test('완충어 — 사과·양해 조각은 한 번만 나와도 잡는다', () => {
+  for (const t of ['부득이 일정을 미룸.', '양해 바람.', '유감스럽게도 재현하지 못함.',
+                   '안타깝게도 자료가 없음.', '죄송하지만 확인 필요.', 'please 확인 바람.']) {
+    assert.equal(pos(analyze(wrap(t)).buffer.length) >= 1, true, t);
+  }
+  assert.equal(analyze(wrap('사죄나 양보 없이 사실만 적음.')).buffer.length, 0);
+  // 「양해각서」는 용어다 — 완충 오탐이던 자리(2026-08-27 리뷰).
+  assert.equal(analyze(wrap('양해각서(MOU)를 체결함.')).buffer.length, 0);
+});
+
+test('근거 없는 총평 — 1회는 자연, 3회 반복이면 밀도 초과(S2)', () => {
+  const one = analyze(wrap('전반적으로 안정적임.', '세부 수치는 03절에 있음.'));
+  // 1건은 S2 최소 횟수(3) 미만 — 지적하지 않는다.
+  assert.equal(one.over, 0);
+  const three = analyze(wrap('전반적으로 안정적임.', '성공적으로 마무리함.', '크게 개선됨.'));
+  assert.equal(pos(three.over) >= 1, true);
+  assert.equal(three.fail, true);
+  // 교대항 전수 — 낱말 하나를 목록에서 빼는 뮤테이션은 그 낱말의 3연타에서 죽는다.
+  for (const w of ['전반적으로', '대체로', '종합적으로 보면', '매우 우수', '크게 개선', '성공적으로']) {
+    const r = analyze(wrap(`${w}라 판단함.`, `${w}라 적음.`, `${w}로 마무리함.`));
+    assert.equal(pos(r.over) >= 1, true, w);
+  }
+});
+
+test('단독 부정 종결 — 이유 표지가 붙으면 통과, 없으면 잡는다', () => {
+  // 일곱 어미 전부 — 목록에서 하나를 빼는 뮤테이션은 여기서 죽는다.
+  for (const end of ['할 수 없음', '불가함', '제외됨', '제외함', '지원하지 않음', '미지원임', '대상이 아님']) {
+    const r = analyze(wrap(`그 경로는 ${end}.`));
+    assert.equal(pos(r.negation.length), 1, end);
+    assert.equal(r.fail, true, end);
+  }
+  // 같은 문장 안의 이유(유형 K 정형)는 통과.
+  assert.equal(analyze(wrap('약관 조항 때문에 그 경로는 할 수 없음.')).negation.length, 0);
+  // 다음 문장의 이유·재검토도 통과 — 「앞뒤 문장」이 문맥이다.
+  assert.equal(analyze(wrap('그 경로는 제외됨. 약관 기준에 안 맞기 때문임.')).negation.length, 0);
+  // 다른 블록의 이유는 문맥이 아니다 — 여전히 잡는다.
+  assert.equal(pos(analyze(wrap('그 경로는 제외됨.', '기준은 부록 1에 있음.')).negation.length), 1);
+});
+
+test('부정 종결이 아닌 부정 — 목록 어구가 문장 **중간**이면 안 잡는다($ 앵커의 계약)', () => {
+  // 「지원하지 않음」이 그대로 들어 있되 문장 끝이 아니다 — $ 앵커를 빼는 뮤테이션은 여기서 죽는다.
+  assert.equal(analyze(wrap('지원하지 않음을 확인한 상태로 진행함.')).negation.length, 0);
+  assert.equal(analyze(wrap('지원하지 않는 형식이면 안내문이 뜸.')).negation.length, 0);
+});
+
+test('부정 종결 — 구제 표지의 조임(2026-08-27 리뷰 회귀)', () => {
+  // 「현재까지」의 「까지」는 기간 표지가 아니다 — 미탐이던 자리.
+  assert.equal(pos(analyze(wrap('현재까지 원인을 확인할 수 없음.')).negation.length), 1);
+  // 앞 문장의 무관한 「예정」은 문맥이 아니다 — 미탐이던 자리.
+  assert.equal(pos(analyze(wrap('예정된 일정대로 점검을 마침. 그 경로는 제외됨.')).negation.length), 1);
+  // 앞 문장이 **인과**면 문맥이다.
+  assert.equal(analyze(wrap('약관 기준이 바뀌었음. 그 경로는 제외됨.')).negation.length, 0);
+  // 날짜에 붙은 「까지」는 구제다.
+  assert.equal(analyze(wrap('그 형식은 미지원임. 12월 1일까지 대체 경로를 씀.')).negation.length, 0);
+  // 목록 번호 조각이 문맥 창을 밀지 않는다(.md 경로).
+  assert.equal(analyze('1. 약관 기준이 바뀜.\n2. 그 경로는 제외됨.').negation.length, 0);
+  // 연도 없는 점 날짜(8. 21.)가 문장을 가르지 않는다.
+  assert.equal(analyze(wrap('<span class="sn">그 경로는 제외됨.</span> <span class="sn">8. 21. 이후 재검토 예정임.</span>')).negation.length, 0);
+});
+
+test('CLI 계약 — lines 에 요약줄이 서고 fail 이 종료코드의 근거다', () => {
+  const r = analyze(wrap('그 경로는 제외됨.'));
+  assert.match(r.lines.at(-1), /이유 없는 부정 종결 1/);
+  assert.equal(r.fail, true);
+});
+
+test('양성 표본 수 — 0표본 통과 방지', () => {
+  console.log(`  양성 표본 ${positives}건 (0 이면 이 시험은 아무것도 안 잰 것)`);
+  assert.equal(positives >= 25, true, String(positives));
+});

package/skills/gazette-report/scripts/typesurvey.mjs

@@ -0,0 +1,48 @@
+/* typesurvey.mjs — 「어느 것이 어느 크기인가」 전수표
+   사용: node typesurvey.mjs <URL> [폭]
+
+   fontchk.mjs 는 크기가 몇 종인지를 본다. 이건 **어느 것이** 그 크기인지를 본다.
+   기계는 역할을 판정할 수 없으므로 판정은 사람이 한다 — 이 표가 그 재료다.
+
+   두 가지를 반드시 지킨다:
+   ① 크기·굵기를 **분포**로 모은다. 서명당 첫 표본을 대표로 찍으면 변형(--why)이나
+      문맥 상속(th 안)으로 갈리는 경우를 통째로 놓친다.
+   ② **평균 자수**를 같이 낸다. 자수가 역할을 가른다 —
+      한두 낱말이면 라벨(14px 가능), 문장이면 표제(본문보다 작으면 안 됨). */
+import { chromium } from 'playwright-core'; import os from 'os';
+const EXE = process.env.CHROME || `${os.homedir()}/Library/Caches/ms-playwright/chromium-1234/chrome-mac-arm64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing`;
+if (!process.argv[2]) { console.error('usage: node typesurvey.mjs <URL> [폭]'); process.exit(1); }
+const b = await chromium.launch({ executablePath: EXE });
+const p = await b.newPage({ viewport: { width: +(process.argv[3] || 1440), height: 900 } });
+await p.goto(process.argv[2], { waitUntil: 'networkidle' }); await p.waitForTimeout(800);
+const rows = await p.evaluate(() => {
+  const m = new Map();
+  document.querySelectorAll('body *').forEach(el => {
+    if (el.closest('script,style')) return;
+    const own = [...el.childNodes].filter(n=>n.nodeType===3).map(n=>n.textContent.trim()).join('');
+    if (!own) return;
+    const cs = getComputedStyle(el);
+    if (cs.display==='none' || cs.visibility==='hidden') return;
+    const cls = (typeof el.className==='string' && el.className.trim())
+      ? '.'+el.className.trim().split(/\s+/).join('.') : el.tagName.toLowerCase();
+    const par = (el.parentElement && typeof el.parentElement.className==='string' && el.parentElement.className.trim())
+      ? '.'+el.parentElement.className.trim().split(/\s+/)[0]+' > ' : '';
+    const sig = par + cls;
+    const rec = m.get(sig) || { sig, sizes:{}, ws:{}, n:0, ex:'', len:0 };
+    const sz = Math.round(parseFloat(cs.fontSize));
+    rec.sizes[sz]=(rec.sizes[sz]||0)+1; rec.ws[cs.fontWeight]=(rec.ws[cs.fontWeight]||0)+1;
+    rec.n++; rec.len += own.replace(/\s+/g,'').length;
+    if (!rec.ex) rec.ex = own.replace(/\s+/g,' ').slice(0,40);
+    m.set(sig, rec);
+  });
+  return [...m.values()];
+});
+await b.close();
+const key = o => Object.entries(o).sort((a,b)=>b[1]-a[1]).map(([k,v])=>`${k}×${v}`).join(' ');
+const maxSize = o => Math.max(...Object.keys(o).map(Number));
+rows.sort((a,b)=> maxSize(b.sizes)-maxSize(a.sizes) || a.sig.localeCompare(b.sig));
+let cur=null;
+for (const r of rows) { const s=maxSize(r.sizes); if (s!==cur){ cur=s; console.log(`\n━━━━ ${cur}px ━━━━`); }
+  const avg = Math.round(r.len/r.n);
+  console.log(`${r.sig.padEnd(44)} ${key(r.sizes).padEnd(14)} ${key(r.ws).padEnd(14)} 평균${String(avg).padStart(3)}자  ${r.ex}`); }
+console.log(`\n서명 ${rows.length}종`);

package/skills/gazette-report/template/README.md

@@ -0,0 +1,89 @@
+# template — 관보 문서 뼈대
+
+`gazette-report` 스킬로 새 문서를 시작할 때 여기서 출발한다.
+**추출 원본은 `FI-soft/report-v2`** — 8종 검사를 통과하고 A4 21쪽으로 인쇄되는 구현이다.
+문서 고유 요소(숫자 롤 · 경과일 배지 · 진입 모션)만 빼고 골격은 그대로다.
+
+**`gazette.css` 를 손으로 고치지 마라.** 이건 추출물이다. 조판 규칙이 바뀌면 레퍼런스를 고치고
+`../scripts/extract.sh <레퍼런스.css> gazette.css` 를 다시 돌린다. 손으로 따라 고쳤다가
+레퍼런스에서 폐기한 12px 등급이 여기 47곳 남아 있던 적이 있다.
+
+## 파일
+
+| 파일 | 무엇 |
+|---|---|
+| `gazette.css` | 조판 3체계(활자·간격·괘선) · 가구 · 두 단 본문 · 표 4괘선 · 확인 강도 표식 · 인쇄 페이지 문법. **문서 무관** — 그대로 링크해 쓴다 |
+| `skeleton.html` | 가구 9요소의 최소 골격. 절 2개(PART 2개) · 표 2종 · 흐름도 1개를 예시로 담았다 |
+
+## 시작하기
+
+```bash
+cp -r template 새문서 && cd 새문서
+python3 -m http.server 8781      # http://localhost:8781/skeleton.html
+```
+
+## 글을 채울 때 — 한 문장 한 줄
+
+한글은 마침표에서 줄을 바꾼다. 산문을 새로 써 넣었으면 마지막에 한 번 돌린다:
+
+```bash
+python3 ../scripts/sentbreak.py skeleton.html --apply   # 문장마다 <span class="sn">
+node    ../scripts/tone.mjs     skeleton.html           # 「이어 붙인 블록 0개」 확인
+```
+
+낱말은 바뀌지 않는다(`contentdiff.sh` 로 확인). 멱등이라 여러 번 돌려도 안전하다.
+
+## 반드시 고쳐야 하는 것 — 셋
+
+| # | 어디 | 무엇 |
+|---|---|---|
+| 1 | `gazette.css` 의 `[data-chapter]` · `[data-part-no]` | **장 색 · PART 색.** 팔레트를 베끼지 말고 **그 문서가 이미 쓰는 상태색**에서 뽑아라 — 「완료」 절이 초록인 이유는 완료 태그가 이미 초록이라서다 |
+| 2 | `gazette.css` 의 `--wide` · `--marg` | 문서 폭 · 여백 주석 단 폭 |
+| 3 | `gazette.css` 의 `@page` 마진 박스 `content` | 러닝 푸터 문구(`문서 제목 · 발행처`) |
+
+## 절을 늘리려면
+
+`skeleton.html` 의 `<!-- ══ 절 — 여기서부터 복제한다 ══ -->` 블록을 복제하고 넷을 함께 고친다:
+
+1. `<section class="part" id="sec-N" data-chapter="0N" data-part-no="M">`
+2. 차례의 `.toc__row[data-chapter]` 행
+3. 측면 색인 `.rail__tab[data-chapter]`
+4. 머리띠 `.crumb__row--ch` 의 칸
+
+**PART 를 늘릴 때**는 `.pt[data-part-no]` 간지 · 차례의 `.toc__part` 밴드 ·
+머리띠 `.crumb__row--part` 의 칸을 함께 넣는다.
+
+## 채울 때 지켜야 하는 것
+
+- **여백 주석 단(`? Why` / `! Key Point` / `i Advice`)** 은 **독자가 실제로 던질 질문**이어야 한다.
+  채우려고 넣으면 안 넣느니만 못하다.
+- **톤은 개조식** — `~함 / ~했음 / ~필요 / ~한 상황`. `~합니다 / ~주세요` 아님.
+- **표는 맨 아래 굵은 줄로 닫는다** (`--rule-edge`). 없으면 표가 목록으로 읽힌다.
+- **상자를 두르지 마라.** 구조는 괘선·여백·활자로 만든다.
+- **본문 상호참조 링크를 굵게 하지 마라.** 밑줄이 이미 신호다.
+- **시각 장치는 내용에서 도출된 것만.** 장식은 금지.
+
+## 스크립트
+
+상호작용(처리 표시 · 머리띠 위치 추적 · 진입 모션)은 문서마다 다르므로 뼈대에 없다.
+붙일 때 지켜야 할 계약은 `skeleton.html` 머리의 주석에 있다.
+
+## 검증
+
+뼈대 자체가 8종 검사를 통과한 상태로 배포된다. 채운 뒤에도 그대로 통과해야 한다.
+
+```bash
+cd ../scripts
+node kcheck.mjs    http://localhost:8781/skeleton.html
+node read.mjs      http://localhost:8781/skeleton.html 1440
+node read.mjs      http://localhost:8781/skeleton.html 390
+node fontchk.mjs   http://localhost:8781/skeleton.html 12,14,17,20,24,29,35,42,51,61
+node flexcheck.mjs http://localhost:8781/skeleton.html
+node tone.mjs      ../template/skeleton.html
+./cssaudit.sh      ../template/gazette.css
+./pdfcheck.sh      http://localhost:8781/skeleton.html
+```
+
+기준선(뼈대 상태, 2026-08-24 실측):
+대비 표본 116 · 미달 0 / 가독성 지적 0 / 활자 스케일 밖 0 · 굵은 글자 29% /
+경어체 0 · 밀도 초과 0 / route light / 인쇄 A4 12쪽.