python-hwpx-automation 6.0.3__py3-none-any.whl

hwpx_automation/office/evalplan/runtime.py

@@ -0,0 +1,2762 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Evaluation-plan (평가계획) review-markdown parser + target skeleton.
+
+The GOAL-loop recipe fills a blank province form from a structured review markdown
+(Ⅰ 운영계획 + [1]~[11]). This module is the *content* half: it parses that markdown
+into a structured :class:`EvalPlanContent` and derives the **target skeleton**
+(how many achievement / 성취수준 / rubric / 성취율 tables the content requires) that
+the quality scorer's C axis measures against (content-derived counts, not the
+1학기 gold's).
+
+Kept deliberately format-tolerant: the review markdown is hand-authored, so the
+parser locates sections by their numbered headers and pulls the GitHub-style
+tables under each. Prose sections are returned as normalised text. No content is
+invented — a missing section yields an empty field, surfaced by the scorer's D
+axis rather than silently filled.
+"""
+from __future__ import annotations
+
+import re
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, cast
+
+_CIRCLED = "①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮"
+
+
+def _md_table_rows(block: str) -> list[list[str]]:
+    """Every data row of the first GitHub-style table in *block* (header +
+    separator dropped), each split into trimmed cells."""
+    rows: list[list[str]] = []
+    seen_sep = False
+    for line in block.splitlines():
+        s = line.strip()
+        if not s.startswith("|"):
+            if rows:
+                break  # table ended
+            continue
+        cells = [c.strip() for c in s.strip("|").split("|")]
+        if all(set(c) <= {"-", ":", " "} and c for c in cells):
+            seen_sep = True
+            continue
+        rows.append(cells)
+    # first row is the header; keep only rows after the separator
+    if seen_sep and rows:
+        return rows[1:]
+    return rows[1:] if len(rows) > 1 else []
+
+
+def _md_table_header(block: str) -> list[str]:
+    for line in block.splitlines():
+        s = line.strip()
+        if s.startswith("|"):
+            return [c.strip() for c in s.strip("|").split("|")]
+    return []
+
+
+@dataclass
+class RubricItem:
+    """One 평가요소 (evaluation element) with its observable-criteria 배점 ladder —
+    ``levels`` is ``[(descriptor, 배점), …]`` top score first, verbatim from the MD.
+    ``subtotal`` marks a 소계 row (the sub-area 만점, not a scored element)."""
+    name: str
+    levels: list[tuple[str, str]] = field(default_factory=list)
+    subtotal: bool = False
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"name": self.name, "levels": [list(level) for level in self.levels],
+                "subtotal": self.subtotal}
+
+
+@dataclass
+class RubricSubArea:
+    """A 세부 영역 (가./나. …) or, for a single-table area, one anonymous sub-area
+    (``label==""``). ``points`` is the 소계 (0 if the MD gives none)."""
+    label: str = ""
+    points: int = 0
+    items: list[RubricItem] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"label": self.label, "points": self.points,
+                "items": [it.to_dict() for it in self.items]}
+
+
+@dataclass
+class Rubric:
+    title: str                       # "문제해결에 탐색 활용하기"
+    points: int                      # 35
+    standards: str                   # "[12인기02-04][12인기02-05]"
+    rows: list[list[str]] = field(default_factory=list)   # [평가항목, 채점 기준]
+    # --- detailed 배점 rubric (current 평가계획 MD format), empty for the legacy
+    # synthetic format; :attr:`detailed` gates the detailed fill route.
+    subareas: list[RubricSubArea] = field(default_factory=list)
+    base_score: str = ""             # 기본점수 (백지·미참여)
+    long_score: str = ""             # 장기 미인정 결석자 (기본점수 −1)
+    task: str = ""                   # 수행과제
+    method: str = ""                 # 평가 방법
+    student_notes: str = ""          # 학생 유의사항
+    criteria: str = ""               # 평가기준(상/중/하) — 2015-개정 (3학년) only
+
+    @property
+    def detailed(self) -> bool:
+        """True when parsed from the current 평가계획 MD (per-element 배점 ladders)."""
+        return bool(self.subareas)
+
+    @property
+    def items(self) -> list[RubricItem]:
+        """All 평가요소 across sub-areas, in document order (flattened view)."""
+        return [it for sa in self.subareas for it in sa.items]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"title": self.title, "points": self.points,
+                "standards": self.standards, "rows": self.rows,
+                "subareas": [sa.to_dict() for sa in self.subareas],
+                "base_score": self.base_score, "long_score": self.long_score}
+
+
+@dataclass
+class EvalPlanContent:
+    title: str = ""
+    teacher: str = ""
+    schedule: list[list[str]] = field(default_factory=list)     # Ⅰ, 6 cols/row
+    purposes: str = ""                                          # §1
+    directions: str = ""                                       # §2
+    policies: str = ""                                         # §3
+    achievement_std: list[list[str]] = field(default_factory=list)  # §4가 [성취기준,상,중,하]
+    levels: list[list[str]] = field(default_factory=list)      # §4나 [영역,A,B,C]
+    achieve_rate: list[list[str]] = field(default_factory=list)  # §5 [성취율,성취도]
+    ratio_header: list[str] = field(default_factory=list)      # §6 header cells
+    ratio_rows: list[list[str]] = field(default_factory=list)  # §6 data rows
+    rubrics: list[Rubric] = field(default_factory=list)        # §7
+    affective: str = ""                                        # §8
+    absentee: str = ""                                         # §9
+    cautions: str = ""                                         # §10
+    analysis: str = ""                                         # §11
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "title": self.title, "teacher": self.teacher,
+            "schedule_rows": len(self.schedule),
+            "achievement_std_rows": len(self.achievement_std),
+            "level_rows": len(self.levels),
+            "achieve_rate_rows": len(self.achieve_rate),
+            "ratio_areas": len([c for c in self.ratio_header if any(ch in c for ch in _CIRCLED)]),
+            "rubrics": [r.to_dict() for r in self.rubrics],
+        }
+
+
+def _section(md: str, start_pat: str, end_pats: list[str]) -> str:
+    m = re.search(start_pat, md)
+    if not m:
+        return ""
+    rest = md[m.end():]
+    ends = [re.search(p, rest) for p in end_pats]
+    cut = min((e.start() for e in ends if e), default=len(rest))
+    return rest[:cut]
+
+
+# a per-standard header: ``**[code]** 진술`` at the start of a line
+_ACH_STD_HEADER = re.compile(r"^\s*\*\*\s*(\[[^\]\n]+\])\s*\*\*\s*(.*?)\s*$")
+
+
+def _parse_achievement_std(block: str) -> list[list[str]]:
+    """Parse §4가 into one row per 성취기준: ``[standard, L1_desc, L2_desc, ...]``.
+
+    Two markdown authoring shapes are accepted; the level count is read from the
+    data, never hard-coded:
+
+    * **unified** -- a single table ``성취기준 | 상 | 중 | 하`` (or ``| A |…| E |``) with
+      one row per standard, level descriptors across the columns. Parsed by
+      :func:`_md_table_rows`.
+    * **per-standard** -- a sequence of ``**[code]** 진술`` headers, each followed by
+      its own ``수준 | 성취수준`` table listing the levels as *rows*. Each is normalised
+      to ``[code+진술, <descriptor per level, in table order>]``, so a standard with an
+      A~E table becomes a 6-field row (bh = 5) matching the unified shape that
+      :func:`fill_achievement` and :func:`_std_level_map` already consume.
+
+    The per-standard shape is tried first; when no ``**[code]**`` header carries a
+    table, the unified single-table parse is returned instead."""
+    lines = block.splitlines()
+    n = len(lines)
+    stds: list[list[str]] = []
+    i = 0
+    while i < n:
+        m = _ACH_STD_HEADER.match(lines[i])
+        if not m:
+            i += 1
+            continue
+        standard = f"{m.group(1)} {m.group(2)}".strip()
+        # advance to this standard's table (blank/prose lines may intervene), but
+        # stop at the next standard header -- a header with no table of its own.
+        j = i + 1
+        while j < n and not lines[j].lstrip().startswith("|"):
+            if _ACH_STD_HEADER.match(lines[j]):
+                break
+            j += 1
+        rows: list[list[str]] = []
+        while j < n and lines[j].lstrip().startswith("|"):
+            cells = [c.strip() for c in lines[j].strip().strip("|").split("|")]
+            if not all(set(c) <= {"-", ":", " "} and c for c in cells):
+                rows.append(cells)
+            j += 1
+        if len(rows) >= 2:                        # header row + >=1 level row
+            descs = [r[-1] for r in rows[1:]]     # right-most column = the descriptor
+            stds.append([standard, *descs])
+            i = j
+        else:
+            i += 1
+    return stds or _md_table_rows(block)
+
+
+def parse_review_md(md_text: str) -> EvalPlanContent:
+    """Parse a 평가계획 review markdown into structured content."""
+    c = EvalPlanContent()
+
+    # title + teacher (first heading + 담당교사 mention)
+    m = re.search(r"#\s*(\d{4}학년도[^\n]+?계획)", md_text)
+    if m:
+        c.title = re.sub(r"\s*\(검토용\)\s*$", "", m.group(1)).strip()
+    m = re.search(r"담당교사\s*[:：]\s*([^\s·|*]+)", md_text)
+    if m:
+        c.teacher = m.group(1).strip()
+
+    # Ⅰ schedule table
+    sched = _section(md_text, r"##\s*Ⅰ\.\s*교수학습 운영 계획", [r"##\s*Ⅱ\.", r"^##\s"])
+    c.schedule = _md_table_rows(sched)
+
+    # numbered sections [1]~[11] (### N. ...)
+    def sec(n: int) -> str:
+        return _section(md_text, rf"###\s*{n}\.\s", [rf"###\s*{n+1}\.\s", r"^##\s"])
+
+    c.purposes = _prose(sec(1))
+    c.directions = _prose(sec(2))
+    c.policies = _prose(sec(3))
+
+    s4 = sec(4)
+    ga = s4.split("**나.")[0]
+    na = ("**나." + s4.split("**나.")[1]) if "**나." in s4 else ""
+    c.achievement_std = _parse_achievement_std(ga)
+    c.levels = _md_table_rows(na)
+
+    c.achieve_rate = _md_table_rows(sec(5))
+
+    s6 = sec(6)
+    c.ratio_header = _md_table_header(s6)
+    c.ratio_rows = _md_table_rows(s6)
+
+    s7 = sec(7)
+    c.rubrics = _parse_rubrics(s7)
+
+    c.affective = _prose(sec(8))
+    c.absentee = _prose(sec(9))
+    c.cautions = _prose(sec(10))
+    c.analysis = _prose(sec(11))
+    return c
+
+
+def _prose(text: str) -> str:
+    """Normalised prose of a numbered section with its leading **title line**
+    dropped -- the ``### N. 평가의 목적`` heading text the section regex sweeps in is
+    not prose. Everything up to (and excluding) the first ordinal '가.' marker or
+    '-'/'*' bullet on its own is the title; the rest is the actual content."""
+    lines = [ln.strip() for ln in text.strip().splitlines() if ln.strip()]
+    # drop a leading title line (no ordinal marker, no bullet) if content follows
+    if lines and not re.match(r"^([가-힣]\.\s|[-*·]\s)", lines[0]) and len(lines) > 1:
+        lines = lines[1:]
+    return _norm(" ".join(lines))
+
+
+def _parse_rubrics(s7: str) -> list[Rubric]:
+    """Parse §7 수행평가 세부기준 into one :class:`Rubric` per 수행영역.
+
+    Dispatches on format: the current 평가계획 MD writes each area as an ``#### ①
+    title`` H4 heading with per-세부영역 ``평가요소 | 수행수준(채점 기준) | 배점`` tables
+    (the *detailed* 배점 rubric) — :func:`_parse_rubrics_detailed`. The older synthetic
+    format bolds the header inline (``**① title (NN점)**``) with a single flat 채점
+    기준(배점) table — :func:`_parse_rubrics_legacy`. Detection is structural (an H4
+    circled heading), never subject-specific."""
+    if re.search(r"(?m)^####\s*[" + _CIRCLED + r"]", s7):
+        return _parse_rubrics_detailed(s7)
+    return _parse_rubrics_legacy(s7)
+
+
+def _parse_rubrics_legacy(s7: str) -> list[Rubric]:
+    rubrics: list[Rubric] = []
+    # split on the bolded circled headers "**① title (NN점)** ..."
+    parts = re.split(r"\*\*([" + _CIRCLED + r"][^*]*?\(\d+점\)[^*]*)\*\*", s7)
+    # parts = [pre, header1, body1, header2, body2, ...]
+    for i in range(1, len(parts), 2):
+        header = parts[i]
+        body = parts[i + 1] if i + 1 < len(parts) else ""
+        mt = re.match(r"[" + _CIRCLED + r"]\s*(.*?)\s*\((\d+)점\)", header)
+        title = mt.group(1).strip() if mt else header.strip()
+        points = int(mt.group(2)) if mt else 0
+        ms = re.search(r"\[12[가-힣]*\d\d-\d\d\][^\n·]*", header + body)
+        standards = ms.group(0).strip() if ms else ""
+        rows = _md_table_rows(body)
+        rubrics.append(Rubric(title=title, points=points, standards=standards, rows=rows))
+    return rubrics
+
+
+def _strip_inline_md(s: str) -> str:
+    """Drop ``**bold**`` / `` `code` `` emphasis, collapse whitespace — cell text is
+    spliced verbatim otherwise (no summarisation)."""
+    return _norm(re.sub(r"\*\*|`", "", s or ""))
+
+
+def _iter_md_tables(block: str):
+    """Yield ``(preamble, header_cells, data_rows)`` for every GitHub table in *block*
+    in order. ``preamble`` is the non-table text since the previous table — it carries
+    the ``［세부 영역 …］`` marker that names each sub-area."""
+    lines = block.splitlines()
+    i = 0
+    preamble: list[str] = []
+    while i < len(lines):
+        if lines[i].strip().startswith("|"):
+            tbl = []
+            while i < len(lines) and lines[i].strip().startswith("|"):
+                tbl.append(lines[i].strip())
+                i += 1
+            rows = []
+            for t in tbl:
+                cells = [c.strip() for c in t.strip("|").split("|")]
+                if all(set(c) <= {"-", ":", " "} and c for c in cells):
+                    continue
+                rows.append(cells)
+            if rows:
+                yield "\n".join(preamble), rows[0], rows[1:]
+            preamble = []
+        else:
+            preamble.append(lines[i])
+            i += 1
+
+
+def _area_bullet(body: str, label: str) -> str:
+    """The value of a ``- **{label}**: …`` meta bullet in an area body ('' if absent)."""
+    m = re.search(rf"[-*]\s*\*\*{label}\*\*\s*[:：]?\s*(.+)", body)
+    return m.group(1).strip() if m else ""
+
+
+def _area_points(body: str, header: str) -> int:
+    """영역 만점 for an area — from the meta bullet / blockquote ('영역 만점: 50점',
+    '> 영역 만점 35점') or a ``(NN점)`` in the heading, else 0."""
+    m = re.search(r"영역\s*만점[은]?\**\s*[:：]?\s*(\d+)\s*점", body)
+    if not m:
+        m = re.search(r"\((\d+)\s*점\)", header)
+    return int(m.group(1)) if m else 0
+
+
+def _area_standards(body: str) -> str:
+    """The 성취기준 codes cited by an area, concatenated ('[12인기02-04][12인기02-05]')."""
+    m = re.search(r"(?:교육과정\s*성취기준|성취기준\s*/\s*성취수준|성취기준)[^\n]*?[:：]\s*(.+)", body)
+    src = m.group(1) if m else body
+    codes = re.findall(r"\[1\d[가-힣A-Za-z]*\d\d-\d\d\](?:\s*~\s*\[1\d[가-힣A-Za-z]*\d\d-\d\d\])?", src)
+    return "".join(codes)
+
+
+def _parse_area_rubric(header: str, title: str, body: str) -> Rubric:
+    """One 수행영역 → a detailed :class:`Rubric`: sub-area ``평가요소 | 수행수준 | 배점``
+    tables become :class:`RubricSubArea` blocks of :class:`RubricItem` ladders, and the
+    ［영역 공통］ / inline 기본점수 rows become ``base_score`` / ``long_score``. Content is
+    read verbatim — no invented 배점, no summarisation."""
+    rub = Rubric(title=title, points=_area_points(body, header),
+                 standards=_area_standards(body),
+                 task=_strip_inline_md(_area_bullet(body, "수행과제")),
+                 method=_strip_inline_md(_area_bullet(body, "평가 방법")),
+                 student_notes=_strip_inline_md(_area_bullet(body, "학생 유의사항")),
+                 criteria=_area_bullet(body, r"평가기준\(상/중/하\)"))
+    for pre, hdr, rows in _iter_md_tables(body):
+        hdr_txt = " ".join(hdr)
+        if "평가요소" in hdr_txt and "배점" in hdr_txt:
+            rub.subareas.append(_parse_subarea(pre, rows, rub))
+        elif "구분" in hdr_txt and "배점" in hdr_txt:
+            _absorb_base_row(rows, rub)          # ［영역 공통］ table
+    _sync_legacy_rows(rub)
+    return rub
+
+
+def _parse_subarea(preamble: str, rows: list[list[str]], rub: Rubric) -> RubricSubArea:
+    """Group a sub-area table's rows into 평가요소 items (new item = non-empty 평가요소
+    cell, continuation rows = extra levels). A named sub-area's 소계 row is kept as a
+    trailing subtotal item (verbatim md — it marks the 가/나 boundary and the sub-area
+    만점); 기본점수 / 장기 미인정 rows (appearing inline in single-table areas) feed
+    ``rub.base_score`` / ``long_score``."""
+    m = re.search(r"［세부 영역\s*([가-힣])\.\s*(.+?)\s*\((\d+)\s*점\)］", preamble or "")
+    sa = RubricSubArea(label=f"{m.group(1)}. {m.group(2)}" if m else "",
+                       points=int(m.group(3)) if m else 0)
+    cur: RubricItem | None = None
+    for row in rows:
+        c0 = _strip_inline_md(row[0]) if len(row) > 0 else ""
+        c1 = _strip_inline_md(row[1]) if len(row) > 1 else ""
+        c2 = _strip_inline_md(row[2]) if len(row) > 2 else ""
+        if "소계" in c0:
+            if c2.isdigit():
+                sa.points = int(c2)
+            if sa.label:                         # keep 소계 as a subtotal row (가/나 marker)
+                sm = re.match(r"(.*?소계)\s*\((.*)\)\s*$", c0)
+                name, note = (sm.group(1), sm.group(2)) if sm else (c0, "")
+                sa.items.append(RubricItem(name=name, levels=[(note, c2)], subtotal=True))
+            cur = None
+            continue
+        if "장기 미인정" in c0 or "장기미인정" in c0:
+            if c2.isdigit():
+                rub.long_score = c2
+            continue
+        if "기본점수" in c0:
+            if c2.isdigit():
+                rub.base_score = c2
+            continue
+        if c0:                                   # a new 평가요소
+            cur = RubricItem(name=c0)
+            sa.items.append(cur)
+        if cur is not None and (c1 or c2):
+            cur.levels.append((c1, c2))
+    return sa
+
+
+def _absorb_base_row(rows: list[list[str]], rub: Rubric) -> None:
+    """Read ［영역 공통］ ``구분 | 배점`` rows into ``base_score`` / ``long_score``. 장기
+    미인정 rows also carry '기본점수' (—1점), so match the more specific label first."""
+    for row in rows:
+        c0 = _strip_inline_md(row[0]) if row else ""
+        cN = _strip_inline_md(row[-1]) if row else ""
+        if not cN.isdigit():
+            continue
+        if "장기 미인정" in c0 or "장기미인정" in c0:
+            rub.long_score = cN
+        elif "기본점수" in c0:
+            rub.base_score = cN
+
+
+def _sync_legacy_rows(rub: Rubric) -> None:
+    """Mirror the detailed model into the legacy ``rows`` shape ([name, 'desc **s** / …']
+    + a trailing 기본점수 summary) so legacy introspection / scorers keep working."""
+    rows: list[list[str]] = []
+    for it in rub.items:
+        ladder = " / ".join(f"{d} **{s}**" if s else d for d, s in it.levels)
+        rows.append([it.name, ladder])
+    if rub.base_score or rub.long_score:
+        rows.append([f"기본점수 **{rub.base_score}** · 장기 미인정 결석 **{rub.long_score}**", ""])
+    rub.rows = rows
+
+
+def _parse_rubrics_detailed(s7: str) -> list[Rubric]:
+    """Parse the current-format §7 (``#### ①`` areas) into detailed rubrics."""
+    heads = list(re.finditer(r"(?m)^####\s*([" + _CIRCLED + r"])\s*(.+?)\s*$", s7))
+    out: list[Rubric] = []
+    for k, m in enumerate(heads):
+        start = m.end()
+        end = heads[k + 1].start() if k + 1 < len(heads) else len(s7)
+        out.append(_parse_area_rubric(m.group(0), m.group(2).strip(), s7[start:end]))
+    return out
+
+
+def _norm(text: str) -> str:
+    return " ".join(text.split()).strip()
+
+
+def expected_skeleton(content: EvalPlanContent, blank: str | Path | None = None) -> dict[str, int]:
+    """Content-derived block counts for the quality scorer's C axis.
+
+    The 평가계획 target collapses §4가 into a **single** achievement table (the
+    review MD ships one unified 성취기준 table for both the 2015-개정 상/중/하 and the
+    2022-개정 A~E families), §4나 into a **single** 학기 단위 성취수준 table, keeps
+    one 성취율 table (the band-count that matches the MD), the 정기시험-stripped
+    반영비율 table, and one rubric table per 수행영역.
+
+    The 2022-개정 (2학년) form additionally ships a 「다. 영역별 최소 성취수준」 table
+    (공통과목 전용); the owner's form-prep spec deletes it, so the target keeps
+    ``minlevel: 0``. ``blank`` is accepted for symmetry / future form detection but
+    the count target is content-derived and identical across 개정 (collapse-to-one),
+    so it is currently unused here."""
+    return {
+        "achievement": 1 if content.achievement_std else 0,
+        "level": 1 if content.levels else 0,
+        "minlevel": 0,                       # 최소 성취수준 (공통과목 전용) -> deleted
+        "rubric": len(content.rubrics),
+        "achieve_rate": 1 if content.achieve_rate else 0,
+        "ratio": 1 if content.ratio_header else 0,
+    }
+
+
+def plan_structural_ops(blank: str | Path, content: EvalPlanContent | None = None) -> dict[str, Any]:
+    """Confident, gold-policy structural edits for a 평가계획 blank (no content
+    fills): delete the red/optional tables and the 정기시험 columns, keeping the
+    original formatting byte-for-byte. Targets are located by *classification*
+    (reusable across the form family), not fixed indices. Returns
+    ``{"ops": [...], "transcript": [...]}`` — feed ``ops`` to
+    :func:`hwpx.table_patch.apply_table_ops`. Table deletes are emitted in
+    descending index order so earlier indices stay valid (column deletes do not
+    shift table indices).
+
+    Deferred (needs content mapping into the blank's rich cells, honest-defer):
+    achievement / 성취수준 / rubric block restructuring and cell text fills.
+    """
+    from ..form_fill.classification import _classify, _tables
+
+    tabs = _tables(blank)
+    ops: list[dict[str, Any]] = []
+    transcript: list[str] = []
+    del_tables: list[int] = []
+    exp = expected_skeleton(content, blank) if content else None
+    by_kind: dict[str, list[int]] = {}
+
+    # Which 성취율 table to KEEP: the one whose grade-band count matches the review
+    # MD (2015-개정 keeps the 3단계 A~C; 2022-개정 keeps the 5단계 A~E). Content-
+    # driven, so it generalises across 개정 rather than hard-coding "delete 5단계".
+    want_bands = len(content.achieve_rate) if content and content.achieve_rate else None
+    keep_rate = _pick_achieve_rate(tabs, want_bands)
+
+    for i, t in enumerate(tabs):
+        kind = _classify(t)
+        by_kind.setdefault(kind, []).append(i)
+        if kind in ("seokcha", "submit", "notice_star"):
+            del_tables.append(i)
+            transcript.append(f"delete_table #{i} ({kind}) — red/optional, gold removes it")
+        elif kind == "minlevel":
+            del_tables.append(i)
+            transcript.append(f"delete_table #{i} (영역별 최소 성취수준) — 공통과목 전용, 삭제")
+        elif kind == "achieve_rate" and keep_rate is not None and i != keep_rate:
+            del_tables.append(i)
+            transcript.append(f"delete_table #{i} (성취율 variant) — keep only #{keep_rate} "
+                              f"(matches MD {want_bands}단계)")
+        elif kind == "ratio":
+            cols = _regular_exam_cols(t)
+            if cols:
+                ops.append({"op": "delete_column", "tableIndex": i, "cols": cols})
+                transcript.append(f"delete_column #{i} cols {cols} (정기시험) — 100% 수행 subject")
+
+    # Surplus template-example tables: the blank ships >1 achievement / 성취수준 /
+    # rubric example (연주/비평 for 3학년, 6 국어 영역 for 2학년); the content needs
+    # `exp[kind]` of them. Delete the extras (keep the first) so the structure
+    # matches the content-derived skeleton.
+    detailed_rubrics = bool(content and content.rubrics and content.rubrics[0].detailed)
+    if exp:
+        for kind in ("achievement", "level", "rubric"):
+            idxs = by_kind.get(kind, [])
+            want = exp.get(kind, 0)
+            # For detailed rubrics the blank ships filled donor samples FIRST (인권·인포
+            # 그래픽) and clean empty templates LAST; the leading 인권 sample carries an
+            # extra 세부 항목 column the MD never uses, so keep the trailing clean
+            # templates instead (drop the surplus from the front).
+            surplus = idxs[:len(idxs) - want] if (kind == "rubric" and detailed_rubrics) else idxs[want:]
+            for i in surplus:
+                if i not in del_tables:
+                    del_tables.append(i)
+                    transcript.append(f"delete_table #{i} (surplus {kind} example) — "
+                                      f"content needs {want}, blank ships {len(idxs)}")
+
+    for i in sorted(set(del_tables), reverse=True):
+        ops.append({"op": "delete_table", "tableIndex": i})
+    # INDEX-SAFE ORDER: column deletes FIRST (they modify a table in place and do
+    # not shift table indices, so original indices are valid), THEN table deletes
+    # in descending index order (so each delete leaves lower indices unchanged).
+    # Emitting table deletes first would shift the ratio table under a later
+    # delete_column and silently corrupt the wrong table.
+    ops.sort(key=lambda o: (o["op"] == "delete_table", -o.get("tableIndex", 0)))
+    return {"ops": ops, "transcript": transcript,
+            "expected_skeleton": expected_skeleton(content) if content else None}
+
+
+def _rate_bands(table) -> int:
+    """Number of distinct 성취도 grade bands (A..E) a 성취율 table declares — its
+    'N단계'. Read from the grade column so 40%-boundary variants don't inflate it."""
+    from hwpx.table_patch import build_grid, table_text
+    tb = table.bytes
+    grid, rep = build_grid(tb)
+    grades: set[str] = set()
+    for r in range(1, rep.row_count):        # row 0 is the header
+        c = grid.get((r, rep.col_count - 1))  # grade is the right-most column
+        if c is None:
+            continue
+        g = table_text(tb[c.start:c.end]).strip()
+        if g in ("A", "B", "C", "D", "E"):
+            grades.add(g)
+    return len(grades)
+
+
+def _pick_achieve_rate(tabs, want_bands: int | None) -> int | None:
+    """Index of the single 성취율 table to KEEP among the blank's sample variants.
+
+    Chooses the variant whose grade-band count matches the review MD's 성취도 band
+    count (``want_bands``) -- 3학년 (2015-개정) keeps the 3단계 A~C, 2학년 (2022-개정)
+    keeps the 5단계 A~E. Ties (or ``want_bands`` unknown) fall back to the first
+    plain N-band table without a 40%-보장지도 boundary note (the canonical 고정분할
+    점수 table), else the first 성취율 table. Returns ``None`` when there is at most
+    one 성취율 table (nothing to prune)."""
+    from ..form_fill.classification import _classify
+    rate = [(i, t) for i, t in enumerate(tabs) if _classify(t) == "achieve_rate"]
+    if len(rate) <= 1:
+        return None
+    if want_bands:
+        exact = [i for i, t in rate if _rate_bands(t) == want_bands]
+        # prefer the exact-band table WITHOUT the 40% 최소성취수준 보장지도 boundary
+        # note (that is the 공통과목 variant, not the canonical 고정분할점수 table)
+        plain = [i for i in exact if "보장지도" not in dict(rate)[i].text]
+        if plain:
+            return plain[0]
+        if exact:
+            return exact[0]
+    return rate[0][0]
+
+
+def _regular_exam_cols(table) -> list[int]:
+    """Logical column indices of the 정기시험 span in a 반영비율 table header."""
+    from hwpx.table_patch import build_grid, table_text
+    tb = table.bytes
+    grid, rep = build_grid(tb)
+    cols: list[int] = []
+    for col in range(rep.col_count):
+        c = grid.get((0, col))
+        if c and "정기시험" in table_text(tb[c.start:c.end]):
+            cols.append(col)
+    return cols
+
+
+# --------------------------------------------------------------------------- #
+# Content fills (phase="all") -- byte-preserving cell/paragraph splices onto the
+# restructured form. Every target is located by *classification* / grid geometry
+# (reusable across the 평가계획 form family), never by a hard-coded 3학년 index; the
+# structural deletions before them shift indices, so each fill re-locates its
+# table fresh. All edits go through the byte-preserving primitives in
+# :mod:`hwpx.table_patch` / :mod:`hwpx.patch` -- no table is ever regenerated.
+# --------------------------------------------------------------------------- #
+
+_STD_CODE = re.compile(r"\[1\d[가-힣A-Za-z]*\d\d-\d\d\]")
+
+
+def _rubric_indices(data: bytes):
+    from ..form_fill.classification import _classify, _tables
+    return [i for i, t in enumerate(_tables(data)) if _classify(t) == "rubric"]
+
+
+def _classify_index(data: bytes, kind: str) -> int | None:
+    """First table index whose scorer classification is *kind* (or None)."""
+    from ..form_fill.classification import _classify, _tables
+    for i, t in enumerate(_tables(data)):
+        if _classify(t) == kind:
+            return i
+    return None
+
+
+def _grid_of(data: bytes, table_index: int):
+    """(section_path, table_bytes, grid, report) for a table by document index."""
+    from hwpx.table_patch import build_grid, iter_table_spans, section_parts
+    for sp, section in sorted(section_parts(data).items()):
+        spans = iter_table_spans(section)
+        if table_index < len(spans):
+            ts, te = spans[table_index]
+            tb = section[ts:te]
+            grid, rep = build_grid(tb)
+            return sp, tb, grid, rep
+        table_index -= len(spans)
+    raise IndexError("table index out of range across sections")
+
+
+def _cell_text(tb: bytes, grid, row: int, col: int) -> str:
+    from hwpx.table_patch import table_text
+    c = grid.get((row, col))
+    return table_text(tb[c.start:c.end]) if c else ""
+
+
+def fill_achievement(data: bytes, content: EvalPlanContent) -> tuple[bytes, dict[str, Any]]:
+    """Reshape the 성취기준 table to ``len(achievement_std)`` clean per-standard blocks
+    and fill each from the review MD (byte-preserving).
+
+    Works for BOTH 개정 by driving the block height off the content (the review MD
+    row is ``[code, <level descriptors...>]``): 2015-개정 (3학년) ships a 4-column
+    음악 example (성취기준 | 평가준거 | 상/중/하 | 서술) with 3-row 상/중/하 blocks; 2022-
+    개정 (2학년) ships a 3-column example (성취기준 | A~E | 서술) with 5-row A~E blocks.
+    We (1) drop the extra 평가준거 column when the blank is 4-wide, (2) delete every
+    data row except one canonical block whose height == the MD's level count,
+    (3) clone that block to N standards, then (4) splice each standard's code into
+    the leader cell and its level descriptors down the right-most (서술) column. The
+    level-label column (상/중/하 or A~E) carries over verbatim from the clone. A
+    no-op if the content has no achievement rows or the blank's block height doesn't
+    match the MD's level count (honest-defer, reported)."""
+    from hwpx.table_patch import apply_table_ops, direct_table_cells
+
+    stds = content.achievement_std
+    report: dict[str, Any] = {"n": len(stds), "filled": 0, "skipped": []}
+    if not stds:
+        return data, report
+    # descriptors per standard = MD columns after the code (3학년: 상/중/하 = 3;
+    # 2학년: A~E = 5). This is the target block height.
+    bh = max((len(s) - 1 for s in stds), default=0)
+    if bh < 1:
+        report["skipped"].append("achievement rows have no level descriptors")
+        return data, report
+
+    ti = _classify_index(data, "achievement")
+    if ti is None:
+        report["skipped"].append("no achievement table found")
+        return data, report
+
+    _sp, tb, _grid, rep = _grid_of(data, ti)
+    # Drop the 평가준거 column (only present in the 4-col 2015-개정 blank): it is the
+    # logical column that a clean standard's leader spans (cs2 header) but the MD
+    # has no content for. After the drop both 개정 are: col0=leader, col1=level
+    # label, col2=서술.
+    ops: list[dict[str, Any]] = []
+    if rep.col_count == 4:
+        ops.append({"op": "delete_column", "table_index": ti, "cols": [1]})
+    res = apply_table_ops(data, ops) if ops else None
+    data2 = res.data if res is not None else data
+    if res is not None and not res.ok:
+        report["skipped"].append(f"delete 평가준거 column: {[s.reason for s in res.skipped]}")
+        return data, report
+
+    # keep header + one clean block whose height matches the MD level count
+    _sp, tb, _grid, rep = _grid_of(data2, ti)
+    desc_col = rep.col_count - 1                       # right-most (서술) column
+    leaders = sorted((c for c in direct_table_cells(tb) if c.col == 0 and c.row_span == bh),
+                     key=lambda c: c.row)
+    if not leaders:
+        report["skipped"].append(
+            f"no clean {bh}-row block to seed from (blank block heights "
+            f"{sorted({c.row_span for c in direct_table_cells(tb) if c.col == 0 and c.row_span > 1})})")
+        return data, report
+    first = leaders[0]
+    keep = set(range(first.row, first.row + bh)) | {0}
+    delrows = sorted((r for r in range(rep.row_count) if r not in keep), reverse=True)
+    if delrows:
+        res = apply_table_ops(data2, [{"op": "delete_row", "table_index": ti, "rows": delrows}])
+        if not res.ok:
+            report["skipped"].append(f"prune to one block: {[s.reason for s in res.skipped]}")
+            return data, report
+        data2 = res.data
+
+    # grow to N blocks by cloning the single block (now rows 1..bh)
+    n = len(stds)
+    if n > 1:
+        res = apply_table_ops(data2, [{"op": "insert_block_by_clone", "table_index": ti,
+                                       "ref_rows": [1, bh], "count": n - 1}])
+        if not res.ok:
+            report["skipped"].append(f"clone to {n} blocks: {[s.reason for s in res.skipped]}")
+            return data, report
+        data2 = res.data
+
+    # fill each block: leader (rs=bh, col0) = code+text; 서술 col rows = descriptors
+    cells: list[dict[str, Any]] = []
+    for i, std in enumerate(stds):
+        lr = 1 + bh * i
+        cells.append({"table_index": ti, "row": lr, "col": 0, "text": std[0], "max_lines": 6})
+        for k, desc in enumerate(std[1:1 + bh]):
+            cells.append({"table_index": ti, "row": lr + k, "col": desc_col, "text": desc, "max_lines": 5})
+    from hwpx.table_patch import fill_cells
+    fr = fill_cells(data2, cells)
+    report["filled"] = len(fr.applied)
+    report["skipped"].extend(s.reason for s in fr.skipped)
+    return fr.data, report
+
+
+_GRADE_ROW = re.compile(r"^[A-E]$")
+
+
+def fill_levels(data: bytes, content: EvalPlanContent) -> tuple[bytes, dict[str, Any]]:
+    """Fill the 성취수준 table's descriptor column from the review MD levels,
+    replacing the blank's sample. Handles BOTH review shapes:
+
+    * 2015-개정 (3학년): ``levels`` is per-area ``[[영역, A, B, C], ...]`` → the first
+      area's A/B/C descriptors fill rows 1-3 of a ``성취수준 | 일반적 특성`` grid.
+    * 2022-개정 (2학년): ``levels`` is grade-major ``[[A, 서술], [B, 서술], ...]`` → each
+      grade's descriptor fills the matching A/B/C/D/E row of the ``학기 단위 성취수준``
+      grid (matched by the row's grade label, so a shape mismatch never corrupts it).
+
+    Only descriptor cells are touched (byte-preserving)."""
+    from hwpx.table_patch import fill_cells, table_text
+
+    report: dict[str, Any] = {"filled": 0, "skipped": []}
+    if not content.levels:
+        return data, report
+    ti = _classify_index(data, "level")
+    if ti is None:
+        report["skipped"].append("no level table found")
+        return data, report
+    _sp, tb, grid, rep = _grid_of(data, ti)
+
+    grade_major = all(len(r) >= 2 and _GRADE_ROW.match(r[0].strip()) for r in content.levels)
+    desc_col = rep.col_count - 1
+    cells = []
+    if grade_major:
+        # map grade letter -> its descriptor; fill each table row by its grade label
+        by_grade = {r[0].strip(): r[-1] for r in content.levels}
+        for row in range(1, rep.row_count):
+            c0 = grid.get((row, 0))
+            label = table_text(tb[c0.start:c0.end]).strip() if c0 else ""
+            if label in by_grade and grid.get((row, desc_col)):
+                cells.append({"table_index": ti, "row": row, "col": desc_col,
+                              "text": by_grade[label], "max_lines": 6})
+    else:
+        abc = content.levels[0][1:1 + (rep.row_count - 1)] if len(content.levels[0]) >= 2 else []
+        for k, desc in enumerate(abc):
+            r = 1 + k
+            if grid.get((r, desc_col)):
+                cells.append({"table_index": ti, "row": r, "col": desc_col, "text": desc, "max_lines": 5})
+    fr = fill_cells(data, cells)
+    report["filled"] = len(fr.applied)
+    report["skipped"].extend(s.reason for s in fr.skipped)
+    return fr.data, report
+
+
+def _batjeom_line(item_label: str, criteria: str) -> str:
+    """Compose one 채점기준 cell line: 'label: level 15 / level 12 / ...' from the
+    MD's bolded-배점 criteria string ('명확히 정의·트리 표현 **15** / ...')."""
+    clean = criteria.replace("**", "").strip()
+    return f"{item_label}: {clean}" if clean else item_label
+
+
+def _top_batjeom(criteria: str) -> str:
+    m = re.findall(r"\*\*(\d+)\*\*", criteria)
+    return m[0] if m else ""
+
+
+def _base_scores(rows: list[list[str]]) -> tuple[str, str, str, str]:
+    """Pull 기본점수 / 장기 미인정 labels+scores from a rubric's trailing summary
+    row ('기본점수(백지·미참여) **14** · 장기 미인정 결석 **13**').
+
+    The label itself can contain a middle-dot ('백지·미참여'), so split on the
+    score-bearing clause boundary ('**N** ·'), not on every '·'."""
+    base_label, base_score, long_label, long_score = "기본점수", "", "장기 미인정 결석", ""
+    for row in rows:
+        cell = row[0]
+        if "기본점수" not in cell:
+            continue
+        # boundary: the ' · ' that follows the first '**score**'
+        m = re.match(r"(.*?\*\*\d+\*\*)\s*·\s*(.*)", cell)
+        if m:
+            first, second = m.group(1), m.group(2)
+        else:
+            first, second = cell, ""
+        b = re.findall(r"\*\*(\d+)\*\*", first)
+        long = re.findall(r"\*\*(\d+)\*\*", second)
+        base_label = re.sub(r"\s*\*\*\d+\*\*", "", first).strip() or base_label
+        if second:
+            long_label = re.sub(r"\s*\*\*\d+\*\*", "", second).strip() or long_label
+        if b:
+            base_score = b[0]
+        if long:
+            long_score = long[0]
+    return base_label, base_score, long_label, long_score
+
+
+def _parse_level_ladder(criteria: str) -> list[tuple[str, str]]:
+    """Parse one 평가항목's 채점기준 ladder ('전처리·완비 **30** / 대부분 **24** / …')
+    into ``[(descriptor, 배점), …]`` — one tuple per level, top score first. Each
+    level is a ``' / '``-separated clause whose ``**\\d+**`` marker is the 배점 and the
+    remaining text the descriptor. Clauses without a score marker are dropped (a level
+    must carry a 배점 to be faithfully placeable). This is the flat-ladder counterpart of
+    the 3학년 (2015-개정) ``_batjeom_line`` / ``_top_batjeom`` parse, kept as an explicit
+    (desc, score) list so the 2022 reshape can lay one grid row per level."""
+    out: list[tuple[str, str]] = []
+    for clause in re.split(r"\s*/\s*", (criteria or "").strip()):
+        m = re.search(r"\*\*(\d+)\*\*", clause)
+        if not m:
+            continue
+        desc = re.sub(r"\s*\*\*\d+\*\*\s*", "", clause).strip()
+        out.append((desc, m.group(1)))
+    return out
+
+
+def _pf_bounds(tb: bytes, grid, rep) -> tuple[int | None, int | None]:
+    """(평가요소 header row, 기본점수 row) of a 2022 rubric — the 채점기준 ladder region
+    is the physical rows strictly between them."""
+    from hwpx.table_patch import table_text
+    ph = base = None
+    for r in range(rep.row_count):
+        c0 = grid.get((r, 0))
+        if c0 is None:
+            continue
+        t0 = table_text(tb[c0.start:c0.end])
+        if t0.replace(" ", "").strip() == "평가요소":
+            ph = r
+        if base is None and "기본점수" in t0:
+            base = r
+    return ph, base
+
+
+def _pf_groups(tb: bytes, ph: int, base: int) -> list[tuple[int, int]]:
+    """The col0 평가요소 leader groups (row, rowSpan) strictly inside ``(ph, base)`` —
+    one per 평가항목, in document order. Deduped by byte span (a merged leader is one
+    group even though it covers several logical rows)."""
+    from hwpx.table_patch import direct_table_cells
+    seen: set[tuple[int, int]] = set()
+    groups: list[tuple[int, int]] = []
+    for c in sorted(direct_table_cells(tb), key=lambda c: c.row):
+        if c.col == 0 and ph < c.row < base and (c.start, c.end) not in seen:
+            seen.add((c.start, c.end))
+            groups.append((c.row, c.row_span))
+    return groups
+
+
+def _pf_desc_col(tb: bytes, ph: int, base: int, bat_col: int) -> int:
+    """The 수행수준(채점기준) descriptor column — the widest (max colSpan) data cell in
+    the ladder region. A narrower col to its left (col 1) is the optional 세부 항목
+    (sub-item) column, present in the 45점 45×9 rubric but not the 30/25점 grids."""
+    from hwpx.table_patch import direct_table_cells
+    best, best_span = None, 0
+    for c in direct_table_cells(tb):
+        if ph < c.row < base and 1 <= c.col < bat_col and c.col_span > best_span:
+            best_span, best = c.col_span, c.col
+    return best if best is not None else 1
+
+
+def _pf_subitems(tb: bytes, r0: int, h: int) -> list[tuple[int, int]]:
+    """col1 세부 항목 sub-blocks (row, rowSpan) inside a 평가요소 group [r0, r0+h)."""
+    from hwpx.table_patch import direct_table_cells
+    seen: set[tuple[int, int]] = set()
+    subs: list[tuple[int, int]] = []
+    for c in sorted(direct_table_cells(tb), key=lambda c: c.row):
+        if c.col == 1 and r0 <= c.row < r0 + h and (c.start, c.end) not in seen:
+            seen.add((c.start, c.end))
+            subs.append((c.row, c.row_span))
+    return subs
+
+
+def _pf_clean_level_row(grid, r: int, desc_col: int, bat_col: int) -> bool:
+    """A row that OWNS both a descriptor cell (at ``desc_col``) and a 배점 cell (at
+    ``bat_col``) starting at row ``r`` with rowSpan==1 — a self-contained level row
+    safe to keep/clone. A row whose 배점 is covered by a vertical merge from above
+    (rowSpan>1) is NOT clean: keeping it while dropping its merge-top would hole the
+    grid, so those are the rows we delete."""
+    d = grid.get((r, desc_col))
+    b = grid.get((r, bat_col))
+    return bool(d and b and d.row == r and b.row == r and d.row_span == 1 and b.row_span == 1)
+
+
+def _reduce_to_first_subitem(data: bytes, ti: int, r0: int, h: int) -> tuple[bytes, int, list[str]]:
+    """If a 평가요소 group [r0, r0+h) subdivides into >1 col1 세부 항목 block (the 45점
+    rubric does), delete every block after the first so the group maps to the MD's ONE
+    flat 평가항목 ladder. Byte-preserving (delete_row only); returns (data, new_height,
+    skip_reasons). The MD carries no sub-item decomposition, so keeping every sub-block
+    would have no faithful source — collapsing to the first block is the honest map."""
+    from hwpx.table_patch import apply_table_ops
+    _sp, tb, _grid, _rep = _grid_of(data, ti)
+    subs = _pf_subitems(tb, r0, h)
+    if len(subs) <= 1:
+        return data, h, []
+    _first_r, first_h = subs[0]
+    del_rows: list[int] = []
+    for sr, sh in subs[1:]:
+        del_rows.extend(range(sr, sr + sh))
+    res = apply_table_ops(data, [{"op": "delete_row", "table_index": ti, "rows": sorted(set(del_rows), reverse=True)}])
+    if not res.ok:
+        return data, h, [f"drop surplus 세부 항목 blocks: {[s.reason for s in res.skipped]}"]
+    return res.data, first_h, []
+
+
+def _normalize_ladder_group(data: bytes, ti: int, r0: int, h: int, m: int,
+                            desc_col: int, bat_col: int) -> tuple[bytes, list[str]]:
+    """Reshape a 평가요소 group [r0, r0+h) to exactly ``m`` clean level rows (byte-
+    preserving delete_row / insert_row_by_clone). Keeps the leader row r0 plus the
+    first (m-1) clean interior level rows, deletes the rest, and clones a clean interior
+    row up when the group is short. Fail-closed: returns (data unchanged, [reason]) if
+    the shape can't be reached cleanly (e.g. too few clean rows to shrink to m)."""
+    from hwpx.table_patch import apply_table_ops
+    _sp, _tb, grid, _rep = _grid_of(data, ti)
+    interior = list(range(r0 + 1, r0 + h))
+    clean = [r for r in interior if _pf_clean_level_row(grid, r, desc_col, bat_col)]
+    if not _pf_clean_level_row(grid, r0, desc_col, bat_col):
+        return data, [f"group r0={r0}: leader row is not a clean level row"]
+    keep = clean[: m - 1]
+    del_rows = sorted(set(interior) - set(keep), reverse=True)
+    d = data
+    if del_rows:
+        res = apply_table_ops(d, [{"op": "delete_row", "table_index": ti, "rows": del_rows}])
+        if not res.ok:
+            return data, [f"group r0={r0}: shrink {del_rows}: {[s.reason for s in res.skipped]}"]
+        d = res.data
+    have = 1 + len(keep)
+    if have < m:
+        # clone the group's clean interior template (now at r0+1) up to m rows
+        res = apply_table_ops(d, [{"op": "insert_row_by_clone", "table_index": ti,
+                                   "ref_row": r0 + 1, "count": m - have}])
+        if not res.ok:
+            return data, [f"group r0={r0}: grow: {[s.reason for s in res.skipped]}"]
+        d = res.data
+    elif have > m:
+        return data, [f"group r0={r0}: only {len(clean)} clean rows, cannot shrink to {m}"]
+    return d, []
+
+
+def _fill_rubric_2022_ladder(data: bytes, ti: int, rub: Rubric) -> tuple[bytes, bool, list[str]]:
+    """Reshape + fill ONE 2022-개정 rubric's 수행수준 채점기준 ladder from the review MD,
+    byte-preserving. Each MD 평가항목 carries a flat level ladder ('desc **30** / desc
+    **24** / …'); the blank decomposes each 평가요소 into sample-specific sub-rows. We
+    map the blank's col0 평가요소 groups 1:1 to the MD 평가항목 (document order),
+    normalize each group to the MD ladder's level count via delete_row /
+    insert_row_by_clone (reshape ≠ regeneration — the original cells' formatting is
+    carried byte-for-byte), then splice each level's descriptor + 배점 in; the optional
+    세부 항목 column is collapsed to the first sub-block and blanked (no MD source).
+
+    Returns ``(data, filled, notes)``. ``filled`` is True only when EVERY group was
+    reconciled and written — a rubric whose group count ≠ MD item count, whose ladder
+    won't parse, or whose reshape fails is left byte-identical and reported (fail-closed
+    / honest-defer), so the caller keeps its NEEDS_REVIEW note."""
+    from hwpx.table_patch import fill_cells
+
+    items = [row for row in rub.rows if not row[0].startswith("기본점수")]
+    ladders = [_parse_level_ladder(it[1]) for it in items]
+    if not items or any(not L for L in ladders):
+        return data, False, [f"rubric ti={ti}: 채점기준 ladder unparseable for some 평가항목"]
+
+    _sp, tb, grid, rep = _grid_of(data, ti)
+    ph, base = _pf_bounds(tb, grid, rep)
+    if ph is None or base is None:
+        return data, False, [f"rubric ti={ti}: no 평가요소/기본점수 bounds for 채점기준 ladder"]
+    bat_col = rep.col_count - 1
+    desc_col = _pf_desc_col(tb, ph, base, bat_col)
+    has_sub = desc_col > 1
+    groups = _pf_groups(tb, ph, base)
+    if len(groups) != len(items):
+        return data, False, [f"rubric ti={ti}: {len(groups)} 평가요소 groups != {len(items)} MD 평가항목"]
+
+    # RESHAPE each group to its ladder's level count. Process LAST→FIRST so earlier
+    # (smaller-index) groups stay valid as later ones change row counts; re-locate the
+    # groups fresh before every edit (indices shift).
+    d = data
+    for gi in range(len(groups) - 1, -1, -1):
+        m = len(ladders[gi])
+        _sp, tb, grid, rep = _grid_of(d, ti)
+        ph2, base2 = _pf_bounds(tb, grid, rep)
+        gg = _pf_groups(tb, cast(int, ph2), cast(int, base2))
+        r0, h = gg[gi]
+        if has_sub:
+            d, _first_h, sub_sk = _reduce_to_first_subitem(d, ti, r0, h)
+            if sub_sk:
+                return data, False, [f"rubric ti={ti} group {gi}: {sub_sk[0]}"]
+            _sp, tb, grid, rep = _grid_of(d, ti)
+            ph2, base2 = _pf_bounds(tb, grid, rep)
+            r0, h = _pf_groups(tb, cast(int, ph2), cast(int, base2))[gi]
+        d, norm_sk = _normalize_ladder_group(d, ti, r0, h, m, desc_col, bat_col)
+        if norm_sk:
+            return data, False, [f"rubric ti={ti} group {gi}: {norm_sk[0]}"]
+
+    # FILL each normalized level row: descriptor + 배점, and blank the 세부 항목 cell.
+    _sp, tb, grid, rep = _grid_of(d, ti)
+    ph2, base2 = _pf_bounds(tb, grid, rep)
+    gg = _pf_groups(tb, cast(int, ph2), cast(int, base2))
+    cells: list[dict[str, Any]] = []
+    for gi, (r0, _h) in enumerate(gg):
+        for k, (desc, score) in enumerate(ladders[gi]):
+            r = r0 + k
+            dc = grid.get((r, desc_col))
+            if dc is not None:
+                cells.append({"table_index": ti, "row": dc.row, "col": dc.col, "text": desc, "max_lines": 4})
+            bc = grid.get((r, bat_col))
+            if bc is not None:
+                cells.append({"table_index": ti, "row": bc.row, "col": bc.col, "text": score, "max_lines": 1})
+        if has_sub:
+            sc = grid.get((r0, 1))
+            if sc is not None and sc.col == 1:
+                cells.append({"table_index": ti, "row": sc.row, "col": 1, "text": "", "max_lines": 1})
+    fr = fill_cells(d, cells)
+    return fr.data, True, [s.reason for s in fr.skipped]
+
+
+def _rubric_is_2022(data: bytes, ti: int) -> bool:
+    """A 2022-개정 rubric table leads its first row with '평가 영역명' (the 2015-개정
+    one leads with '교육과정성취기준')."""
+    from hwpx.table_patch import table_text
+    _sp, tb, grid, _rep = _grid_of(data, ti)
+    c0 = grid.get((0, 0))
+    return bool(c0) and table_text(tb[c0.start:c0.end]).strip().startswith("평가 영역명")
+
+
+def _item_label(row0: str) -> str:
+    """Clean a review rubric item's label cell for splicing (drop markdown emphasis)."""
+    return re.sub(r"\*\*(\d+)\*\*", r"\1", row0).replace("**", "").strip()
+
+
+def _std_level_map(achievement_std: list[list[str]]) -> dict[str, list[str]]:
+    """Map each 성취기준 code -> its ``[A, B, C, D, E]`` 성취수준 descriptors from the
+    review MD's §4가 table (row = ``[code+진술, A, B, C, D, E]``). Codes with fewer
+    than five descriptor columns are skipped (honest: no partial level fill)."""
+    out: dict[str, list[str]] = {}
+    for row in achievement_std:
+        if not row:
+            continue
+        m = _STD_CODE.search(row[0])
+        if m is None:
+            continue
+        levels = [c.strip() for c in row[1:6]]
+        if len(levels) == 5 and all(levels):
+            out[m.group(0)] = levels
+    return out
+
+
+def _fill_rubric_ae_levels(
+    ti: int, tb: bytes, grid, rep, rub: Rubric, std_levels: dict[str, list[str]],
+) -> tuple[list[dict[str, Any]], list[str]]:
+    """Address the A~E descriptor cells of a 2022-개정 rubric's 성취기준별 성취수준 block
+    with the review MD's real 성취수준 descriptors for the rubric's PRIMARY standard.
+
+    A block is a run of rows whose grade-label cell (the col immediately left of the
+    wide 서술 cell) holds 'A'..'E'; the blank ships the descriptors as a foreign sample
+    (통합사회/미술 프로젝트 prose). The blank can ship SEVERAL A~E blocks under one rubric
+    (one per sample standard). We locate every block after the '성취기준' label row and
+    fill the *i*-th block from the *i*-th referenced standard's review 성취수준 (the
+    PRIMARY -- first -- standard drives block 0), splicing that standard's A→col+1 …
+    E→col+5 descriptor into each grade row's 서술 cell. Standard codes come from
+    ``rub.standards`` (a ``~`` range contributes only its leading code); a block with
+    no matching standard is left untouched (honest -- no fabricated mapping).
+
+    Returns ``(cells, skipped)``: cell specs for :func:`fill_cells` and fail-closed
+    skip reasons (no A~E block, or a standard has no MD 성취수준 row). Only the 서술
+    descriptor cell of each grade row is addressed -- the grade label and the span-5
+    성취기준 leader are left untouched."""
+    from hwpx.table_patch import direct_table_cells, table_text
+
+    codes = _STD_CODE.findall(rub.standards or "")
+    if not codes:
+        return [], [f"rubric ti={ti}: no standard code in {rub.standards!r} for A~E levels"]
+
+    # '성취기준' label row bounds the block start; the next '평가 방법' row bounds its end.
+    std_label_row = next(
+        (r for r in range(rep.row_count)
+         if (c0 := grid.get((r, 0))) is not None
+         and table_text(tb[c0.start:c0.end]).replace(" ", "").strip() == "성취기준"),
+        None,
+    )
+    if std_label_row is None:
+        return [], [f"rubric ti={ti}: no '성취기준' label row to anchor A~E block"]
+    method_row = next(
+        (r for r in range(std_label_row + 1, rep.row_count)
+         if (c0 := grid.get((r, 0))) is not None
+         and "평가" in table_text(tb[c0.start:c0.end]) and "방법" in table_text(tb[c0.start:c0.end])),
+        rep.row_count,
+    )
+
+    # A grade cell is a direct 1x1 cell holding exactly one of 'A'..'E' in the block;
+    # its 서술 descriptor is the direct cell in the same row starting at grade.col+1.
+    grade_rows: list[tuple[str, int, int]] = []  # (grade, row, grade_col)
+    for c in sorted(direct_table_cells(tb), key=lambda c: c.row):
+        if not (std_label_row < c.row < method_row):
+            continue
+        t = table_text(tb[c.start:c.end]).strip()
+        if t in ("A", "B", "C", "D", "E") and c.col_span == 1:
+            grade_rows.append((t, c.row, c.col))
+    if not grade_rows:
+        return [], [f"rubric ti={ti}: no A~E grade rows in 성취기준별 성취수준 block"]
+
+    # split into contiguous A→…→E blocks (a new 'A' starts a new block); the blank can
+    # ship several sample blocks under one rubric (one per sample standard).
+    blocks: list[list[tuple[str, int, int]]] = []
+    for g, r, col in grade_rows:
+        if g == "A" or not blocks:
+            blocks.append([])
+        blocks[-1].append((g, r, col))
+
+    cells: list[dict[str, Any]] = []
+    skipped: list[str] = []
+    for bi, block in enumerate(blocks):
+        # map the i-th block to the i-th referenced standard; the primary standard
+        # drives block 0. A block past the referenced standards is left untouched.
+        if bi >= len(codes):
+            skipped.append(f"rubric ti={ti}: A~E block {bi} has no {bi}-th referenced standard -- left as-is")
+            continue
+        levels = std_levels.get(codes[bi])
+        if levels is None:
+            skipped.append(f"rubric ti={ti}: standard {codes[bi]} (block {bi}) not in review 성취수준 map")
+            continue
+        lvl_by_grade = dict(zip("ABCDE", levels))
+        for g, r, gcol in block:
+            desc = grid.get((r, gcol + 1))
+            if desc is None or desc.col <= gcol:
+                skipped.append(f"rubric ti={ti}: grade {g} row {r} has no 서술 cell right of col {gcol}")
+                continue
+            text = lvl_by_grade.get(g)
+            if not text:
+                continue
+            # address the 서술 cell by its own top-left logical position (merge-safe).
+            cells.append({"table_index": ti, "row": desc.row, "col": desc.col,
+                          "text": text, "max_lines": 4})
+    return cells, skipped
+
+
+def _locate_rubric_2022_rows(tb: bytes, grid: Any, rep: Any) -> tuple[int | None, int | None, int | None, int | None]:
+    """Locate the 수행과제 / 성취기준-label / 평가요소 header / 기본점수 rows."""
+
+    from hwpx.table_patch import table_text
+
+    task_row = std_label_row = ph = base = None
+    for r in range(rep.row_count):
+        c0 = grid.get((r, 0))
+        if c0 is None:
+            continue
+        t0 = table_text(tb[c0.start:c0.end]).strip()
+        t0c = t0.replace(" ", "")
+        if task_row is None and t0c == "수행과제":
+            task_row = r
+        if std_label_row is None and t0c == "성취기준":
+            std_label_row = r
+        if t0c == "평가요소":
+            ph = r
+        if base is None and "기본점수" in t0:
+            base = r
+    return task_row, std_label_row, ph, base
+
+
+def _rubric_2022_header_cells(ti: int, rub: Rubric) -> list[dict[str, Any]]:
+    # header: title / points -- addressed by adjacent label (geometry-free)
+    return [
+        {"table_index": ti, "cell_anchor": {"label": "평가 영역명", "dir": "right"},
+         "text": rub.title, "max_lines": 2},
+        {"table_index": ti, "cell_anchor": {"label": "영역 만점", "dir": "right"},
+         "text": f"{rub.points}점", "max_lines": 1},
+    ]
+
+
+def _rubric_2022_standards_method_row(tb: bytes, grid: Any, rep: Any, std_label_row: int) -> int:
+    from hwpx.table_patch import table_text
+
+    return next(
+        (
+            r for r in range(std_label_row + 1, rep.row_count)
+            if (c0 := grid.get((r, 0))) is not None
+            and "평가" in table_text(tb[c0.start:c0.end])
+            and "방법" in table_text(tb[c0.start:c0.end])
+        ),
+        rep.row_count,
+    )
+
+
+def _rubric_2022_standards_leader_rows(tb: bytes, std_label_row: int, method_row: int) -> list[int]:
+    from hwpx.table_patch import direct_table_cells
+
+    return [
+        c.row for c in sorted(direct_table_cells(tb), key=lambda c: c.row)
+        if c.col == 0 and std_label_row < c.row < method_row and c.row_span >= 2
+    ]
+
+
+def _rubric_2022_standards_cells(
+    ti: int, rub: Rubric, tb: bytes, grid: Any, rep: Any, std_label_row: int | None
+) -> tuple[list[dict[str, Any]], list[str]]:
+    """성취기준 codes: the '성취기준' LABEL row's right neighbour is the '성취기준별
+    성취수준' A~E banner (a section header, NOT a value slot) -- so we write the
+    codes into the A~E block's col-0 LEADER cell(s) instead (the merged cells that
+    span the A..E rows and currently carry the blank's foreign sample codes).
+    The blank can ship SEVERAL sample 성취기준 blocks under one rubric (each its own
+    A~E leader); the MD supplies one codes string per rubric, so we overwrite EVERY
+    leader between the 성취기준 label row and the next 평가 방법 section, leaving no
+    foreign code behind (the first carries the codes; the rest are blanked)."""
+
+    cells: list[dict[str, Any]] = []
+    skipped: list[str] = []
+    if rub.standards and std_label_row is not None:
+        method_row = _rubric_2022_standards_method_row(tb, grid, rep, std_label_row)
+        leaders = _rubric_2022_standards_leader_rows(tb, std_label_row, method_row)
+        if leaders:
+            for j, lr in enumerate(leaders):
+                cells.append({"table_index": ti, "row": lr, "col": 0,
+                              "text": rub.standards if j == 0 else "", "max_lines": 4})
+        else:
+            skipped.append(f"rubric ti={ti}: no A~E 성취기준 block leader to place codes")
+    return cells, skipped
+
+
+def _rubric_2022_task_cells(
+    ti: int, rub: Rubric, grid: Any, rep: Any, task_row: int | None
+) -> list[dict[str, Any]]:
+    """수행과제: the blank ships a foreign sample task (통사 인권 문제 …). The MD has no
+    dedicated 수행과제 string, so synthesise a faithful one from THIS area's 평가항목
+    labels (the tasks the rubric actually scores) -- replaces the sample subject."""
+
+    cells: list[dict[str, Any]] = []
+    if task_row is not None:
+        items = [_item_label(row[0]) for row in rub.rows if not row[0].startswith("기본점수")]
+        if items:
+            # the value cell is the FIRST cell to the right of the 수행과제 label's own
+            # col-span (the 45점 rubric's label spans cols 0-1, so grid[(task_row, 1)]
+            # would be the label itself -- start past it, not at a fixed col 1).
+            label_cell = grid.get((task_row, 0))
+            start_col = (label_cell.col + label_cell.col_span) if label_cell is not None else 1
+            task_cell = next((grid.get((task_row, cc)) for cc in range(start_col, rep.col_count)
+                              if grid.get((task_row, cc)) is not None), None)
+            if task_cell is not None:
+                cells.append({"table_index": ti, "row": task_cell.row, "col": task_cell.col,
+                              "text": "∙" + " ∙".join(items), "max_lines": 3})
+    return cells
+
+
+def _rubric_2022_element_leader_rows(tb: bytes, ph: int, base: int) -> list[int]:
+    from hwpx.table_patch import direct_table_cells
+
+    seen: set[tuple[int, int]] = set()
+    leaders: list[int] = []
+    for c in sorted(direct_table_cells(tb), key=lambda c: c.row):
+        if c.col == 0 and ph < c.row < base and c.row_span >= 2 and (c.start, c.end) not in seen:
+            seen.add((c.start, c.end))
+            leaders.append(c.row)
+    return leaders
+
+
+def _rubric_2022_element_label_cells(
+    ti: int, rub: Rubric, leaders: list[int]
+) -> tuple[list[dict[str, Any]], list[str]]:
+    items = [_item_label(row[0]) for row in rub.rows if not row[0].startswith("기본점수")]
+    cells: list[dict[str, Any]] = []
+    skipped: list[str] = []
+    if leaders and items:
+        k = len(leaders)
+        packed = items if len(items) <= k else items[:k - 1] + [" / ".join(items[k - 1:])]
+        for row, label in zip(leaders, packed):
+            cells.append({"table_index": ti, "row": row, "col": 0, "text": label, "max_lines": 3})
+    elif items:
+        skipped.append(f"rubric ti={ti}: no 평가요소 leader cells to place {len(items)} items")
+    return cells, skipped
+
+
+def _rubric_2022_base_score_cells(
+    ti: int, rub: Rubric, grid: Any, rep: Any, base: int, lastcol: int
+) -> list[dict[str, Any]]:
+    _base_label, base_score, _long_label, long_score = _base_scores(rub.rows)
+    cells: list[dict[str, Any]] = []
+    if base_score and grid.get((base, lastcol)):
+        cells.append({"table_index": ti, "row": base, "col": lastcol, "text": base_score, "max_lines": 1})
+    if long_score and base + 1 < rep.row_count and grid.get((base + 1, lastcol)):
+        cells.append({"table_index": ti, "row": base + 1, "col": lastcol, "text": long_score, "max_lines": 1})
+    return cells
+
+
+def _rubric_2022_leader_and_base_cells(
+    ti: int, rub: Rubric, tb: bytes, grid: Any, rep: Any, ph: int | None, base: int | None, lastcol: int
+) -> tuple[list[dict[str, Any]], list[str]]:
+    """평가요소 수행수준 leader cells (col0 merged cells strictly inside (ph, base))
+    plus the 기본점수 / 장기 미인정 배점 (right-most column of the two base rows)."""
+
+    if ph is None or base is None:
+        return [], [f"rubric ti={ti}: could not bound 평가요소 region (ph={ph}, base={base})"]
+    leaders = _rubric_2022_element_leader_rows(tb, ph, base)
+    label_cells, skipped = _rubric_2022_element_label_cells(ti, rub, leaders)
+    base_cells = _rubric_2022_base_score_cells(ti, rub, grid, rep, base, lastcol)
+    return label_cells + base_cells, skipped
+
+
+def _fill_rubric_2022(data: bytes, ti: int, rub: Rubric,
+                      std_levels: dict[str, list[str]] | None = None) -> tuple[bytes, list[str]]:
+    """Fill ONE 2022-개정 수행평가 세부기준 rubric table (평가 영역명 layout) from a
+    review rubric, byte-preserving. These tables are heterogeneous rich grids
+    (수행과제 / 성취기준 A~E block / 평가방법 / 학생 유의사항 / 평가요소 수행수준 blocks /
+    기본점수·장기미인정). We overwrite the cleanly-addressable label cells the scorer
+    measures -- the 평가 영역명 (title), 영역 만점 (points), 성취기준 (codes), the 성취
+    기준별 성취수준 A~E descriptors (from the primary standard's review 성취수준, via
+    ``std_levels``), the 평가요소 수행수준 leader cells (the review 평가항목 labels), the
+    수행과제 task, and the 기본점수 / 장기 미인정 배점 -- AND reshape+fill the 수행수준
+    채점기준 descriptor ladder (:func:`_fill_rubric_2022_ladder`): each 평가요소 group is
+    normalized (delete_row / insert_row_by_clone -- reshape, NOT regeneration) to the
+    MD ladder's level count, then each level's descriptor + 배점 is spliced in. A rubric
+    whose ladder can't be reconciled cleanly is left as blank sample and reported
+    (NEEDS_REVIEW, fail-closed) rather than corrupted."""
+    from hwpx.table_patch import fill_cells
+
+    skipped: list[str] = []
+
+    # STEP 0 (structure+content): reshape and fill the 수행수준 채점기준 ladder FIRST --
+    # it deletes/clones rows, so the label-cell locations below must be found on the
+    # reshaped grid. Fail-closed: on any reconciliation failure the ladder pass returns
+    # the input bytes unchanged and its notes carry the reason (a NEEDS_REVIEW note is
+    # re-emitted at the end when ``ladder_filled`` is False).
+    data, ladder_filled, ladder_notes = _fill_rubric_2022_ladder(data, ti, rub)
+    skipped.extend(ladder_notes)
+
+    _sp, tb, grid, rep = _grid_of(data, ti)
+    lastcol = rep.col_count - 1
+
+    task_row, std_label_row, ph, base = _locate_rubric_2022_rows(tb, grid, rep)
+
+    cells: list[dict[str, Any]] = _rubric_2022_header_cells(ti, rub)
+
+    standards_cells, standards_sk = _rubric_2022_standards_cells(ti, rub, tb, grid, rep, std_label_row)
+    cells.extend(standards_cells)
+    skipped.extend(standards_sk)
+
+    # 성취기준별 성취수준 A~E descriptors: the blank ships the 서술 cells as a foreign
+    # sample (통합사회/미술 프로젝트 prose). Splice the primary standard's review 성취수준
+    # into each grade row's 서술 cell (fail-closed: reported, never corrupted).
+    if std_levels:
+        ae_cells, ae_sk = _fill_rubric_ae_levels(ti, tb, grid, rep, rub, std_levels)
+        cells.extend(ae_cells)
+        skipped.extend(ae_sk)
+
+    cells.extend(_rubric_2022_task_cells(ti, rub, grid, rep, task_row))
+
+    leader_base_cells, leader_base_sk = _rubric_2022_leader_and_base_cells(
+        ti, rub, tb, grid, rep, ph, base, lastcol
+    )
+    cells.extend(leader_base_cells)
+    skipped.extend(leader_base_sk)
+
+    fr = fill_cells(data, cells)
+    skipped.extend(s.reason for s in fr.skipped)
+    # honest-defer (no-silent-true): re-emit a NEEDS_REVIEW note ONLY when the 수행수준
+    # 채점기준 descriptor ladder could NOT be reconciled byte-preservingly (STEP 0
+    # returned ladder_filled=False -- e.g. group count ≠ MD item count, or a group's
+    # clean-row shape resisted normalization). When the ladder WAS filled, the note is
+    # omitted so the caller no longer reads this rubric as carrying sample prose.
+    if not ladder_filled:
+        skipped.append(f"rubric ti={ti}: NEEDS_REVIEW — 수행수준 채점기준 descriptor ladder "
+                       "left as blank sample (no byte-preserving map to review score ladder)")
+    return fr.data, skipped
+
+
+def _fill_rubric_headings(data: bytes, content: EvalPlanContent) -> tuple[bytes, list[str]]:
+    """Rewrite each 2022-개정 rubric's ordinal heading paragraph -- the '가. 인권 문제
+    해결 프로젝트' / '나. 인포그래픽 디자인' line that sits OUTSIDE the table, directly
+    before its '평가 영역명' paragraph -- to '<ordinal>. <review 영역명>', byte-preserving
+    (paragraph text splice only). One heading per rubric, matched in document order to
+    ``content.rubrics``; a heading with no matching rubric is left untouched (honest --
+    no fabricated title). Located by structure (an ordinal-marker paragraph immediately
+    followed by '평가 영역명'), so it never touches an in-table cell."""
+    from hwpx.patch import paragraph_chunks, paragraph_patch
+    from hwpx.table_patch import section_parts, table_text
+
+    skipped: list[str] = []
+    sections = section_parts(data)
+    if not sections or not content.rubrics:
+        return data, skipped
+    sp = min(sections)
+    section = sections[sp]
+    texts = [table_text(chunk).strip() for chunk in paragraph_chunks(section)]
+    heads = [i for i in range(len(texts) - 1)
+             if re.match(r"^[가나다라마바사아자차카타파하]\.(\s|$)", texts[i]) and texts[i + 1] == "평가 영역명"]
+    patches: list[dict[str, Any]] = []
+    for k, pidx in enumerate(heads):
+        if k >= len(content.rubrics):
+            break
+        patches.append({"section_path": sp, "paragraph_index": pidx,
+                        "text": f"{_ORDINALS[k]}. {content.rubrics[k].title}"})
+    if len(heads) != len(content.rubrics):
+        skipped.append(f"rubric headings: {len(heads)} ordinal headings vs {len(content.rubrics)} rubrics")
+    if not patches:
+        return data, skipped
+    pres = paragraph_patch(data, patches)
+    skipped.extend(s.reason for s in pres.skipped)
+    return pres.data, skipped
+
+
+# --------------------------------------------------------------------------- #
+# Detailed §7 fill (current 평가계획 MD) -- per-평가요소 배점 ladders. Reshapes the
+# blank rubric's 평가요소 ladder to the MD's element count (grow / shrink the col0
+# vertical-merge blocks) and splices every observable criterion + 배점 verbatim.
+# Every target is located by geometry (label text / grid spans), reusable across the
+# form family, and every edit goes through the byte-preserving table_patch primitives.
+# --------------------------------------------------------------------------- #
+
+def _row_label_value(grid: Any, rep: Any, tb: bytes, matches) -> tuple[int | None, Any, Any]:
+    """(row, label_cell, value_cell) for the first cell whose text satisfies *matches*;
+    value_cell is the grid cell immediately to its right (spanning-aware)."""
+    from hwpx.table_patch import table_text
+    for r in range(rep.row_count):
+        for c in range(rep.col_count):
+            cell = grid.get((r, c))
+            if cell is None or cell.row != r or cell.col != c:
+                continue
+            if matches(table_text(tb[cell.start:cell.end])):
+                return r, cell, grid.get((r, c + cell.col_span))
+    return None, None, None
+
+
+def _fill_2022_header(data: bytes, ti: int, rub: Rubric) -> tuple[bytes, list[str]]:
+    """Overwrite the header value cells (평가 영역명 / 영역 만점 / 학기 / 수행과제 / 학생
+    유의사항) — located by their label, so it works on both the clean template and the
+    donor samples that survive structural pruning."""
+    from hwpx.table_patch import fill_cells
+    _sp, tb, grid, rep = _grid_of(data, ti)
+
+    def _n(t: str) -> str:
+        return t.replace(" ", "").strip()
+
+    specs = [
+        (lambda t: _n(t) == "평가영역명", rub.title, 3),
+        (lambda t: _n(t) == "영역만점", f"{rub.points}점", 1),
+        (lambda t: _n(t) == "학기", "2학기", 1),
+        (lambda t: _n(t) == "수행과제", rub.task, 6),
+        (lambda t: _n(t) == "학생유의사항", rub.student_notes, 6),
+    ]
+    cells: list[dict[str, Any]] = []
+    for pred, val, ml in specs:
+        if not val:
+            continue
+        _r, _lc, vc = _row_label_value(grid, rep, tb, pred)
+        if vc is not None:
+            cells.append({"table_index": ti, "row": vc.row, "col": vc.col, "text": val, "max_lines": ml})
+    # 평가 방법: the donor sample's checkbox grid carries the WRONG subject's ☑ marks.
+    # Overwrite the value cell with the MD's method (its ☑ list) and blank the second
+    # checkbox row so no foreign check survives.
+    if rub.method:
+        _mr, _mlc, mvc = _row_label_value(
+            grid, rep, tb, lambda t: _n(t) == "평가방법"
+        )
+        if mvc is not None:
+            cells.append({"table_index": ti, "row": mvc.row, "col": mvc.col, "text": rub.method, "max_lines": 2})
+            nxt = grid.get((mvc.row + 1, mvc.col))
+            if nxt is not None and nxt.row == mvc.row + 1:
+                cells.append({"table_index": ti, "row": nxt.row, "col": nxt.col, "text": "", "max_lines": 1})
+    fr = fill_cells(data, cells)
+    return fr.data, [s.reason for s in fr.skipped]
+
+
+def _delete_2022_ae_block(data: bytes, ti: int) -> tuple[bytes, list[str]]:
+    """Delete the 성취기준 + 성취기준별 성취수준 (A~E) block. The current MD gives no
+    per-area A~E descriptors (it refers to §4), so keeping the sample rows would show
+    empty/foreign A~E — dropping them is the honest render. Bounds: the '성취기준' label
+    row through the row before '평가 방법'."""
+    from hwpx.table_patch import apply_table_ops, table_text
+    _sp, tb, grid, rep = _grid_of(data, ti)
+    ae_start = method_row = None
+    for r in range(rep.row_count):
+        c0 = grid.get((r, 0))
+        if c0 is None or c0.row != r:
+            continue
+        t = table_text(tb[c0.start:c0.end]).replace(" ", "").strip()
+        if ae_start is None and t == "성취기준":
+            ae_start = r
+        if t == "평가방법":
+            method_row = r
+            break
+    if ae_start is None or method_row is None or method_row <= ae_start:
+        return data, [f"rubric ti={ti}: A~E block bounds not found (성취기준={ae_start}, 평가방법={method_row})"]
+    rows = list(range(ae_start, method_row))
+    res = apply_table_ops(data, [{"op": "delete_row", "table_index": ti, "rows": sorted(rows, reverse=True)}])
+    if not res.ok:
+        return data, [f"rubric ti={ti}: delete A~E block: {[s.reason for s in res.skipped]}"]
+    return res.data, []
+
+
+def _grow_ladder_groups(data: bytes, ti: int, n: int) -> tuple[bytes, list[str]]:
+    """Reshape the col0 평가요소 ladder to exactly *n* groups. Clones the shortest clean
+    group block (``insert_block_by_clone`` — copies formatting byte-for-byte) to grow,
+    deletes whole surplus blocks to shrink. Fail-closed."""
+    from hwpx.table_patch import apply_table_ops
+    _sp, tb, grid, rep = _grid_of(data, ti)
+    ph, base = _pf_bounds(tb, grid, rep)
+    if ph is None or base is None:
+        return data, [f"rubric ti={ti}: no 평가요소/기본점수 bounds for ladder growth"]
+    groups = _pf_groups(tb, ph, base)
+    g = len(groups)
+    if g == n:
+        return data, []
+    if g < n:
+        r0, h = min(groups, key=lambda gh: gh[1])       # clone the shortest block
+        res = apply_table_ops(data, [{"op": "insert_block_by_clone", "table_index": ti,
+                                      "ref_rows": [r0, r0 + h - 1], "count": n - g}])
+        if not res.ok:
+            return data, [f"rubric ti={ti}: grow ladder to {n} groups: {[s.reason for s in res.skipped]}"]
+        return res.data, []
+    del_rows: list[int] = []
+    for r0, h in groups[n:]:
+        del_rows.extend(range(r0, r0 + h))
+    res = apply_table_ops(data, [{"op": "delete_row", "table_index": ti,
+                                  "rows": sorted(set(del_rows), reverse=True)}])
+    if not res.ok:
+        return data, [f"rubric ti={ti}: shrink ladder to {n} groups: {[s.reason for s in res.skipped]}"]
+    return res.data, []
+
+
+def _fill_2022_ladder_detailed(data: bytes, ti: int, items: list[RubricItem]) -> tuple[bytes, bool, list[str]]:
+    """Normalize each 평가요소 group to its element's level count and splice the
+    descriptor + 배점 of every level (verbatim from the MD's structured levels — never
+    the lossy '/'-joined form). ``_grow_ladder_groups`` must have made the group count
+    equal to ``len(items)`` first. Reuses the byte-preserving group reshape helpers."""
+    from hwpx.table_patch import fill_cells
+    _sp, tb, grid, rep = _grid_of(data, ti)
+    ph, base = _pf_bounds(tb, grid, rep)
+    if ph is None or base is None:
+        return data, False, [f"rubric ti={ti}: no ladder bounds"]
+    bat_col = rep.col_count - 1
+    desc_col = _pf_desc_col(tb, ph, base, bat_col)
+    has_sub = desc_col > 1
+    groups = _pf_groups(tb, ph, base)
+    if len(groups) != len(items):
+        return data, False, [f"rubric ti={ti}: {len(groups)} 평가요소 groups != {len(items)} MD elements"]
+
+    d = data
+    for gi in range(len(groups) - 1, -1, -1):
+        m = max(1, len(items[gi].levels))
+        _sp, tb, grid, rep = _grid_of(d, ti)
+        ph2, base2 = _pf_bounds(tb, grid, rep)
+        r0, h = _pf_groups(tb, cast(int, ph2), cast(int, base2))[gi]
+        if has_sub:
+            d, _fh, sub_sk = _reduce_to_first_subitem(d, ti, r0, h)
+            if sub_sk:
+                return data, False, [f"rubric ti={ti} group {gi}: {sub_sk[0]}"]
+            _sp, tb, grid, rep = _grid_of(d, ti)
+            ph2, base2 = _pf_bounds(tb, grid, rep)
+            r0, h = _pf_groups(tb, cast(int, ph2), cast(int, base2))[gi]
+        d, norm_sk = _normalize_ladder_group(d, ti, r0, h, m, desc_col, bat_col)
+        if norm_sk:
+            return data, False, [f"rubric ti={ti} group {gi}: {norm_sk[0]}"]
+
+    _sp, tb, grid, rep = _grid_of(d, ti)
+    ph2, base2 = _pf_bounds(tb, grid, rep)
+    gg = _pf_groups(tb, cast(int, ph2), cast(int, base2))
+    cells: list[dict[str, Any]] = []
+    for gi, (r0, _h) in enumerate(gg):
+        lead = grid.get((r0, 0))
+        if lead is not None:
+            cells.append({"table_index": ti, "row": lead.row, "col": lead.col,
+                          "text": items[gi].name, "max_lines": 4})
+        for k, (desc, score) in enumerate(items[gi].levels):
+            r = r0 + k
+            dc = grid.get((r, desc_col))
+            if dc is not None:
+                cells.append({"table_index": ti, "row": dc.row, "col": dc.col, "text": desc, "max_lines": 6})
+            bc = grid.get((r, bat_col))
+            if bc is not None and score:
+                cells.append({"table_index": ti, "row": bc.row, "col": bc.col, "text": score, "max_lines": 1})
+        if has_sub:
+            sc = grid.get((r0, 1))
+            if sc is not None and sc.col == 1:
+                cells.append({"table_index": ti, "row": sc.row, "col": 1, "text": "", "max_lines": 1})
+    fr = fill_cells(d, cells)
+    return fr.data, True, [s.reason for s in fr.skipped]
+
+
+def _fill_2022_base_scores(data: bytes, ti: int, rub: Rubric) -> tuple[bytes, list[str]]:
+    """Fill the 기본점수 / 장기 미인정 결석자 배점 cells (right-most column). The row
+    labels already carry the form's standard text, so only the 배점 is spliced. 장기
+    미인정 rows also contain '기본점수' (−1점), so match the more specific label first."""
+    from hwpx.table_patch import fill_cells, table_text
+    _sp, tb, grid, rep = _grid_of(data, ti)
+    bat_col = rep.col_count - 1
+    base_row = long_row = None
+    for r in range(rep.row_count):
+        c0 = grid.get((r, 0))
+        if c0 is None or c0.row != r:
+            continue
+        t = table_text(tb[c0.start:c0.end])
+        if "장기 미인정" in t or "장기미인정" in t:
+            long_row = r
+        elif "기본점수" in t:
+            base_row = r
+    cells: list[dict[str, Any]] = []
+    for row, score in ((base_row, rub.base_score), (long_row, rub.long_score)):
+        if row is None or not score:
+            continue
+        bc = grid.get((row, bat_col))
+        if bc is not None:
+            cells.append({"table_index": ti, "row": bc.row, "col": bc.col, "text": score, "max_lines": 1})
+    fr = fill_cells(data, cells)
+    return fr.data, [s.reason for s in fr.skipped]
+
+
+def _fill_rubric_detailed_2022(data: bytes, ti: int, rub: Rubric) -> tuple[bytes, bool, list[str]]:
+    """Fill ONE 2022-개정 (평가 영역명) rubric with a detailed area's content: header
+    values, drop the A~E block, grow the 평가요소 ladder to the element count, splice
+    every level's criterion + 배점, and the 기본점수 배점. Returns (data, ladder_filled,
+    notes)."""
+    notes: list[str] = []
+    data, n = _fill_2022_header(data, ti, rub)
+    notes += n
+    data, n = _delete_2022_ae_block(data, ti)
+    notes += n
+    items = rub.items
+    data, n = _grow_ladder_groups(data, ti, len(items))
+    notes += n
+    data, filled, n = _fill_2022_ladder_detailed(data, ti, items)
+    notes += n
+    data, n = _fill_2022_base_scores(data, ti, rub)
+    notes += n
+    data = _prune_header_empty_bullets(data, ti)
+    return data, filled, notes
+
+
+def _split_criteria(criteria: str) -> tuple[str, str, str]:
+    """Split a 평가기준(상/중/하) bullet ('상=… ／ 중=… ／ 하=…') into its three
+    descriptors (verbatim, '' for any absent level)."""
+    out = {}
+    for key in ("상", "중", "하"):
+        m = re.search(rf"{key}\s*=\s*(.+?)(?=\s*[／/]\s*[상중하]\s*=|$)", criteria or "")
+        out[key] = _strip_inline_md(m.group(1)) if m else ""
+    return out["상"], out["중"], out["하"]
+
+
+def _3hak_ladder_bounds(tb: bytes, grid: Any, rep: Any) -> tuple[int | None, int | None]:
+    """(영역(만점) header row, 기본점수 row) of a 2015-개정 rubric ladder."""
+    from hwpx.table_patch import table_text
+    hr = br = None
+    for r in range(rep.row_count):
+        c0 = grid.get((r, 0))
+        if c0 is not None and c0.row == r:
+            t = table_text(tb[c0.start:c0.end]).replace(" ", "")
+            if "영역" in t and "만점" in t:
+                hr = r
+        c1 = grid.get((r, 1))
+        if c1 is not None and c1.row == r and br is None and "기본점수" in table_text(tb[c1.start:c1.end]):
+            br = r
+    return hr, br
+
+
+def _fill_3hak_header(data: bytes, ti: int, rub: Rubric) -> tuple[bytes, list[str]]:
+    """Fill the 교육과정성취기준 codes, the 평가기준 상/중/하 descriptors, and 학생 유의
+    사항 — located by label geometry."""
+    from hwpx.table_patch import fill_cells
+
+    def _n(t: str) -> str:
+        return t.replace(" ", "").strip()
+
+    _sp, tb, grid, rep = _grid_of(data, ti)
+    sang, jung, ha = _split_criteria(rub.criteria)
+    specs = [
+        (lambda t: _n(t) in ("교육과정성취기준", "성취기준"), rub.standards, 3),
+        (lambda t: _n(t) == "상", sang, 4),
+        (lambda t: _n(t) == "중", jung, 4),
+        (lambda t: _n(t) == "하", ha, 4),
+        (lambda t: _n(t) == "학생유의사항", rub.student_notes, 4),
+    ]
+    cells: list[dict[str, Any]] = []
+    for pred, val, ml in specs:
+        if not val:
+            continue
+        _r, _lc, vc = _row_label_value(grid, rep, tb, pred)
+        if vc is not None:
+            cells.append({"table_index": ti, "row": vc.row, "col": vc.col, "text": val, "max_lines": ml})
+    fr = fill_cells(data, cells)
+    return fr.data, [s.reason for s in fr.skipped]
+
+
+def _fill_3hak_base_scores(data: bytes, ti: int, rub: Rubric) -> tuple[bytes, list[str]]:
+    from hwpx.table_patch import fill_cells, table_text
+    _sp, tb, grid, rep = _grid_of(data, ti)
+    bat_col = rep.col_count - 1
+    base_row = long_row = None
+    for r in range(rep.row_count):
+        c1 = grid.get((r, 1))
+        if c1 is None or c1.row != r:
+            continue
+        t = table_text(tb[c1.start:c1.end])
+        if "장기 미인정" in t or "장기미인정" in t:
+            long_row = r
+        elif "기본점수" in t:
+            base_row = r
+    cells: list[dict[str, Any]] = []
+    for row, score in ((base_row, rub.base_score), (long_row, rub.long_score)):
+        if row is None or not score:
+            continue
+        bc = grid.get((row, bat_col))
+        if bc is not None:
+            cells.append({"table_index": ti, "row": bc.row, "col": bc.col, "text": score, "max_lines": 1})
+    fr = fill_cells(data, cells)
+    return fr.data, [s.reason for s in fr.skipped]
+
+
+def _build_3hak_ladder(data: bytes, ti: int, rub: Rubric) -> tuple[bytes, bool, list[str]]:
+    """Reshape the 5-column 영역(만점)|평가항목|평가요소|채점 기준|배점 ladder to one physical
+    row per MD level, then subdivide the single 평가요소 merge into per-element blocks and
+    the 평가항목 merge into per-세부영역 blocks (``split_cell_vertical``, byte-preserving).
+    Leaders land on each block's top row; 채점 기준 + 배점 land on every level row."""
+    from hwpx.table_patch import apply_table_ops
+
+    subareas = [(sa.label, sa.points, [it for it in sa.items if not it.subtotal])
+                for sa in rub.subareas]
+    subareas = [(lbl, pts, its) for lbl, pts, its in subareas if its]
+    if not subareas:
+        return data, False, [f"rubric ti={ti}: 3학년 rubric has no scored elements"]
+
+    flat: list[tuple[str, str]] = []
+    item_sizes: list[int] = []
+    subarea_sizes: list[int] = []
+    item_leaders: list[tuple[int, str]] = []
+    subarea_leaders: list[tuple[int, str]] = []
+    off = 0
+    for lbl, pts, its in subareas:
+        sa_start, sa_total = off, 0
+        for it in its:
+            levels = it.levels or [("", "")]
+            item_leaders.append((off, it.name))
+            item_sizes.append(len(levels))
+            flat.extend(levels)
+            off += len(levels)
+            sa_total += len(levels)
+        subarea_leaders.append((sa_start, f"{lbl} ({pts}점)" if lbl else ""))
+        subarea_sizes.append(sa_total)
+    n = off
+
+    _sp, tb, grid, rep = _grid_of(data, ti)
+    hr, br = _3hak_ladder_bounds(tb, grid, rep)
+    if hr is None or br is None:
+        return data, False, [f"rubric ti={ti}: no 영역(만점)/기본점수 ladder bounds"]
+    body0 = cast(int, hr) + 1
+    cur = br - body0
+    # Grow / shrink the body to n rows. Clone a COVERED body row (body0+1): its cells are
+    # rowSpan==1 (채점 기준·배점) while col0/1/2 merges span across it and auto-extend.
+    if n > cur:
+        res = apply_table_ops(data, [{"op": "insert_row_by_clone", "table_index": ti,
+                                      "ref_row": body0 + 1, "count": n - cur}])
+        if not res.ok:
+            return data, False, [f"rubric ti={ti}: grow ladder to {n} rows: {[s.reason for s in res.skipped]}"]
+        data = res.data
+    elif n < cur:
+        res = apply_table_ops(data, [{"op": "delete_row", "table_index": ti,
+                                      "rows": list(range(body0 + n, br))}])
+        if not res.ok:
+            return data, False, [f"rubric ti={ti}: shrink ladder to {n} rows: {[s.reason for s in res.skipped]}"]
+        data = res.data
+
+    # Subdivide 평가요소 (col2) per element and 평가항목 (col1) per 세부영역.
+    for col, sizes in ((2, item_sizes), (1, subarea_sizes)):
+        if len(sizes) > 1:
+            res = apply_table_ops(data, [{"op": "split_cell_vertical", "table_index": ti,
+                                          "row": body0, "col": col, "sizes": sizes}])
+            if not res.ok:
+                return data, False, [f"rubric ti={ti}: split col{col} {sizes}: {[s.reason for s in res.skipped]}"]
+            data = res.data
+
+    from hwpx.table_patch import fill_cells
+    _sp, tb, grid, rep = _grid_of(data, ti)
+    hr, _br = _3hak_ladder_bounds(tb, grid, rep)
+    body0 = cast(int, hr) + 1
+    bat_col = rep.col_count - 1
+    cells: list[dict[str, Any]] = []
+    c0 = grid.get((body0, 0))
+    if c0 is not None:
+        cells.append({"table_index": ti, "row": c0.row, "col": 0,
+                      "text": f"{rub.title}({rub.points}점)", "max_lines": 4})
+    for roff, lbl in subarea_leaders:
+        c = grid.get((body0 + roff, 1))
+        if c is not None and lbl:
+            cells.append({"table_index": ti, "row": c.row, "col": 1, "text": lbl, "max_lines": 4})
+    for roff, name in item_leaders:
+        c = grid.get((body0 + roff, 2))
+        if c is not None:
+            cells.append({"table_index": ti, "row": c.row, "col": 2, "text": name, "max_lines": 4})
+    for k, (desc, score) in enumerate(flat):
+        c3 = grid.get((body0 + k, 3))
+        if c3 is not None:
+            cells.append({"table_index": ti, "row": c3.row, "col": c3.col, "text": desc, "max_lines": 6})
+        c4 = grid.get((body0 + k, bat_col))
+        if c4 is not None and score:
+            cells.append({"table_index": ti, "row": c4.row, "col": c4.col, "text": score, "max_lines": 1})
+    fr = fill_cells(data, cells)
+    return fr.data, True, [s.reason for s in fr.skipped]
+
+
+def _fill_rubric_detailed_3hak(
+    data: bytes, ti: int, rub: Rubric, content: EvalPlanContent
+) -> tuple[bytes, bool, list[str]]:
+    """Fill ONE 2015-개정 (교육과정성취기준) rubric with a detailed area's content: header
+    (성취기준 / 평가기준 상·중·하 / 학생 유의사항), the nested 배점 ladder, and the 기본점수
+    배점. Returns (data, ladder_filled, notes)."""
+    notes: list[str] = []
+    data, n = _fill_3hak_header(data, ti, rub)
+    notes += n
+    data, ok, n = _build_3hak_ladder(data, ti, rub)
+    notes += n
+    data, n = _fill_3hak_base_scores(data, ti, rub)
+    notes += n
+    data = _prune_header_empty_bullets(data, ti)
+    return data, ok, notes
+
+
+def _empty_trailing_para_spans(cell_xml: bytes) -> list[tuple[int, int]]:
+    """Byte spans of every empty ``<hp:p>`` after the first in a cell — the donor
+    template's leftover list-bullet paragraphs, which render as stray/red bullets once
+    the MD text is spliced into the first paragraph. The first paragraph is always
+    kept (a cell needs one)."""
+    s = cell_xml.decode("utf-8")
+    spans: list[tuple[int, int]] = []
+    for i, m in enumerate(re.finditer(r"<hp:p\b.*?</hp:p>", s, re.DOTALL)):
+        if i == 0:
+            continue
+        txt = "".join(
+            re.findall(
+                r"<hp:t\b[^>]*>(.*?)</hp:t>",
+                m.group(0),
+                re.DOTALL,
+            )
+        )
+        if not txt.strip():
+            spans.append((len(s[:m.start()].encode("utf-8")), len(s[:m.end()].encode("utf-8"))))
+    return spans
+
+
+def _prune_header_empty_bullets(data: bytes, ti: int) -> bytes:
+    """Drop the empty trailing bullet paragraphs left in a rubric's 수행과제 / 학생 유의
+    사항 value cells (byte-preserving: removes whole empty ``<hp:p>`` elements, rewrites
+    only the affected section part)."""
+    from hwpx.patch import rewrite_package_parts
+    from hwpx.table_patch import (
+        build_grid,
+        iter_table_spans,
+        section_parts,
+        table_text,
+    )
+
+    idx = ti
+    for sp, section in sorted(section_parts(data).items()):
+        spans = iter_table_spans(section)
+        if idx >= len(spans):
+            idx -= len(spans)
+            continue
+        ts, te = spans[idx]
+        tb = section[ts:te]
+        grid, rep = build_grid(tb)
+        edits: list[tuple[int, int]] = []
+        for r in range(rep.row_count):
+            for cprime in range(rep.col_count):
+                cell = grid.get((r, cprime))
+                if cell is None or (cell.row, cell.col) != (r, cprime):
+                    continue
+                if table_text(tb[cell.start:cell.end]).replace(" ", "").strip() not in ("수행과제", "학생유의사항"):
+                    continue
+                vc = grid.get((r, cell.col + cell.col_span))
+                if vc is None:
+                    continue
+                for a, b in _empty_trailing_para_spans(tb[vc.start:vc.end]):
+                    edits.append((ts + vc.start + a, ts + vc.start + b))
+        if not edits:
+            return data
+        new_section = section
+        for a, b in sorted(edits, reverse=True):
+            new_section = new_section[:a] + new_section[b:]
+        return rewrite_package_parts(data, {sp: new_section})
+    return data
+
+
+def _fill_rubrics_detailed(
+    data: bytes, content: EvalPlanContent, report: dict[str, Any]
+) -> tuple[bytes, dict[str, Any]]:
+    """Fill every §7 rubric from a detailed area. Routes by blank shape: 평가 영역명
+    tables (2학년) → :func:`_fill_rubric_detailed_2022`; 교육과정성취기준 tables (3학년) →
+    :func:`_fill_rubric_detailed_3hak`."""
+    filled = 0
+    for i, rub in enumerate(content.rubrics):
+        idxs = _rubric_indices(data)
+        if i >= len(idxs):
+            report["skipped"].append(f"rubric {i}: no matching blank table")
+            continue
+        ti = idxs[i]
+        if _rubric_is_2022(data, ti):
+            data, ok, notes = _fill_rubric_detailed_2022(data, ti, rub)
+        else:
+            data, ok, notes = _fill_rubric_detailed_3hak(data, ti, rub, content)
+        report["skipped"].extend(f"rubric {i}: {n}" for n in notes)
+        if ok:
+            filled += 1
+    report["filled"] = filled
+    return data, report
+
+
+def fill_rubrics(data: bytes, content: EvalPlanContent) -> tuple[bytes, dict[str, Any]]:
+    """Fill each 수행평가 세부기준 rubric table from the matching review rubric
+    (byte-preserving). Replaces the sample 성취기준 codes / 평가항목 labels.
+
+    Routes by 개정: 2015-개정 (3학년, '교육과정성취기준' rubric) shrinks the example item
+    block to the review item count and splices 성취기준 / 상·중·하 / 항목 / 배점 rows;
+    2022-개정 (2학년, '평가 영역명' rubric) overwrites the cleanly-addressable label
+    cells (title / points / 성취기준 / A~E / 수행과제 / 평가요소 leaders / 기본점수 배점),
+    reshapes+fills the 수행수준 채점기준 ladder, and rewrites each rubric's ordinal
+    heading paragraph (가./나./다. + sample project title) to the review 영역명."""
+
+    report: dict[str, Any] = {"rubrics": len(content.rubrics), "filled": 0, "skipped": []}
+
+    # Detailed route (current 평가계획 MD): each area carries a per-element 배점 ladder
+    # that the summary routes below can't represent. Grows the blank's 평가요소 ladder to
+    # the MD's element count and splices every observable criterion + 배점 verbatim.
+    if content.rubrics and content.rubrics[0].detailed:
+        return _fill_rubrics_detailed(data, content, report)
+
+    # 2022-개정 route: fill each rubric table's label cells + 채점기준 ladder + heading.
+    idxs0 = _rubric_indices(data)
+    if idxs0 and _rubric_is_2022(data, idxs0[0]):
+        return _fill_rubrics_2022_route(data, content, report)
+
+    # STEP 1 (structure): shrink each rubric's item block to its review item count.
+    data = _shrink_rubric_item_blocks(data, content, report)
+    # STEP 2 (content): fill each rubric's cells.
+    data = _fill_rubric_cells_legacy(data, content, report)
+    return data, report
+
+
+def _fill_rubrics_2022_route(
+    data: bytes, content: EvalPlanContent, report: dict[str, Any]
+) -> tuple[bytes, dict[str, Any]]:
+    std_levels = _std_level_map(content.achievement_std)
+    filled = 0
+    for i, rub in enumerate(content.rubrics):
+        idxs = _rubric_indices(data)
+        if i >= len(idxs):
+            report["skipped"].append(f"rubric {i}: no matching blank table")
+            continue
+        data, sk = _fill_rubric_2022(data, idxs[i], rub, std_levels)
+        report["skipped"].extend(sk)
+        filled += 1
+    # rewrite each rubric's ordinal heading paragraph (outside the table) that holds
+    # the blank's sample project title (가. 인권 문제 해결 프로젝트 …).
+    data, head_sk = _fill_rubric_headings(data, content)
+    report["skipped"].extend(head_sk)
+    report["filled"] = filled
+    return data, report
+
+
+def _shrink_rubric_item_blocks(data: bytes, content: EvalPlanContent, report: dict[str, Any]) -> bytes:
+    """STEP 1: shrink each rubric's item block to its review item count."""
+
+    from hwpx.table_patch import apply_table_ops
+
+    for i, rub in enumerate(content.rubrics):
+        items = [row for row in rub.rows if not row[0].startswith("기본점수")]
+        n = max(1, len(items))
+        idxs = _rubric_indices(data)
+        if i >= len(idxs):
+            report["skipped"].append(f"rubric {i}: no matching blank table")
+            continue
+        ti = idxs[i]
+        hdr, base, _nrows = _rubric_bounds(data, ti)
+        if hdr is None or base is None:
+            report["skipped"].append(f"rubric {i}: could not bound item block")
+            continue
+        first_item = hdr + 1
+        todel = list(range(first_item + n, base))   # keep n, drop the surplus
+        if todel:
+            res = apply_table_ops(data, [{"op": "delete_row", "table_index": ti, "rows": todel}])
+            if not res.ok:
+                report["skipped"].append(f"rubric {i} shrink: {[s.reason for s in res.skipped]}")
+                continue
+            data = res.data
+    return data
+
+
+def _fill_rubric_cells_legacy(data: bytes, content: EvalPlanContent, report: dict[str, Any]) -> bytes:
+    """STEP 2: fill each rubric's cells (2015-개정 route)."""
+
+    levels = content.levels
+    for i, rub in enumerate(content.rubrics):
+        idxs = _rubric_indices(data)
+        if i >= len(idxs):
+            continue
+        ti = idxs[i]
+        levels_for_area = levels[i] if i < len(levels) else None
+        data, skipped, filled_count = _fill_rubric_legacy_cells(
+            data, ti, rub, levels_for_area, content.achievement_std
+        )
+        report["filled"] += filled_count
+        report["skipped"].extend(f"rubric {i}: {s.reason}" for s in skipped)
+    return data
+
+
+def _fill_rubric_legacy_cells(
+    data: bytes,
+    ti: int,
+    rub: Rubric,
+    levels_for_area: Sequence[str] | None,
+    achievement_std: Any,
+) -> tuple[bytes, list[Any], int]:
+    """Fill one legacy (2015-개정) rubric table's cells.
+
+    Returns (data, skip_reasons, filled_count).
+    """
+
+    from hwpx.table_patch import fill_cells
+
+    hdr, base, _nrows = _rubric_bounds(data, ti)
+    if hdr is None or base is None:
+        return data, [], 0
+    first_item = hdr + 1
+    items = [row for row in rub.rows if not row[0].startswith("기본점수")]
+    _sp, tb, grid, _rep = _grid_of(data, ti)
+
+    cells: list[dict[str, Any]] = []
+    # r0 성취기준 (replaces 한국사 sample codes)
+    std_cell = _rubric_std_cell(ti, rub, achievement_std)
+    if std_cell is not None:
+        cells.append(std_cell)
+    # r1-3 상/중/하 평가기준 from the matching area's A/B/C descriptors
+    cells.extend(_rubric_level_cells(ti, levels_for_area, grid))
+    # 영역(만점) leader
+    area_cell = _rubric_area_leader_cell(ti, rub, first_item, grid)
+    if area_cell is not None:
+        cells.append(area_cell)
+    # 평가항목 labels -> the merged 평가항목 cell's paragraphs (one line per item)
+    item_cell = _rubric_item_labels_cell(ti, first_item, grid, tb, items)
+    if item_cell is not None:
+        cells.append(item_cell)
+    # per-item 채점기준 rows (col3) + top 배점 (col4)
+    cells.extend(_rubric_item_criteria_cells(ti, first_item, base, grid, items))
+    # 기본점수 / 장기 미인정 rows
+    cells.extend(_rubric_base_score_cells(ti, base, grid, rub.rows))
+
+    fr = fill_cells(data, cells)
+    return fr.data, list(fr.skipped), len(fr.applied)
+
+
+def _rubric_std_cell(ti: int, rub: Rubric, achievement_std: Any) -> dict[str, Any] | None:
+    std_text = rub.standards or (achievement_std and "")
+    if std_text:
+        return {"table_index": ti, "row": 0, "col": 1, "text": std_text, "max_lines": 3}
+    return None
+
+
+def _rubric_level_cells(
+    ti: int, levels_for_area: Sequence[str] | None, grid: Any
+) -> list[dict[str, Any]]:
+    cells: list[dict[str, Any]] = []
+    if levels_for_area is not None and len(levels_for_area) >= 4:
+        for k, desc in enumerate(levels_for_area[1:4]):
+            rr = 1 + k
+            if grid.get((rr, 2)):
+                cells.append({"table_index": ti, "row": rr, "col": 2, "text": desc, "max_lines": 4})
+    return cells
+
+
+def _rubric_area_leader_cell(ti: int, rub: Rubric, first_item: int, grid: Any) -> dict[str, Any] | None:
+    if grid.get((first_item, 0)) is not None:
+        return {"table_index": ti, "row": first_item, "col": 0,
+                "text": f"{rub.title}({rub.points}점)", "max_lines": 3}
+    return None
+
+
+def _rubric_item_labels_cell(
+    ti: int, first_item: int, grid: Any, tb: Any, items: list[list[str]]
+) -> dict[str, Any] | None:
+    from hwpx.table_patch import cell_paragraph_spans
+
+    item_cell = grid.get((first_item, 1))
+    if item_cell is None:
+        return None
+    n_para = len(cell_paragraph_spans(tb[item_cell.start:item_cell.end]))
+    labels = [it[0] for it in items]
+    if n_para < 1:
+        return None
+    # pack labels across available paragraphs; extras merged into the last
+    if len(labels) <= n_para:
+        packed = labels
+    else:
+        packed = labels[:n_para - 1] + [" · ".join(labels[n_para - 1:])]
+    return {"table_index": ti, "row": first_item, "col": 1, "text": "\n".join(packed), "max_lines": 2}
+
+
+def _rubric_item_criteria_cells(
+    ti: int, first_item: int, base: int, grid: Any, items: list[list[str]]
+) -> list[dict[str, Any]]:
+    cells: list[dict[str, Any]] = []
+    for k, it in enumerate(items):
+        rr = first_item + k
+        if rr >= base:
+            break
+        if grid.get((rr, 3)):
+            cells.append({"table_index": ti, "row": rr, "col": 3,
+                          "text": _batjeom_line(it[0], it[1]), "max_lines": 3})
+        top = _top_batjeom(it[1])
+        if top and grid.get((rr, 4)):
+            cells.append({"table_index": ti, "row": rr, "col": 4, "text": top, "max_lines": 1})
+    return cells
+
+
+def _rubric_base_score_cells(
+    ti: int, base: int, grid: Any, rub_rows: list[list[str]]
+) -> list[dict[str, Any]]:
+    base_label, base_score, long_label, long_score = _base_scores(rub_rows)
+    cells: list[dict[str, Any]] = []
+    if grid.get((base, 1)):
+        cells.append({"table_index": ti, "row": base, "col": 1, "text": base_label, "max_lines": 2})
+    if base_score and grid.get((base, 4)):
+        cells.append({"table_index": ti, "row": base, "col": 4, "text": base_score, "max_lines": 1})
+    if grid.get((base + 1, 1)):
+        cells.append({"table_index": ti, "row": base + 1, "col": 1, "text": long_label, "max_lines": 2})
+    if long_score and grid.get((base + 1, 4)):
+        cells.append({"table_index": ti, "row": base + 1, "col": 4, "text": long_score, "max_lines": 1})
+    return cells
+
+
+def _rubric_bounds(data: bytes, ti: int) -> tuple[int | None, int | None, int]:
+    """(header_row, 기본점수_row, row_count) of a rubric table -- the item block is
+    the physical rows between them."""
+    from hwpx.table_patch import table_text
+    _sp, tb, grid, rep = _grid_of(data, ti)
+    hdr = base = None
+    for r in range(rep.row_count):
+        c0 = grid.get((r, 0))
+        if c0 is not None:
+            t0 = table_text(tb[c0.start:c0.end])
+            if "영역" in t0 and "만점" in t0:
+                hdr = r
+        c1 = grid.get((r, 1))
+        if c1 is not None and base is None and "기본점수" in table_text(tb[c1.start:c1.end]):
+            base = r
+    return hdr, base, rep.row_count
+
+
+def _prose_items(raw: str, header_words: Sequence[str] = ()) -> list[str]:
+    """Split a ``_norm``'d prose section ('가. ... 나. ... 다. ...') into 가/나/다
+    items, dropping any leading section-title words the parser swept in."""
+    s = raw.strip()
+    for hw in header_words:
+        if s.startswith(hw):
+            s = s[len(hw):].strip()
+    # split before each Korean-letter ordinal marker '가.'..'하.'
+    parts = re.split(r"(?<!\S)(?=[가-힣]\.\s)", s)
+    items = [re.sub(r"^[가-힣]\.\s*", "", p).strip() for p in parts if p.strip()]
+    # drop residual '- ' bullet / title fragments with no ordinal
+    return [it for it in items if it and not it.startswith("평가")]
+
+
+_ORDINALS = "가나다라마바사아자차카타파하"
+
+
+def fill_sections(data: bytes, content: EvalPlanContent) -> tuple[bytes, dict[str, Any]]:
+    """Fill the 가./나./다. prose slots of §1 목적 / §2 기본방향 / §3 방침 with the
+    review MD's items (byte-preserving paragraph splices).
+
+    A slot = a paragraph starting with an ordinal marker ('가.'…), whether empty
+    (§1/§2 ship empty placeholders) or already holding the blank's generic sample
+    prose (§3). Each slot keeps its ordinal ('가. <item>') so the numbering
+    survives, and NO item is dropped: when the review has more items than slots,
+    the surplus is appended -- with its own ordinals -- to the last slot (the
+    blank's fixed placeholder count can't grow, and paragraph_patch only
+    *replaces*). §11 결과분석 is deferred (its 가./(1)(2)(3)/나. sub-structure would
+    be flattened) and keeps the blank's generic content -- reported, not faked.
+    Sections whose slots can't be located are reported."""
+    from hwpx.patch import paragraph_chunks, paragraph_patch
+    from hwpx.table_patch import section_parts, table_text
+
+    report: dict[str, Any] = {"filled": 0, "skipped": [], "deferred": ["analysis(§11): rich sub-structure kept generic"]}
+    sections = section_parts(data)
+    if not sections:
+        return data, report
+    sp = min(sections)
+    section = sections[sp]
+    texts = [table_text(chunk).strip() for chunk in paragraph_chunks(section)]
+
+    def slots_after(header_kw: str, next_kw: str) -> list[int]:
+        try:
+            hi = next(i for i, t in enumerate(texts) if t == header_kw)
+        except StopIteration:
+            return []
+        end = len(texts)
+        for j in range(hi + 1, len(texts)):
+            if texts[j] == next_kw:
+                end = j
+                break
+        # a slot = a paragraph whose text is an ordinal marker (empty or filled)
+        return [j for j in range(hi + 1, end)
+                if re.match(r"^[가나다라마바사아자차카타파하]\.(\s|$)", texts[j])]
+
+    plan = [
+        ("purposes", "평가의 목적", "평가의 기본 방향", ("평가의 목적",)),
+        ("directions", "평가의 기본 방향", "평가 방침", ("평가의 기본 방향",)),
+        ("policies", "평가 방침", "성취기준 및 성취수준", ("평가 방침",)),
+    ]
+    patches: list[dict[str, Any]] = []
+    for attr, header, nxt, titlewords in plan:
+        items = _prose_items(getattr(content, attr, ""), titlewords)
+        slots = slots_after(header, nxt)
+        if not slots or not items:
+            if items:
+                report["skipped"].append(f"{attr}: no ordinal placeholder located")
+            continue
+        # number every item, then pack into the fixed slots without dropping any
+        numbered = [f"{_ORDINALS[i]}. {it}" for i, it in enumerate(items)]
+        k = len(slots)
+        packed = numbered if len(numbered) <= k else numbered[:k - 1] + [" ".join(numbered[k - 1:])]
+        for slot_idx, text in zip(slots, packed):
+            patches.append({"section_path": sp, "paragraph_index": slot_idx, "text": text})
+
+    if not patches:
+        report["skipped"].append("no fillable prose placeholders located")
+        return data, report
+    pres = paragraph_patch(data, patches)
+    report["filled"] = len(pres.applied)
+    report["skipped"].extend(s.reason for s in pres.skipped)
+    return pres.data, report
+
+
+def _flatten_schedule_merges(data: bytes, ti: int) -> tuple[bytes, list[str]]:
+    """Split every vertical merge in the schedule's *data* rows into unit rows.
+
+    The donor ships a subject sample whose 단원명/성취기준 may span two weeks (a
+    ``rowSpan==2`` cell). The review has distinct content per week, so a naive
+    one-row-per-week fill writes the first week into the merged cell and can only
+    *skip* the second (its cell is covered) -- the second week's 단원/성취기준 is
+    absorbed. Splitting each vertical merge into unit cells (byte-preserving, the
+    original formatting cloned onto the new cell) restores the 1:1 mapping so no
+    row is absorbed. Header row (0) is left untouched. Content-agnostic."""
+    from hwpx.table_patch import apply_table_ops, direct_table_cells
+    notes: list[str] = []
+    while True:
+        _sp, tb, _grid, _rep = _grid_of(data, ti)
+        merge = next(((c.row, c.col, c.row_span)
+                      for c in sorted(direct_table_cells(tb), key=lambda c: (c.row, c.col))
+                      if c.row >= 1 and c.row_span > 1), None)
+        if merge is None:
+            break
+        r, col, rs = merge
+        res = apply_table_ops(data, [{"op": "split_cell_vertical", "table_index": ti,
+                                      "row": r, "col": col, "sizes": [1] * rs}])
+        if not res.ok:
+            notes.append(f"split donor merge r{r}c{col} (rowSpan {rs}) refused: "
+                         f"{[s.reason for s in res.skipped]}")
+            break
+        data = res.data
+        notes.append(f"split donor merge r{r}c{col} (rowSpan {rs}) into {rs} unit rows")
+    return data, notes
+
+
+def fill_schedule(data: bytes, content: EvalPlanContent) -> tuple[bytes, dict[str, Any]]:
+    """Fill the Ⅰ 교수학습 운영 계획 schedule table from ``content.schedule`` (one
+    logical row per review row, 6 columns), shrink-to-fit at 4 lines. Located by
+    the widest multi-row data table under the Ⅰ heading. Any vertical merge a donor
+    sample left in the data rows is split first so every review row maps to its own
+    form row (no absorption)."""
+    from hwpx.table_patch import fill_cells
+
+    report: dict[str, Any] = {"rows": len(content.schedule), "filled": 0, "skipped": [], "unmerged": []}
+    if not content.schedule:
+        return data, report
+    ti = _schedule_index(data)
+    if ti is None:
+        report["skipped"].append("no schedule table found")
+        return data, report
+    data, report["unmerged"] = _flatten_schedule_merges(data, ti)
+    cells = []
+    for i, row in enumerate(content.schedule):
+        r = i + 1  # row 0 is the header
+        for col in range(min(6, len(row))):
+            cells.append({"table_index": ti, "row": r, "col": col, "text": row[col], "max_lines": 4})
+    fr = fill_cells(data, cells)
+    report["filled"] = len(fr.applied)
+    report["skipped"].extend(s.reason for s in fr.skipped)
+    return fr.data, report
+
+
+def _schedule_index(data: bytes) -> int | None:
+    """Table index of the Ⅰ schedule grid: the first multi-row table whose header
+    row carries the 월/주/성취기준 signature."""
+    from hwpx.table_patch import (
+        build_grid,
+        iter_table_spans,
+        section_parts,
+        table_text,
+    )
+    base = 0
+    for sp, section in sorted(section_parts(data).items()):
+        spans = iter_table_spans(section)
+        for ti, (s, e) in enumerate(spans):
+            tb = section[s:e]
+            grid, rep = build_grid(tb)
+            if rep.row_count < 3:
+                continue
+            hdr = " ".join(table_text(tb[grid[(0, c)].start:grid[(0, c)].end])
+                           for c in range(rep.col_count) if grid.get((0, c)))
+            if "월" in hdr and "주" in hdr and "성취기준" in hdr:
+                return base + ti
+        base += len(spans)
+    return None
+
+
+_PCT_RE = re.compile(r"(\d+)\s*%")
+
+
+def _percent_or_value(value: str) -> str:
+    match = _PCT_RE.search(value)
+    return match.group(0) if match else value
+
+
+def _ratio_columns(tb: bytes, grid, rep) -> tuple[int, list[int], int | None]:
+    """(label_col, area_cols, total_col) of a 반영비율 grid.
+
+    ``label_col`` is the right-most column of the header's left-most (구분/평가 종류)
+    cell -- 3학년 spans 1 column, 2학년 spans 2 -- so reading a row's label from col 0
+    is safe but *writing* area values must start after this. ``total_col`` is the
+    header column carrying '합계'. ``area_cols`` are the columns strictly between the
+    label span and 합계 (the per-영역 data columns), 정기시험 already deleted."""
+    from hwpx.table_patch import table_text
+    c00 = grid.get((0, 0))
+    label_cols = [cc for cc in range(rep.col_count) if grid.get((0, cc)) is c00]
+    label_col = label_cols[-1] if label_cols else 0
+    total_col = None
+    for cc in range(rep.col_count):
+        cell = grid.get((0, cc))
+        if cell and "합계" in table_text(tb[cell.start:cell.end]):
+            total_col = cc
+            break
+    area_cols = [cc for cc in range(label_col + 1, rep.col_count) if cc != total_col]
+    return label_col, area_cols, total_col
+
+
+def _ratio_row_source(label: str, content: EvalPlanContent) -> tuple[str, list[str], str | None] | None:
+    """Map a produced 반영비율 row *label* to its MD source: a ``(kind, area_values,
+    total)`` tuple, or None to leave the row untouched.
+
+    The blank ships more rows than the MD's 5 data rows (a plain '반영 비율' %-only
+    summary + a '시기/영역' area-name row on top of the MD's 영역 만점/논술형/시기/
+    성취기준/평가요소), so the mapping is by tolerant label keyword, not position:
+
+    * '영역 만점' → the MD 영역 만점(반영비율) cells ('35점(35%)' …)
+    * plain '반영 비율' (NOT 영역 만점) → the bare percentages of 영역 만점 ('35%' …)
+    * '시기/영역' (area-name row) → the MD ratio_header 영역 names
+    * '논술형' → MD 논술형 평가 반영비율
+    * '평가 시기' / '시기' (without 영역) → MD 평가 시기
+    * '성취기준' → MD 성취기준  (this is where the blank's foreign sample codes live)
+    * '평가요소' → MD 평가요소
+    """
+    lab = label.replace(" ", "")
+    rows = {r[0].replace(" ", ""): r for r in content.ratio_rows}
+
+    def row(*keys: str) -> list[str] | None:
+        for k, value in rows.items():
+            if any(key in k for key in keys):
+                return value
+        return None
+
+    def data_and_total(r: list[str] | None) -> tuple[list[str], str | None] | None:
+        if not r:
+            return None
+        vals = r[1:]
+        total = vals[-1] if len(vals) > len(_area_names(content)) else None
+        # area values are the leading cells; a trailing 합계 (last) is the total
+        area = vals[:len(_area_names(content))]
+        return area, total
+
+    areas = _area_names(content)
+    if "영역만점" in lab:
+        dt = data_and_total(row("영역만점", "만점"))
+        return ("영역 만점", dt[0], dt[1]) if dt else None
+    if lab.startswith("반영비율") or lab == "반영비율":
+        dt = data_and_total(row("영역만점", "만점"))
+        if not dt:
+            return None
+        pcts = [_percent_or_value(value) for value in dt[0]]
+        return ("반영 비율", pcts, dt[1])
+    if "시기/영역" in lab or lab == "시기영역":
+        # the area-name row: fill from the MD ratio_header 영역 names
+        return ("영역명", list(areas), None)
+    if "논술형" in lab:
+        dt = data_and_total(row("논술형"))
+        return ("논술형", dt[0], dt[1]) if dt else None
+    if "평가시기" in lab or (lab.startswith("시기") and "영역" not in lab):
+        dt = data_and_total(row("평가시기", "시기"))
+        return ("평가 시기", dt[0], dt[1]) if dt else None
+    if "성취기준" in lab:
+        dt = data_and_total(row("성취기준"))
+        return ("성취기준", dt[0], dt[1]) if dt else None
+    if "평가요소" in lab:
+        dt = data_and_total(row("평가요소"))
+        return ("평가요소", dt[0], dt[1]) if dt else None
+    return None
+
+
+def _area_names(content: EvalPlanContent) -> list[str]:
+    """The 영역 names from the MD §6 header ('① 문제해결에 …', …) -- every header cell
+    that is not the leading 구분 label or the trailing 합계."""
+    hdr = content.ratio_header
+    if not hdr:
+        return []
+    inner = hdr[1:]
+    if inner and "합계" in inner[-1]:
+        inner = inner[:-1]
+    return inner
+
+
+def fill_ratio(data: bytes, content: EvalPlanContent) -> tuple[bytes, dict[str, Any]]:
+    """Fill the 반영비율 (평가의 종류와 반영비율) table's data cells from the review MD
+    §6 (byte-preserving). The recipe deletes the 정기시험 column but never wrote the
+    수행평가 area data, so the produced table carries 100% sample content (50/50/50 %,
+    통합과학 subjects, 통과 성취기준 codes). This maps ``content.ratio_rows`` onto the
+    produced rows by their left-most LABEL (tolerant keyword match, so 반영 비율 vs
+    영역 만점 both resolve) and fills the per-영역 columns + the 시기/영역 area names +
+    the header 영역 names. Handles BOTH forms (3학년 5-col, 2학년 6-col with a 2-col
+    label span). No-op / reported if the MD ships no §6 table."""
+    from hwpx.table_patch import fill_cells, table_text
+
+    report: dict[str, Any] = {"rows_filled": 0, "skipped": []}
+    if not content.ratio_rows and not content.ratio_header:
+        report["skipped"].append("MD has no §6 ratio table")
+        return data, report
+    ti = _classify_index(data, "ratio")
+    if ti is None:
+        report["skipped"].append("no ratio table found")
+        return data, report
+    _sp, tb, grid, rep = _grid_of(data, ti)
+    label_col, area_cols, total_col = _ratio_columns(tb, grid, rep)
+    if not area_cols:
+        report["skipped"].append(f"no area columns detected (label_col={label_col}, total_col={total_col})")
+        return data, report
+
+    cells: list[dict[str, Any]] = []
+    # header 평가 종류 row (r0): the area-name header cells still say '수행평가' -- leave
+    # them (they are the 평가 종류, correctly 수행평가); the 영역 names go in the 시기/영역
+    # row so they are not duplicated.
+    for r in range(1, rep.row_count):
+        c0 = grid.get((r, 0))
+        label = table_text(tb[c0.start:c0.end]).strip() if c0 else ""
+        src = _ratio_row_source(label, content)
+        if src is None:
+            continue
+        kind, area_vals, total = src
+        wrote = False
+        # Dedup horizontally-merged area cells: the blank collapses some rows' 영역
+        # columns into ONE spanned cell (e.g. the '반영 비율' summary is a single
+        # cell over all 영역). Writing per-column would collide on the same physical
+        # cell; instead we write ONE value per distinct cell. A merged summary cell
+        # takes the row's 합계 (its meaning is the aggregate), a merged non-summary
+        # cell takes the joined area values; distinct per-영역 cells take their own
+        # value, and an MD '—' CLEARS the blank's leftover sample (writes empty).
+        seen_cells: set[tuple[int, int]] = set()
+        for k, cc in enumerate(area_cols):
+            cell = grid.get((r, cc))
+            if cell is None:
+                continue
+            key = (cell.start, cell.end)
+            if key in seen_cells:
+                continue
+            seen_cells.add(key)
+            spanned = [ac for ac in area_cols if grid.get((r, ac)) is cell]
+            if len(spanned) > 1:
+                # a merged area cell — one physical cell over several 영역 columns
+                if kind == "반영 비율":
+                    val = (total or "").strip()
+                else:
+                    parts = [area_vals[area_cols.index(ac)].strip()
+                             for ac in spanned if area_cols.index(ac) < len(area_vals)]
+                    parts = [p for p in parts if p and p != "—"]
+                    val = " / ".join(dict.fromkeys(parts))
+            else:
+                val = area_vals[k].strip() if k < len(area_vals) else ""
+                if val == "—":
+                    val = ""      # clear leftover sample where the MD has no value
+            cells.append({"table_index": ti, "row": r, "col": cc, "text": val, "max_lines": 3})
+            wrote = True
+        # 합계 column: fill only when the MD supplies a concrete total (not '—')
+        if total and total.strip() not in ("", "—") and total_col is not None and grid.get((r, total_col)):
+            cells.append({"table_index": ti, "row": r, "col": total_col, "text": total.strip(), "max_lines": 1})
+        if wrote:
+            report["rows_filled"] += 1
+
+    if not cells:
+        report["skipped"].append("no ratio rows matched the MD labels")
+        return data, report
+    fr = fill_cells(data, cells)
+    report["filled_cells"] = len(fr.applied)
+    report["skipped"].extend(s.reason for s in fr.skipped)
+    return fr.data, report
+
+
+def finalize_evalplan(data: bytes, content: EvalPlanContent) -> tuple[bytes, dict[str, Any]]:
+    """Deterministic post-fill cleanup: turn a *filled* donor 평가계획 form into a
+    submittable 채움본 without a bespoke driver script.
+
+    Runs the recipe's mechanical steps -- fill the title / teacher / 정의적 cells,
+    prune the donor's instruction scaffolding and orphaned sample headings (bounded
+    by the form's OWN section headings, never by subject or grade), strip the red
+    guidance runs, recolor filled blue slots to body black, and remove trailing
+    table captions. Every decision is structure/pattern based; no subject or grade
+    string appears. Genuine ambiguity (novel instruction phrasing, non-1:1 정의적
+    cell mapping, tie-broken 변형 선택) is intentionally NOT resolved here -- that is
+    the skill's (LLM) judgment.
+
+    ``data`` must already be a :func:`fill_evalplan` (``phase="all"``) output; the
+    deletes are computed while the red guidance runs are still intact so a black
+    ordinal sharing a paragraph with a red instruction is removed as a unit. Returns
+    ``(clean_bytes, report)``."""
+    import html
+    import io
+    import zipfile
+
+    from hwpx.body_patch import (
+        apply_body_ops,
+        direct_paragraph_spans,
+        recolor_runs_by_color,
+        strip_runs_by_color,
+    )
+    from hwpx.table_patch import fill_cells, strip_trailing_table_captions
+
+    from ..form_fill.classification import _tables
+    from ..form_fill.guidance import is_form_instruction
+
+    T = re.compile(r"<hp:t(?:\s[^>]*)?>(.*?)</hp:t>", re.DOTALL)
+    RUN = re.compile(r"<hp:run\b[^>]*?>.*?</hp:run>", re.DOTALL)
+    ORDINAL = re.compile(r"^[가-하]\.?$|^\(\d+\)$|^\*+$|^[·・\s]*$")
+    # legit 평가계획 notes that sit among instructions -- form-generic, never a
+    # subject/grade token, so keeping them is not hardcoding a subject.
+    KEEP = ("가급적 동점자",)
+
+    report: dict[str, Any] = {
+        "deleted": 0, "skipped": [], "captions": 0,
+        "title": False, "teacher": False, "affective_rows": 0,
+    }
+
+    def _sec_hdr(d: bytes) -> tuple[str, str]:
+        z = zipfile.ZipFile(io.BytesIO(d))
+        sec = z.read("Contents/section0.xml").decode("utf-8")
+        hdr_name = next(n for n in z.namelist() if n.endswith("header.xml"))
+        return sec, z.read(hdr_name).decode("utf-8")
+
+    def _red_ids(hdr: str) -> set[str]:
+        out: set[str] = set()
+        for cm in re.finditer(
+            r"<hh:charPr\b[^>]*\bid=\"(\d+)\"[^>]*textColor=\"([#0-9A-Fa-f]+)\"", hdr
+        ):
+            if cm.group(2).upper() == "#FF0000":
+                out.add(cm.group(1))
+        return out
+
+    def _run_texts(block: str, reds: set[str]) -> tuple[str, str]:
+        black: list[str] = []
+        red: list[str] = []
+        for rm in RUN.finditer(block):
+            run = rm.group(0)
+            txt = html.unescape("".join(T.findall(run)))
+            cid = re.search(r'charPrIDRef="(\d+)"', run)
+            (red if (cid and cid.group(1) in reds) else black).append(txt)
+        return "".join(black), "".join(red)
+
+    # ---- paragraph deletes computed on the FILLED bytes (red still intact) ------
+    sec, hdr = _sec_hdr(data)
+    reds = _red_ids(hdr)
+    spans = direct_paragraph_spans(sec)
+    blocks = [sec[a:b] for (a, b) in spans]
+    texts = [html.unescape("".join(T.findall(bl))).strip() for bl in blocks]
+    has_tbl = ["<hp:tbl" in bl for bl in blocks]
+    del_idx: set[int] = set()
+
+    def first(pred, start: int = 0) -> int | None:
+        return next((i for i in range(start, len(texts)) if pred(i)), None)
+
+    # (2e) 성취수준별 고정분할점수 labels -- red form scaffolding; delete all (the
+    # engine already kept the single subject-matching 성취율 table by band count).
+    del_idx.update(
+        i for i in range(len(texts))
+        if not has_tbl[i] and texts[i].startswith("성취수준별 고정분할점수")
+    )
+
+    # (2a) 최소 성취수준 orphan heading block -- its table was pruned (공통과목 전용);
+    # delete the non-table paragraphs from the heading down to the §5 table.
+    ms = first(lambda i: not has_tbl[i] and texts[i].startswith("다. 최소 성취수준"))
+    sec5 = first(lambda i: has_tbl[i] and "기준 성취율과 성취도" in texts[i])
+    if ms is not None and sec5 is not None:
+        del_idx.update(i for i in range(ms, sec5) if not has_tbl[i])
+
+    # (2f) foreign donor sample headings between the §7 and §8 tables.
+    s7 = first(lambda i: has_tbl[i] and "수행평가 세부기준" in texts[i])
+    s8 = first(lambda i: has_tbl[i] and "정의적 능력 평가" in texts[i],
+               start=(s7 + 1) if s7 is not None else 0)
+    if s7 is not None and s8 is not None:
+        del_idx.update(i for i in range(s7 + 1, s8) if not has_tbl[i] and texts[i])
+
+    # (2b) foreign "(N) area" sub-headers between §4 and §5 (donor sample labels;
+    # the MD's §4 uses 가./나. markers, never "(N) word", so this is safe).
+    s4h = first(lambda i: has_tbl[i] and "성취기준 및 성취수준" in texts[i])
+    s5h = first(lambda i: has_tbl[i] and "기준 성취율과 성취도" in texts[i],
+                start=(s4h + 1) if s4h is not None else 0)
+    if s4h is not None and s5h is not None:
+        del_idx.update(
+            i for i in range(s4h + 1, s5h)
+            if not has_tbl[i] and re.match(r"^\(\d+\)\s*\S", texts[i])
+        )
+
+    # (2c) red-guidance-with-trivial-black + black instruction paragraphs.
+    for i, bl in enumerate(blocks):
+        if has_tbl[i] or i in del_idx or any(k in texts[i] for k in KEEP):
+            continue
+        black_txt, red_txt = _run_texts(bl, reds)
+        if (
+            red_txt.strip() and ORDINAL.match(black_txt.strip())
+        ) or is_form_instruction(texts[i]):
+            del_idx.add(i)
+
+    # ---- title + §8 정의적 + teacher fills (paragraph count unchanged) -----------
+    cells: list[dict[str, Any]] = []
+    if content.title:
+        cells.append({"table_index": 0, "row": 0, "col": 0, "text": content.title})
+        report["title"] = True
+    # §8 정의적 능력 평가 표: replace the donor sample with the MD's 측면 rows (1:1).
+    aff = re.findall(
+        r"(\S+적 측면\([^)]*\))\s*[:：]\s*(.+?)(?=\s*-\s*\S+적 측면|$)", content.affective or ""
+    )
+    aff_ti = next((gi for gi, t in enumerate(_tables(data)) if "정의적 능력 평가 요소" in t.text), None)
+    if aff_ti is not None and aff:
+        for r, (label, desc) in enumerate(aff[:3], start=1):
+            cells.append({"table_index": aff_ti, "row": r, "col": 0, "text": label.strip(), "max_lines": 3})
+            cells.append({"table_index": aff_ti, "row": r, "col": 1, "text": desc.strip(), "max_lines": 4})
+        report["affective_rows"] = min(len(aff), 3)
+    if cells:
+        data = fill_cells(data, cells).data
+    if content.teacher:
+        # fill the placeholder, then recolor the filled value to body-black so the
+        # red-strip below does not remove it; robust to the label+placeholder being
+        # in one run (2학년) or split black label + red placeholder (3학년).
+        data = apply_body_ops(data, [
+            {"op": "replace_text", "find": "◯◯◯, ◯◯◯", "replace": content.teacher, "count": 1},
+            {"op": "restyle_text", "find": content.teacher, "textColor": "#000000", "count": 1},
+            {"op": "replace_text", "find": "(**)", "replace": "", "count": 4},
+        ]).data
+        report["teacher"] = True
+
+    # ---- apply deletes (high->low so indices stay valid) ------------------------
+    dr = apply_body_ops(data, [{"op": "delete_paragraph", "index": i}
+                               for i in sorted(del_idx, reverse=True)])
+    data = dr.data
+    report["deleted"] = len(del_idx) - len(dr.skipped)
+    report["skipped"] = [str(s) for s in dr.skipped]
+
+    # ---- strip residual red, recolor filled blue->black, strip captions --------
+    data = strip_runs_by_color(data, ["#FF0000"]).data
+    data = recolor_runs_by_color(data, ["#0000FF"], "#000000").data
+    cap = strip_trailing_table_captions(data)
+    data = cap.data
+    report["captions"] = len(cap.applied)
+    return data, report
+
+
+def fill_evalplan(
+    blank: str | Path,
+    content: EvalPlanContent,
+    *,
+    output: str | None = None,
+    phase: str = "structural",
+) -> dict[str, Any]:
+    """Apply the recipe to a blank form.
+
+    ``phase="structural"`` runs the confident deletions only (red/optional tables,
+    정기시험 column, surplus example tables). ``phase="all"`` additionally runs the
+    content fills -- schedule, achievement, levels, rubrics, section prose -- each
+    byte-preserving and located by classification/geometry (index-safe against the
+    prior structural deletes). ``phase="clean"`` runs ``"all"`` and then
+    :func:`finalize_evalplan` -- the deterministic post-fill cleanup (title/teacher/
+    정의적 fills, scaffolding + orphan prune, red-strip, blue->black recolor, caption
+    strip) that yields a submittable 채움본 with no bespoke driver. Returns the apply
+    result dict plus the op-plan transcript and, for ``phase`` in ``{"all","clean"}``,
+    a ``content_report`` per region (plus ``content_report["finalize"]`` for clean)."""
+    from hwpx.table_patch import apply_table_ops
+
+    plan = plan_structural_ops(blank, content)
+    result = apply_table_ops(blank, plan["ops"])
+    data = result.data
+    payload = result.to_dict()
+
+    content_report: dict[str, Any] = {}
+    if phase in ("all", "clean"):
+        data, content_report["schedule"] = fill_schedule(data, content)
+        data, content_report["achievement"] = fill_achievement(data, content)
+        data, content_report["levels"] = fill_levels(data, content)
+        data, content_report["rubrics"] = fill_rubrics(data, content)
+        data, content_report["ratio"] = fill_ratio(data, content)
+        data, content_report["sections"] = fill_sections(data, content)
+    if phase == "clean":
+        data, content_report["finalize"] = finalize_evalplan(data, content)
+
+    if output is not None:
+        from pathlib import Path as _P
+        _P(output).write_bytes(data)
+        payload["outputPath"] = output
+    payload["transcript"] = plan["transcript"]
+    payload["expected_skeleton"] = plan["expected_skeleton"]
+    payload["content_report"] = content_report
+    payload["_data"] = data
+    return payload
+
+
+def parse_review_file(path: str | Path) -> EvalPlanContent:
+    return parse_review_md(Path(path).read_text(encoding="utf-8"))
+
+
+__all__ = [  # noqa: RUF022 - frozen 4.x public ordering
+    "EvalPlanContent", "Rubric", "parse_review_md", "parse_review_file",
+    "expected_skeleton", "plan_structural_ops", "fill_evalplan", "finalize_evalplan",
+    "fill_schedule", "fill_achievement", "fill_levels", "fill_rubrics", "fill_ratio",
+    "fill_sections",
+]