genetics-mcp 2.23.0 → 2.25.0

package/skills/genetics-report/assets/patch.py

@@ -0,0 +1,411 @@
+#!/usr/bin/env python3
+"""원고 부분 고치기 — **멱등**. 회차마다 스크립트를 다시 짓지 않게 한다.
+
+## 왜 이 파일이 생겼나 (2026-09-22)
+
+포털은 「통째로 바꾸기」(`update_report`)만 준다. 그래서 회차마다 「이 문장을 저 문장으로」를
+적용하는 파이썬을 고객사 문서 폴더에 새로 지었고, 그것이 쌓였다 — 실측: 앳플리 #31 의
+문서 폴더에 20개 2,563줄, RDS 8.4 폴더에 46개 4,285줄(`edit-<날짜><글자>.py` 만 34개).
+매번 같은 뼈대(`rep`·`setv`·`droprows`·멱등·금지어 쓸기)를 다시 썼고, 다시 쓸 때마다 같은
+결함을 다시 만들었다(2026-09-21: `zip` 이 짧은 쪽에 맞춰 잘리는 탓에 `droprows` 가 두 번째
+실행에서 남은 줄 하나를 지웠다 — 여기서는 길이 검사로 막는다).
+
+**고치는 내용은 그 회차의 것이지만, 고치는 방법은 아니다.** 방법만 여기 두고,
+회차 폴더에는 **데이터 파일 하나**(edits.json)만 남긴다.
+
+## 쓰는 법
+
+    python3 patch.py report.json edits.json           # 적용
+    python3 patch.py report.json edits.json --dry     # 재 보기만(파일 안 건드림)
+    python3 patch.py base.json draft.json --freeze edits.json   # draft 의 set 에 old 를 base 에서 채워 굳힘(원고는 안 건드림)
+
+`edits.json` 은 목록이고, 각 항목은 `op` 하나다. `path` 는 원고 JSON 의 자리를
+`["sections", 1, "lede"]` 처럼 적는다(문자열 `"sections[1].lede"` 도 받는다).
+줄은 번호 대신 **첫 칸 글자**로 가리킬 수 있다 — `rows[label=관리자 통계 빈칸]`(목록 꼴은 `{"label": "…"}`). 앞 op 가 줄을
+끼우거나 빼도 같은 줄을 가리킨다. 보는 글자는 표 줄의 첫 칸 · 흐름도 줄의 `cells[0].text` · 발행 이력 줄의 `no` 뿐이고
+(도표 `rows` 의 `label` 칸은 보지 않는다), 그 글자인 줄이 **정확히 하나**일 때만 찾는다 — 없거나 둘 이상이면 멈춘다.
+**`[label=X]` 는 X 를 안 바꾸는 칸에만 쓴다** — 그 줄의 첫 칸(흐름도 `cells[0].text` · 발행 이력 `no`)을 바꾸면 두 번째 실행이 X 를 못 찾아
+멱등이 깨지므로, 그런 `set`·`replace` 는 돌리기 전에 멈춘다. 첫 칸을 바꾸는 편집은 번호 경로로 적는다(`--freeze` 가 `old` 를 채운다).
+배열 원소는 `assets[id=fig-a]` 처럼 `id` 로도 가리킨다 — 끝자리여도 된다(그 `id` 인 원소가 정확히 하나일 때만). 없는 자리(없는 칸 · 넘친 번호)는
+만들지 않고 멈춘다 — 칸을 더하려면 그 위 객체를 통째로 `set` 한다.
+
+| op | 칸 | 하는 일 |
+|---|---|---|
+| `set` | `path` · `old` · `new` | 그 자리 값이 `old` 면 `new` 로. 이미 `new` 면 건너뛴다 |
+| `replace` | `path` · `old` · `new` | 그 자리 **문자열 안**의 조각을 바꾼다 |
+| `drop_rows` | `path` · `labels` | 앞줄들을 뺀다. 첫 칸 글자가 `labels` 와 **정확히** 같을 때만 |
+| `remove_row` | `path` · `label` | 첫 칸이 그 글자인 줄 하나를 뺀다(자리는 어디든). 없으면 건너뛰고, 둘 이상이면 멈춘다 |
+| `append_row` | `path` · `row` | 없으면 뒤에 붙인다(있으면 건너뛴다) |
+| `insert_row` | `path` · `row` · `before` 또는 `after` | 없으면 첫 칸이 그 글자인 줄 앞(뒤)에 끼운다. 있는지를 자리보다 **먼저** 본다(있으면 건너뛴다) |
+| `forbid` | `words` | 원고 전체에서 그 낱말이 남았는지 **센다**(안 고친다) |
+
+모든 op 는 **멱등**이다 — 두 번 돌리면 두 번째는 「바꿈 0」이어야 하고, 그것이 이 도구의 계약이다.
+값이 `old` 도 `new` 도 아니면 **멈춘다** — 그 사이에 누가 고쳤다는 뜻이고, 조용히 덮으면 안 된다.
+끼울 줄(`append_row`·`insert_row` 의 `row`)은 **최종 값**으로 적는다 — 끼운 줄을 다른 op 로 또 고치면 두 번째 실행이 한 번 더 끼운다.
+
+## draft 와 `--freeze` (2026-09-29)
+
+긴 표 행의 `old` 를 손으로 옮기기 어려워, 한 수정 판에서는 스크래치 스크립트가 받은 판의 값을 읽어 `old` 를 채웠다.
+이제 draft 에는 `set` 의 `new` 만 적고, `--freeze` 가 base(`get_report` 로 받아 둔 판)에서 `old` 를 채워 OUT 에 쓴다.
+멈추는 때(그때는 OUT 을 안 쓴다): 편집이 0개 · OUT 이 비었거나 받은 판·draft 와 같은 파일 · set 한 자리를 다른 op 가 또 고침 ·
+줄을 끼우거나 뺀 표(`drop_rows`·`remove_row`·`insert_row` 뒤)의 칸을 번호로 가리키는 `old` 없는 `set` — `old` 는 받은 판 번호로 뜨는데
+적용은 밀린 번호로 돌아, 두 칸 값이 우연히 같으면 엉뚱한 줄을 고치고도 통과한다(2026-09-30 검토 재현 — 실제 표 칸의 8~17%). 그 줄은
+`[label=…]` 로 가리키거나 `old` 를 손으로 적는다(그때 번호는 앞 op 를 적용한 뒤의 번호) · base 사본에 두 번 돌려 첫 번째에서 건너뛰거나
+멈춤(base 에 이미 새 값이 있거나, 손으로 적은 번호 경로가 앞 op 가 민 번호가 아니다) · 두 번째에서 멈추거나 「바꿈 0」이 아님(멱등이 아니다 —
+번호 경로와 같은 표를 줄 op 가 밀었거나, 끼운 줄을 다른 op 로 또 고쳤다). 멈춘 op 가 줄을 끼우거나 뺀 표를 번호로 가리키면 그 까닭을 이름으로 말한다.
+`--dry` 와 `--freeze` 는 함께 쓰지 않는다.
+남은 금지어는 적용 때와 같은 규칙이다 — OUT 은 쓰고 종료 코드 1 로 끝난다.
+편집이 도판 칸(`assets…`)을 고치면 적용·굳히기가 한 줄 알린다 — 교체 인자에서 `assets` 를 빼면 서버가 저장된 도판(캡션·출처 줄·alt 포함)을
+그대로 이으므로, 그 판은 새 판의 `assets` 를 `get_report` 표식째 싣는다.
+**`old` 는 적용할 때 채우지 않는다** — 그러면 「그 사이 누가 고쳤다」를 못 잡는다. 적용에 `old` 없는 `set` 이 오면 멈춘다.
+"""
+import argparse
+import copy
+import json
+import os
+import re
+import sys
+
+# 자산 바이트·도해 SVG 는 글자가 아니다 — `forbid` 가 훑지 않는다.
+SKIP_KEYS = {'data', 'file', 'ref', 'mime', 'provider', 'svg'}
+_TOK = re.compile(r'([A-Za-z_]\w*)|\[(\d+)\]|\[id=([^\]]+)\]|\[label=([^\]]+)\]|\.')
+
+
+def parse_path(p):
+    """`["sections", 1, "lede"]` 또는 `"sections[1].lede"` → 자리 목록.
+
+    `assets[id=fig-a]` 꼴도 받는다 — 배열에서 `id` 로 찾는다(자리 번호가 흔들려도 안 깨진다 · 끝자리여도 된다 — `_find_id`).
+    `rows[label=…]` 는 첫 칸 글자로 줄을 찾는다(`_find_label`).
+    """
+    if isinstance(p, list):
+        return list(p)
+    out = []
+    for name, idx, aid, lab in _TOK.findall(str(p)):
+        if name:
+            out.append(name)
+        elif idx:
+            out.append(int(idx))
+        elif aid:
+            out.append({'id': aid})
+        elif lab:
+            out.append({'label': lab})
+    return out
+
+
+def locate(doc, path):
+    """자리 목록 → (부모, 열쇠). 마지막 한 칸은 남긴다 — 그 칸도 있어야 한다(`_step`)."""
+    cur = doc
+    for k in path[:-1]:
+        cur = cur[_step(cur, k, path)]
+    return cur, _step(cur, path[-1], path)
+
+
+def _step(cur, k, path):
+    """한 칸의 열쇠 — `[label=…]`·`[id=…]` 는 번호로 푼다. 없는 자리는 트레이스백 대신 경로를 말하고 멈춘다(만들지 않는다)."""
+    if isinstance(k, dict) and 'label' in k:
+        k = _find_label(cur, k['label'])
+    elif isinstance(k, dict):
+        k = _find_id(cur, k['id'])
+    if not ((isinstance(cur, dict) and isinstance(k, str) and k in cur)
+            or (isinstance(cur, list) and isinstance(k, int) and -len(cur) <= k < len(cur))):
+        sys.exit('✗ 그 자리가 없습니다 @ %s (%r) — 없는 칸은 만들지 않습니다(칸을 더하려면 그 위 객체를 통째로 set)'
+                 % (json.dumps(path, ensure_ascii=False), k))
+    return k
+
+
+def _find_id(items, aid):
+    """`id` 가 `aid` 인 원소의 번호 — 없거나 둘 이상이면 멈춘다(`_find_label` 과 같은 규칙)."""
+    hits = [i for i, x in enumerate(items if isinstance(items, list) else []) if isinstance(x, dict) and x.get('id') == aid]
+    if len(hits) != 1:
+        sys.exit('✗ id 가 「%s」인 칸이 %d개입니다 — 하나여야 합니다' % (aid, len(hits)))
+    return hits[0]
+
+
+def _label(r):
+    """줄을 알아보는 글자 — 표는 첫 칸, 흐름도는 첫 칸의 글."""
+    if isinstance(r, dict):
+        cells = r.get('cells') or []
+        return (cells[0] or {}).get('text', '') if cells else str(r.get('no', ''))
+    return r[0] if r else ''
+
+
+def _find_label(rows, label):
+    """첫 칸 글자가 `label` 인 줄의 번호 — 없거나 둘 이상이면 멈춘다(앞 op 가 줄을 끼우거나 빼도 같은 줄)."""
+    hits = [i for i, r in enumerate(rows if isinstance(rows, list) else []) if str(_label(r)) == str(label)]
+    if len(hits) != 1:
+        sys.exit('✗ 첫 칸이 「%s」인 줄이 %d개입니다 — 하나여야 합니다' % (label, len(hits)))
+    return hits[0]
+
+
+def _relabels(e):
+    """`[label=X]` 로 찾은 줄의 첫 칸 X 를 바꾸는 set·replace 면 X — 두 번째 실행이 그 줄을 못 찾는다(멱등이 깨진다). 아니면 None."""
+    if e.get('op') not in ('set', 'replace') or 'path' not in e:
+        return None
+    p = parse_path(e['path'])
+    for i, k in enumerate(p):
+        if not (isinstance(k, dict) and 'label' in k):
+            continue
+        rest, x, new = p[i + 1:], str(k['label']), e.get('new')
+        if e['op'] == 'replace':
+            after = x.replace(str(e.get('old')), str(new)) if rest in ([0], ['no'], ['cells', 0, 'text']) else x
+        elif not rest:
+            after = _label(new) if isinstance(new, (list, dict)) else None
+        elif rest in ([0], ['no'], ['cells', 0, 'text']):
+            after = new
+        elif rest == ['cells', 0]:
+            after = new.get('text', '') if isinstance(new, dict) else None
+        elif rest == ['cells']:
+            after = _label({'cells': new}) if isinstance(new, list) else None
+        else:
+            after = x
+        if after is None or str(after) != x:
+            return x
+    return None
+
+
+def walk_strings(o, path=''):
+    if isinstance(o, dict):
+        for k, v in o.items():
+            if k in SKIP_KEYS:
+                continue
+            yield from walk_strings(v, '%s.%s' % (path, k) if path else k)
+    elif isinstance(o, list):
+        for i, v in enumerate(o):
+            yield from walk_strings(v, '%s[%d]' % (path, i))
+    elif isinstance(o, str):
+        yield path, o
+
+
+class Run:
+    def __init__(self, doc):
+        self.doc, self.done, self.skipped, self.left = doc, 0, 0, []
+
+    def _where(self, e):
+        return e.get('why') or e.get('path') or e.get('op')
+
+    def set(self, e):
+        if 'old' not in e:
+            sys.exit('✗ set 에 old 가 없습니다 @ %s — draft 는 --freeze 로 먼저 굳힙니다' % self._where(e))
+        parent, key = locate(self.doc, parse_path(e['path']))
+        cur = parent[key]
+        if cur == e['new']:
+            self.skipped += 1
+            return
+        if cur != e['old']:
+            sys.exit('✗ 값이 다릅니다 @ %s\n  지금: %r\n  기대: %r\n'
+                     '  (그 사이에 누가 고쳤습니다 — 덮지 않고 멈춥니다)'
+                     % (self._where(e), cur, e['old']))
+        parent[key] = e['new']
+        self.done += 1
+
+    def replace(self, e):
+        parent, key = locate(self.doc, parse_path(e['path']))
+        cur = parent[key]
+        if not isinstance(cur, str):
+            sys.exit('✗ 문자열이 아닙니다 @ %s — %r' % (self._where(e), type(cur).__name__))
+        if e['old'] in cur:
+            parent[key] = cur.replace(e['old'], e['new'])
+            self.done += 1
+        elif e['new'] in cur:
+            self.skipped += 1
+        else:
+            sys.exit('✗ 옛 조각도 새 조각도 없습니다 @ %s\n  지금: %r\n  찾던 것: %r'
+                     % (self._where(e), cur, e['old']))
+
+    def drop_rows(self, e):
+        """⚠ 길이를 **먼저** 잰다 — zip 은 짧은 쪽에 맞춰 잘리므로, 이 검사가 없으면
+        두 번째 실행이 남은 줄을 지운다(2026-09-21 실측 사고)."""
+        parent, key = locate(self.doc, parse_path(e['path']))
+        rows, labels = parent[key], e['labels']
+        if len(rows) < len(labels) or [_label(r) for r in rows[:len(labels)]] != labels:
+            self.skipped += 1
+            return
+        del rows[:len(labels)]
+        self.done += 1
+
+    def append_row(self, e):
+        parent, key = locate(self.doc, parse_path(e['path']))
+        rows = parent[key]
+        if e['row'] in rows:
+            self.skipped += 1
+            return
+        rows.append(e['row'])
+        self.done += 1
+
+    def insert_row(self, e):
+        """`before`/`after` 줄 옆에 끼운다. 있는지를 자리보다 **먼저** 본다 — 두 번째 실행이 자리 줄을 못 찾아도 멈추지 않게."""
+        parent, key = locate(self.doc, parse_path(e['path']))
+        rows = parent[key]
+        if e['row'] in rows:
+            self.skipped += 1
+            return
+        if ('before' in e) == ('after' in e):
+            sys.exit('✗ insert_row 는 before · after 중 하나만 적습니다 @ %s' % self._where(e))
+        at = _find_label(rows, e['before'] if 'before' in e else e['after'])
+        rows.insert(at if 'before' in e else at + 1, e['row'])
+        self.done += 1
+
+    def remove_row(self, e):
+        """첫 칸이 `label` 인 줄 하나를 뺀다 — 없으면 이미 뺀 것으로 건너뛰고, 둘 이상이면 어느 줄인지 모르니 멈춘다."""
+        parent, key = locate(self.doc, parse_path(e['path']))
+        rows = parent[key]
+        hits = [i for i, r in enumerate(rows) if str(_label(r)) == str(e['label'])]
+        if not hits:
+            self.skipped += 1
+            return
+        if len(hits) > 1:
+            sys.exit('✗ 첫 칸이 「%s」인 줄이 %d개입니다 — 어느 줄을 뺄지 모릅니다 @ %s' % (e['label'], len(hits), self._where(e)))
+        del rows[hits[0]]
+        self.done += 1
+
+    def forbid(self, e):
+        for w in e['words']:
+            for p, s in walk_strings(self.doc):
+                if w in s:
+                    i = s.find(w)
+                    self.left.append((p, w, s[max(0, i - 25):i + 25]))
+
+
+OPS = {'set': 'set', 'replace': 'replace', 'drop_rows': 'drop_rows', 'remove_row': 'remove_row',
+       'append_row': 'append_row', 'insert_row': 'insert_row', 'forbid': 'forbid'}
+
+
+SHIFTERS = ('drop_rows', 'remove_row', 'insert_row')   # 목록 번호를 미는 op — append_row 는 끝에만 붙여 앞 번호를 안 민다
+
+
+def freeze(doc, edits):
+    """draft → edits: `set` 에 빠진 `old` 를 base(doc)에서 채우고, base 사본에 두 번 돌려 멱등을 잰다(doc 은 안 건드린다)."""
+    if not isinstance(edits, list) or not edits:
+        sys.exit('✗ 편집이 0개입니다 — draft 는 편집 목록(JSON 배열)이어야 합니다(받은 판과 draft 의 자리를 바꿔 주지 않았는지)')
+    # 줄을 끼우거나 뺀 표의 칸을 번호로 굳히지 않는다 — old 는 받은 판 번호로 뜨는데 적용은 밀린 번호로 돈다(머리 주석).
+    shifted = []
+    for e in edits:
+        p = parse_path(e['path']) if 'path' in e else []
+        if e['op'] == 'set' and 'old' not in e:
+            for s in shifted:
+                if len(p) > len(s) and p[:len(s)] == s and isinstance(p[len(s)], int):
+                    sys.exit('✗ 줄을 끼우거나 뺀 표의 칸을 번호로 굳히지 않습니다 @ %s — 그 줄은 [label=…] 로 가리키거나, '
+                             'set 의 old 를 손으로 적습니다(그때 번호는 앞 op 를 적용한 뒤의 번호)' % (e.get('why') or e['path']))
+        if e['op'] in SHIFTERS:
+            shifted.append(p)
+    # 사슬 — set 한 자리(또는 그 안)를 다른 op 가 또 고치면 첫 실행은 되고 두 번째 실행이 멈춘다(표를 통째 set 한 뒤 그 칸을 replace 등)
+    paths = [(e['op'], parse_path(e['path'])) for e in edits if 'path' in e]
+    for i, (op, p) in enumerate(paths):
+        if op != 'set':
+            continue
+        for j, (op2, q) in enumerate(paths):
+            if j != i and q[:len(p)] == p:
+                sys.exit('✗ set 한 자리(또는 그 안)를 또 고칩니다 @ %s (%s · %s) — 한 자리는 한 번만'
+                         % (json.dumps(p, ensure_ascii=False), op, op2))
+    out = []
+    for e in edits:
+        e = copy.deepcopy(e)
+        if e['op'] == 'set' and 'old' not in e:
+            parent, key = locate(doc, parse_path(e['path']))
+            # 손으로 쓴 목록과 같은 꼴 — old 를 new 바로 앞에 끼우고 나머지 칸 순서는 그대로 둔다(실사용 목록은 why 가 new 뒤)
+            filled = {}
+            for k, v in e.items():
+                if k == 'new':
+                    filled['old'] = copy.deepcopy(parent[key])
+                filled[k] = v
+            e = filled
+        out.append(e)
+    trial, first = copy.deepcopy(doc), None
+    for n in (1, 2):
+        run, at = Run(trial), -1
+        try:
+            # 사본으로 돈다 — set 이 꽂은 new 를 뒤 op 가 고치면 굳힌 목록의 new 가 조용히 바뀐다(2026-09-30 검토)
+            for at, e in enumerate(copy.deepcopy(out)):
+                skipped = run.skipped
+                getattr(run, OPS[e['op']])(e)
+                if n == 1 and run.skipped > skipped:   # draft 의 op 는 base 에서 모두 바뀌어야 한다
+                    sys.exit('✗ 바꿀 것이 없습니다 @ %s — base 에 이미 있거나(고친 뒤의 원고를 base 로 줬는지) 줄 라벨이 안 맞습니다'
+                             % run._where(e))
+        except SystemExit as x:
+            sys.exit('✗ 시험 적용 %d번째에서 멈춤 — %s\n%s' % (n, _why_stopped(n, at, out), x.code))
+        if n == 2 and run.done:
+            sys.exit('✗ 시험 적용 두 번째에서 바꿈 %d — 멱등이 아닙니다' % run.done)
+        first = first or run
+    return out, first
+
+
+def _why_stopped(n, at, edits):
+    """시험 적용이 멈춘 까닭의 한 줄 — 멈춘 op 가 줄을 끼우거나 뺀 표를 번호로 가리키면 그것을 이름으로 말한다.
+
+    첫 번째 실행에서는 앞선 줄 op 만 번호를 밀었고, 두 번째 실행에서는 목록의 모든 줄 op 가 이미 밀어 놓았다.
+    두 번째에서 멈췄다면 첫 번째는 건너뜀 없이 끝까지 돈 뒤라 base 탓일 수 없다 — 멱등이 아닌 것이다.
+    """
+    p = parse_path(edits[at]['path']) if 0 <= at < len(edits) and 'path' in edits[at] else []
+    for e in (edits[:at] if n == 1 else edits):
+        s = parse_path(e['path']) if e['op'] in SHIFTERS and 'path' in e else None
+        if s is not None and len(p) > len(s) and p[:len(s)] == s and isinstance(p[len(s)], int):
+            return ('이 op 는 줄을 끼우거나 뺀 표를 번호로 가리킵니다 — 그 줄은 [label=…] 로 가리키거나, '
+                    '손으로 적은 번호(set 의 old · replace)를 앞 op 를 적용한 뒤의 번호로 맞춥니다')
+    if n == 1:
+        return ('base 가 draft 를 쓴 판인지(고친 뒤의 원고를 base 로 줬는지), 손으로 적은 번호 경로(set 의 old · replace)가 '
+                '앞 op 를 적용한 뒤의 번호인지 봅니다')
+    return ('멱등이 아닙니다(첫 번째는 끝까지 돌았습니다) — 한 자리를 두 op 가 고쳤는지 봅니다: set 한 줄·칸을 다른 철자의 경로'
+            '(번호 ↔ [label=…])로 또 고쳤거나, 끼운 줄을 다른 op 로 또 고쳤습니다(끼울 줄은 최종 값으로 적습니다)')
+
+
+def main():
+    ap = argparse.ArgumentParser(description='원고 부분 고치기(멱등) — 회차 데이터는 edits.json 에')
+    ap.add_argument('report', help='원고 JSON (get_report 가 준 발행 데이터)')
+    ap.add_argument('edits', help='고칠 목록 JSON')
+    mode = ap.add_mutually_exclusive_group()
+    mode.add_argument('--dry', action='store_true', help='재 보기만 — 파일을 안 건드린다')
+    mode.add_argument('--freeze', metavar='OUT',
+                    help='edits 를 draft 로 읽어 set 의 old 를 report(base)에서 채우고, base 사본에 두 번 돌려 멱등이면 OUT 에 쓴다 — 원고는 안 건드린다')
+    a = ap.parse_args()
+
+    try:
+        doc = json.load(open(a.report, encoding='utf-8'))
+        edits = json.load(open(a.edits, encoding='utf-8'))
+    except ValueError as x:
+        sys.exit('✗ JSON 으로 못 읽었습니다 — %s. get_report 로 받은 파일이면 머리줄·꼬리 줄 없이 mcp-call.mjs --json 으로 받습니다' % x)
+    if not isinstance(doc, dict):
+        sys.exit('✗ 원고가 JSON 객체가 아닙니다 — 원고와 편집 목록의 자리를 바꿔 준 것 아닌지 봅니다')
+    if isinstance(edits, dict):
+        edits = edits.get('edits') or []
+    for i, e in enumerate(edits):
+        if e.get('op') not in OPS:
+            sys.exit('✗ 모르는 op: %r (edits[%d]) — 있는 것: %s' % (e.get('op'), i, ' · '.join(OPS)))
+    for i, e in enumerate(edits):
+        x = _relabels(e)
+        if x is not None:
+            sys.exit('✗ [label=%s] 로 찾은 줄의 첫 칸을 바꿉니다(edits[%d]) — 두 번째 실행이 그 줄을 못 찾아 멱등이 깨집니다. 첫 칸을 바꾸는 편집은 '
+                     '번호 경로로 적습니다(같은 표에 줄을 끼우거나 빼는 op 가 앞서면 old 를 손으로 — 그때 번호는 앞 op 를 적용한 뒤의 번호)' % (x, i))
+    if a.freeze is not None:
+        if not a.freeze.strip():
+            sys.exit('✗ --freeze 의 OUT 이 비었습니다')
+        for src in (a.report, a.edits):
+            if os.path.exists(a.freeze) and os.path.samefile(a.freeze, src):
+                sys.exit('✗ OUT 이 %s 와 같은 파일입니다 — 받은 판·draft 를 덮지 않게 다른 이름으로' % src)
+        out, run = freeze(doc, edits)
+        json.dump(out, open(a.freeze, 'w', encoding='utf-8'), ensure_ascii=False, indent=1)
+        print('굳힘 %d개 → %s (base 사본에 두 번 돌려 두 번째 바꿈 0)' % (len(out), a.freeze))
+        a.dry = True
+    else:
+        run = Run(doc)
+        for e in edits:
+            getattr(run, OPS[e['op']])(e)
+
+    if not a.dry:
+        json.dump(doc, open(a.report, 'w', encoding='utf-8'), ensure_ascii=False, indent=1)
+    print('바꿈 %d · 이미 같음 %d%s' % (run.done, run.skipped, ' (dry)' if a.dry else ''))
+    if run.left:
+        print('남은 금지어 %d곳' % len(run.left))
+        for p, w, ctx in run.left[:20]:
+            print('  「%s」 @ %s — …%s…' % (w, p, ctx.replace('\n', ' ')))
+    # 두 번째 실행이 0 이어야 한다는 계약을 사람이 눈으로 확인할 수 있게 한 줄 남긴다.
+    if run.done and not a.dry:
+        print('(멱등 확인: 한 번 더 돌려 「바꿈 0」이면 맞습니다)')
+    touched = sum(1 for e in edits if 'path' in e and (parse_path(e['path']) or [None])[0] == 'assets')
+    if touched:
+        print('도판 칸을 고친 편집 %d개 — 교체 인자에서 assets 를 빼면 서버가 저장된 도판(캡션·출처 줄·alt 포함)을 그대로 잇는다: '
+              '이 판은 새 판의 assets 를 get_report 표식째 싣는다' % touched)
+    sys.exit(1 if run.left else 0)
+
+
+if __name__ == '__main__':
+    main()