python-hwpx 2.15.0__tar.gz → 2.16.0__tar.gz

{python_hwpx-2.15.0/src/python_hwpx.egg-info → python_hwpx-2.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hwpx
-Version: 2.15.0
+Version: 2.16.0
 Summary: 한글 없이 HWPX 문서를 열고, 편집하고, 생성하고, 검증하는 Python 자동화 라이브러리
 Author: python-hwpx Maintainers
 License-Expression: Apache-2.0

{python_hwpx-2.15.0 → python_hwpx-2.16.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-hwpx"
-version = "2.15.0"
+version = "2.16.0"
 description = "한글 없이 HWPX 문서를 열고, 편집하고, 생성하고, 검증하는 Python 자동화 라이브러리"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = "Apache-2.0"

{python_hwpx-2.15.0 → python_hwpx-2.16.0}/src/hwpx/authoring.py

@@ -874,6 +874,138 @@ def _validate_v2_block(raw_block: Any, *, path: str) -> list[PlanValidationIssue
     return issues
 
 
+# --- M3 (S-057) document-type -> design profile routing ------------------------
+# Maps a plan's document_type (Korean label or profile id) to a committed
+# hwpx.design profile. When it resolves, create_document_from_plan composes from
+# the harvested, Hancom-opens-clean profile skeleton instead of the from-scratch
+# builder. Unknown types keep the legacy from-scratch path (regression-safe).
+_DOCTYPE_TO_PROFILE = {
+    "공문": "official_notice",
+    "공문서": "official_notice",
+    "official_notice": "official_notice",
+    "보고서": "report",
+    "report": "report",
+    "government_report": "report",
+    "가정통신문": "home_notice",
+    "home_notice": "home_notice",
+}
+_DOCTYPE_METADATA_KEYS = (
+    "document_type",
+    "문서 유형",
+    "문서유형",
+    "문서 종류",
+    "문서종류",
+    "documentType",
+)
+# 결문 (closing block) fields in their canonical render order.
+_GYEOLMUN_FIELDS = (
+    ("issuer", "발신명의"),
+    ("productionNumber", "생산등록번호"),
+    ("enforcementDate", "시행일"),
+    ("disclosure", "공개구분"),
+)
+
+
+def _plan_document_type(plan: Any) -> str:
+    """Read the plan's document type from metadata (preferred) or top level."""
+
+    if not isinstance(plan, Mapping):
+        return ""
+    metadata = plan.get("metadata")
+    metadata = metadata if isinstance(metadata, Mapping) else {}
+    for key in _DOCTYPE_METADATA_KEYS:
+        value = metadata.get(key) or plan.get(key)
+        if value:
+            return str(value).strip()
+    return ""
+
+
+def _resolve_design_profile(plan: Any) -> str | None:
+    """Return a committed design profile id for the plan's document_type, or None."""
+
+    raw = _plan_document_type(plan)
+    if not raw:
+        return None
+    from hwpx import design as _design
+
+    profile_id = _DOCTYPE_TO_PROFILE.get(raw)
+    if profile_id and profile_id in _design.available_profiles():
+        return profile_id
+    return None
+
+
+def _bridge_to_design_plan(plan: Mapping[str, Any], profile_id: str):
+    """Lower a document_plan mapping onto a :class:`hwpx.design.plan.DocumentPlan`.
+
+    Heading level 1 -> ``heading`` role, level >= 2 -> ``subheading``; paragraphs
+    and bullet items -> ``body``; tables -> an ``info`` table block. 결문 메타
+    fields are appended as trailing ``body`` blocks in canonical order (P0 proved
+    these survive a Hancom render).
+    """
+
+    from hwpx.design.plan import Block as _Block, DocumentPlan as _DesignPlan
+
+    blocks: list = []
+    for raw in plan.get("blocks") or []:
+        if not isinstance(raw, Mapping):
+            continue
+        block_type = str(raw.get("type") or "paragraph")
+        if block_type == "heading":
+            level = int(raw.get("level") or 1)
+            role = "heading" if level <= 1 else "subheading"
+            blocks.append(_Block(type="paragraph", role=role, text=str(raw.get("text") or "")))
+        elif block_type == "paragraph":
+            blocks.append(_Block(type="paragraph", role="body", text=str(raw.get("text") or "")))
+        elif block_type == "bullets":
+            for item in raw.get("items") or []:
+                blocks.append(_Block(type="paragraph", role="body", text=str(item)))
+        elif block_type == "table":
+            raw_cols = list(raw.get("columns") or raw.get("header") or [])
+            if raw_cols and isinstance(raw_cols[0], Mapping):
+                # document_plan schema: columns=[{key,label}], rows=[{key: value}]
+                keys = [str(c.get("key") or c.get("label") or "") for c in raw_cols]
+                columns = [str(c.get("label") or c.get("key") or "") for c in raw_cols]
+                rows = []
+                for row in raw.get("rows") or []:
+                    if isinstance(row, Mapping):
+                        rows.append([str(row.get(k, "")) for k in keys])
+                    elif isinstance(row, (list, tuple)):
+                        rows.append([str(c) for c in row])
+            else:
+                columns = [str(c) for c in raw_cols]
+                rows = [[str(c) for c in row] for row in (raw.get("rows") or [])]
+            blocks.append(_Block(type="table", role="info", columns=columns, rows=rows))
+        # page_break / memo: no design role -> skipped
+    gyeolmun = plan.get("gyeolmun")
+    if isinstance(gyeolmun, Mapping):
+        for key, label in _GYEOLMUN_FIELDS:
+            value = gyeolmun.get(key)
+            if value:
+                blocks.append(_Block(type="paragraph", role="body", text=f"{label}  {value}"))
+    return _DesignPlan(profile=profile_id, title=str(plan.get("title") or ""), blocks=blocks)
+
+
+def _korean_proofing_status(plan: Any, normalized_plan: "DocumentPlan | None") -> str:
+    """Honest 맞춤법/공공언어 status (Constitution V/IX) — never asserts 'passed'.
+
+    No free offline Korean spell/spacing oracle exists, so the default is
+    ``unverified``. If the plan signals an LLM self-proof pass it is labelled
+    ``llm_proofed_not_oracle_verified`` — proofed, but NOT oracle-verified.
+    """
+
+    metadata: Mapping[str, Any] = {}
+    if isinstance(plan, Mapping) and isinstance(plan.get("metadata"), Mapping):
+        metadata = plan["metadata"]
+    elif normalized_plan is not None:
+        metadata = normalized_plan.metadata
+    signal = str(
+        metadata.get("korean_proofing") or metadata.get("korean_proofing_status") or ""
+    ).strip().lower()
+    if signal in {"llm", "llm_proofed", "llm-proofed", "llm_proofed_not_oracle_verified"}:
+        return "llm_proofed_not_oracle_verified"
+    return "unverified"
+
+
 def create_document_from_plan(
     plan: Mapping[str, Any] | DocumentPlan,
     *,
@@ -881,6 +1013,19 @@ def create_document_from_plan(
 ) -> HwpxDocument:
     """Create a formatted HWPX document from a declarative document plan."""
 
+    if isinstance(plan, Mapping):
+        profile_id = _resolve_design_profile(plan)
+        if profile_id is not None:
+            from hwpx import design as _design
+
+            design_plan = _bridge_to_design_plan(plan, profile_id)
+            data, result = _design.compose_bytes(design_plan, production=True)
+            if not result.ok:
+                raise ValueError(
+                    f"profile compose failed for {profile_id!r}: {result.errors}"
+                )
+            return HwpxDocument.open(data)
+
     normalized = normalize_document_plan(plan)
     if normalized.builder_document is not None:
         return normalized.builder_document.lower()
@@ -952,8 +1097,15 @@ def inspect_document_authoring_quality(
     *,
     plan: Mapping[str, Any] | DocumentPlan | None = None,
     quality_profile: str | Mapping[str, Any] | None = None,
+    verify_render: bool = False,
 ) -> dict[str, Any]:
-    """Return deterministic structural quality evidence for generated HWPX."""
+    """Return deterministic structural quality evidence for generated HWPX.
+
+    When *verify_render* is true AND a Mac Hancom oracle is reachable, the
+    document is rendered and ``render_checked``/``visual_complete`` become real
+    receipts. Otherwise ``render_checked`` is ``False`` and ``visual_complete``
+    is ``"unverified"`` — never a silent true (Constitution V).
+    """
 
     normalized_plan: DocumentPlan | None = None
     plan_validation: dict[str, Any] | None = None
@@ -981,6 +1133,32 @@ def inspect_document_authoring_quality(
         package_report = validate_package(path if path is not None else package_payload)
         document_report = document.validate()
         reopened = _can_reopen(path, package_payload)
+        render_checked = False
+        visual_complete: Any = "unverified"
+        if verify_render:
+            from hwpx.visual import oracle as _oracle
+
+            _mac = _oracle.MacHancomOracle()
+            if _mac.available():
+                import tempfile as _tf
+
+                with _tf.TemporaryDirectory() as _tmp:
+                    _hwpx = Path(_tmp) / "render_check.hwpx"
+                    _hwpx.write_bytes(package_payload)
+                    _pdf = Path(_tmp) / "render_check.pdf"
+                    _rendered = _mac.render_pdf(str(_hwpx), str(_pdf))
+                    if _rendered and Path(_rendered).exists():
+                        try:
+                            import fitz as _fitz
+
+                            _doc = _fitz.open(_rendered)
+                            _has_text = any(pg.get_text().strip() for pg in _doc)
+                            _doc.close()
+                            render_checked = bool(_has_text)
+                            visual_complete = render_checked
+                        except Exception:
+                            render_checked = False
+                            visual_complete = "unverified"
         non_empty_texts = [
             (paragraph.text or "").strip()
             for paragraph in document.paragraphs
@@ -1034,11 +1212,29 @@ def inspect_document_authoring_quality(
             and not profiles["operating_plan"].get("pass", False)
         ):
             gaps.append("operating plan quality failed")
+
+        document_type = ""
+        if isinstance(plan, Mapping):
+            document_type = _plan_document_type(plan)
+        elif normalized_plan is not None:
+            document_type = str(normalized_plan.metadata.get("document_type", "") or "")
+        gongmun_structure: dict[str, Any] | None = None
+        if _DOCTYPE_TO_PROFILE.get(document_type.strip()) == "official_notice":
+            from hwpx.tools.official_lint import (
+                inspect_official_document_style as _gongmun_lint,
+            )
+
+            gongmun_structure = _gongmun_lint(document, document_type="공문")
+            if not gongmun_structure.get("structure_pass", True):
+                gaps.append("공문 structure gate failed")
+        korean_proofing_status = _korean_proofing_status(plan, normalized_plan)
         return {
             "report_version": AUTHORING_REPORT_VERSION,
             "schemaVersion": DOCUMENT_PLAN_SCHEMA_VERSION,
             "plan_validation": plan_validation,
             "pass": not gaps,
+            "korean_proofing_status": korean_proofing_status,
+            "gongmun_structure": gongmun_structure,
             "block_counts": _block_counts(normalized_plan),
             "document": {
                 "paragraph_count": len(document.paragraphs),
@@ -1046,6 +1242,8 @@ def inspect_document_authoring_quality(
                 "table_count": table_count,
                 "page_break_count": page_break_count,
             },
+            "render_checked": render_checked,
+            "visual_complete": visual_complete,
             "validation": {
                 "reopened": reopened,
                 "validate_package": {
@@ -1064,7 +1262,7 @@ def inspect_document_authoring_quality(
             "style_token_usage": style_usage,
             "recovery": recovery,
             "profiles": profiles,
-            "visual_review_required": bool(gates.get("visualReviewRequired", True)),
+            "visual_review_required": bool(gates.get("visualReviewRequired", True)) and not render_checked,
             "gaps": gaps,
         }
     finally:

python_hwpx-2.16.0/src/hwpx/design/profiles/home_notice/fragments/body.xml

@@ -0,0 +1 @@
+<hp:p xmlns:hp="http://www.hancom.co.kr/hwpml/2011/paragraph" id="2147483648" paraPrIDRef="1" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="26"><hp:t>{{body}}</hp:t></hp:run></hp:p>

python_hwpx-2.16.0/src/hwpx/design/profiles/home_notice/fragments/heading.xml

@@ -0,0 +1 @@
+<hp:p xmlns:hp="http://www.hancom.co.kr/hwpml/2011/paragraph" id="2147483648" paraPrIDRef="1" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="25"><hp:t>{{heading}}</hp:t></hp:run></hp:p>

python_hwpx-2.16.0/src/hwpx/design/profiles/home_notice/fragments/title.xml

@@ -0,0 +1 @@
+<hp:p xmlns:hp="http://www.hancom.co.kr/hwpml/2011/paragraph" id="2147483648" paraPrIDRef="25" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="17"><hp:t>{{title}}</hp:t></hp:run></hp:p>

python_hwpx-2.16.0/src/hwpx/design/profiles/home_notice/profile.json

@@ -0,0 +1,24 @@
+{
+  "schemaVersion": "hwpx.design.profile.v1",
+  "id": "home_notice",
+  "template": "template.hwpx",
+  "fragments": {
+    "title": "fragments/title.xml",
+    "heading": "fragments/heading.xml",
+    "body": "fragments/body.xml"
+  },
+  "page": {
+    "width": 59528,
+    "height": 84186,
+    "orientation": "WIDELY",
+    "margins": {
+      "left": 4251,
+      "right": 4251,
+      "top": 1417,
+      "bottom": 0
+    }
+  },
+  "char_pr_count": 54,
+  "style_coverage_threshold": 0.98,
+  "source_basename": "ganghwa_records.hwpx"
+}

{python_hwpx-2.15.0 → python_hwpx-2.16.0}/src/hwpx/tools/official_lint.py

@@ -36,28 +36,48 @@ _ATTACHMENT_RE = re.compile(r"^\s*(?:붙임|첨부)\s+(?:\d+\.\s*)?.+\s+\d+\s*
 _SPACE_BEFORE_PUNCTUATION_RE = re.compile(r"\s+[:?？]")
 
 
-def inspect_official_document_style(source: Any) -> dict[str, Any]:
-    """Inspect official-document conventions in text, plans, or HWPX files."""
+def inspect_official_document_style(
+    source: Any, *, document_type: Any = None
+) -> dict[str, Any]:
+    """Inspect official-document conventions in text, plans, or HWPX files.
+
+    When *document_type* resolves to a 공문 (official outgoing document) the
+    structural spine — 두문(수신)·결문(발신명의·시행·공개구분)·끝. — is enforced at
+    ERROR severity (the hard-gate, ``structure_pass``). Without *document_type*
+    the behaviour is unchanged (backward compatible).
+    """
 
     paragraphs = _paragraphs_from_source(source)
+    is_gongmun = _is_gongmun(document_type)
     violations: list[dict[str, Any]] = []
     violations.extend(_inspect_marker_hierarchy(paragraphs))
-    violations.extend(_inspect_end_marker(paragraphs))
+    if not is_gongmun:
+        # A 시행문 places its 결문(발신명의·시행) AFTER the 끝. marker, so the strict
+        # "끝. must be the final paragraph" rule does not apply to 공문; the
+        # structure gate enforces 끝. presence instead.
+        violations.extend(_inspect_end_marker(paragraphs))
     violations.extend(_inspect_attachment_notation(paragraphs))
     violations.extend(_inspect_dates(paragraphs))
     violations.extend(_inspect_amounts(paragraphs))
     violations.extend(_inspect_spacing(paragraphs))
+    if is_gongmun:
+        violations.extend(_inspect_gongmun_structure(paragraphs))
 
     violation_count = len(violations)
+    error_count = sum(1 for v in violations if v.get("severity") == "error")
     ok = violation_count == 0
+    rules = list(_RULES_CHECKED) + (list(_GONGMUN_STRUCTURE_RULES) if is_gongmun else [])
     return {
         "report_version": OFFICIAL_DOCUMENT_STYLE_REPORT_VERSION,
         "pass": ok,
+        "structure_pass": error_count == 0,
+        "document_type": str(document_type) if document_type else None,
         "score": max(0.0, round(1.0 - (violation_count / 10), 2)),
         "summary": {
             "paragraph_count": len(paragraphs),
             "violation_count": violation_count,
-            "rules_checked": list(_RULES_CHECKED),
+            "error_count": error_count,
+            "rules_checked": rules,
         },
         "violations": violations,
         "repair_hints": [
@@ -71,9 +91,94 @@ def inspect_official_document_style(source: Any) -> dict[str, Any]:
     }
 
 
+_GONGMUN_DOCTYPES = {"공문", "공문서", "official_notice", "시행문"}
+_GONGMUN_STRUCTURE_RULES = (
+    "missing-susin",
+    "missing-balsinmyeongui",
+    "missing-sihaeng",
+    "missing-disclosure",
+    "missing-end-marker",
+)
+_ISSUER_SUFFIX_RE = re.compile(r"(장|관|감)$")
+_DISCLOSURE_RE = re.compile(r"(부분공개|비공개|공개)")
+
+
+def _is_gongmun(document_type: Any) -> bool:
+    return bool(document_type) and str(document_type).strip() in _GONGMUN_DOCTYPES
+
+
+def _norm_spaces(text: str) -> str:
+    return re.sub(r"\s+", "", text)
+
+
+def _inspect_gongmun_structure(paragraphs: Sequence[str]) -> list[dict[str, Any]]:
+    """ERROR-severity 공문 spine checks (the hard-gate), anchored by a real 시행문.
+
+    Reliably machine-checkable from real 시행문: 수신(두문), 시행/공개구분(결문),
+    끝.(본문 종결), and 발신명의 — detected via the literal label OR a 기관장 명의
+    line (space-normalised, ending 장/관/감, not the 수신 recipient line).
+    """
+
+    nonempty = [t.strip() for t in paragraphs if t.strip()]
+    norm = [_norm_spaces(t) for t in nonempty]
+    full_norm = "".join(norm)
+    violations: list[dict[str, Any]] = []
+
+    def err(rule: str, message: str, suggestion: str) -> None:
+        violations.append(
+            _violation(
+                rule=rule,
+                paragraph_index=0,
+                text="",
+                message=message,
+                suggestion=suggestion,
+                severity="error",
+            )
+        )
+
+    if "수신" not in full_norm:
+        err("missing-susin", "공문 두문에 수신(수신자)이 없습니다",
+            "두문에 '수신  <수신자>'를 추가하세요.")
+    if "시행" not in full_norm:
+        err("missing-sihaeng", "공문 결문에 시행 정보가 없습니다",
+            "결문에 '시행  <처리과-일련번호> (<시행일자>)'를 추가하세요.")
+    if not _DISCLOSURE_RE.search(full_norm):
+        err("missing-disclosure", "공문 결문에 공개구분이 없습니다",
+            "결문에 공개구분(공개/부분공개/비공개)을 추가하세요.")
+    if "끝." not in full_norm:
+        err("missing-end-marker", "공문 본문에 끝 표시(끝.)가 없습니다",
+            "본문/붙임 마지막에 '끝.'을 두세요.")
+    has_label = "발신명의" in full_norm
+    has_issuer = any(
+        _ISSUER_SUFFIX_RE.search(t) and len(t) >= 3 and "수신" not in t and not t.endswith(")")
+        for t in norm
+    )
+    if not (has_label or has_issuer):
+        err("missing-balsinmyeongui", "공문 결문에 발신명의(기관장 명의)가 없습니다",
+            "결문에 발신명의(예: ○○교육지원청교육장)를 추가하세요.")
+    return violations
+
+
+def _document_paragraph_texts(paragraphs: Any) -> list[str]:
+    """Flatten paragraph text including nested table-cell text.
+
+    Real 시행문 carry the 두문(수신·경유) and 결문(발신명의·시행·공개구분) inside
+    tables, which top-level ``document.paragraphs`` does not descend into.
+    """
+
+    texts: list[str] = []
+    for paragraph in paragraphs:
+        texts.append(paragraph.text)
+        for table in getattr(paragraph, "tables", ()):
+            for row in table.rows:
+                for cell in row.cells:
+                    texts.extend(_document_paragraph_texts(cell.paragraphs))
+    return texts
+
+
 def _paragraphs_from_source(source: Any) -> list[str]:
     if isinstance(source, HwpxDocument):
-        return [paragraph.text for paragraph in source.paragraphs]
+        return _document_paragraph_texts(source.paragraphs)
     if isinstance(source, Path):
         return _paragraphs_from_path(source)
     if isinstance(source, str):
@@ -96,7 +201,7 @@ def _paragraphs_from_source(source: Any) -> list[str]:
 def _paragraphs_from_path(path: Path) -> list[str]:
     document = HwpxDocument.open(path)
     try:
-        return [paragraph.text for paragraph in document.paragraphs]
+        return _document_paragraph_texts(document.paragraphs)
     finally:
         document.close()
 

{python_hwpx-2.15.0 → python_hwpx-2.16.0/src/python_hwpx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hwpx
-Version: 2.15.0
+Version: 2.16.0
 Summary: 한글 없이 HWPX 문서를 열고, 편집하고, 생성하고, 검증하는 Python 자동화 라이브러리
 Author: python-hwpx Maintainers
 License-Expression: Apache-2.0

{python_hwpx-2.15.0 → python_hwpx-2.16.0}/src/python_hwpx.egg-info/SOURCES.txt

@@ -38,6 +38,11 @@ src/hwpx/design/profiles/application_form/fragments/body.xml
 src/hwpx/design/profiles/application_form/fragments/heading.xml
 src/hwpx/design/profiles/application_form/fragments/info_table.xml
 src/hwpx/design/profiles/application_form/fragments/title.xml
+src/hwpx/design/profiles/home_notice/profile.json
+src/hwpx/design/profiles/home_notice/template.hwpx
+src/hwpx/design/profiles/home_notice/fragments/body.xml
+src/hwpx/design/profiles/home_notice/fragments/heading.xml
+src/hwpx/design/profiles/home_notice/fragments/title.xml
 src/hwpx/design/profiles/official_notice/profile.json
 src/hwpx/design/profiles/official_notice/template.hwpx
 src/hwpx/design/profiles/official_notice/fragments/body.xml
@@ -151,6 +156,9 @@ src/python_hwpx.egg-info/entry_points.txt
 src/python_hwpx.egg-info/requires.txt
 src/python_hwpx.egg-info/top_level.txt
 tests/test_advanced_generators.py
+tests/test_authoring_profile_routing.py
+tests/test_authoring_profile_routing_oracle.py
+tests/test_authoring_render_check.py
 tests/test_builder_core.py
 tests/test_builder_plan_v2.py
 tests/test_builder_vertical_slice.py
@@ -205,6 +213,8 @@ tests/test_memo_and_style_editing.py
 tests/test_namespace_handling.py
 tests/test_new_features.py
 tests/test_official_document_style.py
+tests/test_official_lint_gongmun_gate.py
+tests/test_official_lint_tableaware.py
 tests/test_opc_package.py
 tests/test_open_safety_corpus.py
 tests/test_oxml_parsing.py

python_hwpx-2.16.0/tests/test_authoring_profile_routing.py

@@ -0,0 +1,148 @@
+# SPDX-License-Identifier: Apache-2.0
+"""M3 P1 — document_type -> design profile routing + 결문 IR bridge."""
+from __future__ import annotations
+
+from hwpx.authoring import (
+    _resolve_design_profile,
+    _bridge_to_design_plan,
+    create_document_from_plan,
+)
+from hwpx.design.plan import DocumentPlan as DesignPlan
+from hwpx.document import HwpxDocument
+
+
+def _plan(**over):
+    base = {
+        "schemaVersion": "hwpx.document_plan.v1",
+        "title": "교육협력 사업 추진 협조 요청",
+        "metadata": {"document_type": "공문"},
+        "blocks": [
+            {"type": "heading", "level": 1, "text": "1. 관련"},
+            {"type": "paragraph", "text": "가. 협조하여 주시기 바랍니다.  끝."},
+        ],
+    }
+    base.update(over)
+    return base
+
+
+# --- Task 1: resolver ---
+def test_resolve_known_korean_types():
+    assert _resolve_design_profile(_plan()) == "official_notice"
+    assert _resolve_design_profile(_plan(metadata={"document_type": "보고서"})) == "report"
+    assert _resolve_design_profile(_plan(metadata={"document_type": "가정통신문"})) == "home_notice"
+
+
+def test_resolve_profile_id_direct():
+    assert _resolve_design_profile(_plan(metadata={"document_type": "official_notice"})) == "official_notice"
+
+
+def test_resolve_unknown_returns_none():
+    assert _resolve_design_profile(_plan(metadata={"document_type": "메모"})) is None
+    assert _resolve_design_profile(_plan(metadata={})) is None
+
+
+# --- Task 2: bridge ---
+def test_bridge_maps_title_and_roles():
+    dp = _bridge_to_design_plan(_plan(), "official_notice")
+    assert isinstance(dp, DesignPlan)
+    assert dp.profile == "official_notice"
+    assert dp.title == "교육협력 사업 추진 협조 요청"
+    roles = [(b.type, b.role) for b in dp.blocks]
+    assert ("paragraph", "heading") in roles
+    assert ("paragraph", "body") in roles
+
+
+def test_bridge_level2_is_subheading():
+    dp = _bridge_to_design_plan(_plan(blocks=[{"type": "heading", "level": 2, "text": "x"}]), "report")
+    assert ("paragraph", "subheading") in [(b.type, b.role) for b in dp.blocks]
+
+
+def test_bridge_converts_mapping_table():
+    # document_plan tables are mapping-based: columns=[{key,label}], rows=[{key:value}]
+    plan = _plan(blocks=[{
+        "type": "table",
+        "columns": [{"key": "dept", "label": "부서"}, {"key": "rate", "label": "달성률"}],
+        "rows": [{"dept": "기획부", "rate": "100%"}, {"dept": "운영부", "rate": "93%"}],
+    }])
+    dp = _bridge_to_design_plan(plan, "report")
+    table = [b for b in dp.blocks if b.type == "table"][0]
+    assert table.columns == ["부서", "달성률"]
+    assert table.rows == [["기획부", "100%"], ["운영부", "93%"]]
+
+
+def test_bridge_bullets_become_body():
+    dp = _bridge_to_design_plan(
+        _plan(blocks=[{"type": "bullets", "items": ["가. 첫째", "나. 둘째"]}]), "official_notice"
+    )
+    bodies = [b.text for b in dp.blocks if b.role == "body"]
+    assert "가. 첫째" in bodies and "나. 둘째" in bodies
+
+
+# --- Task 3: 결문 메타 ---
+def test_bridge_appends_gyeolmun():
+    plan = _plan(gyeolmun={
+        "issuer": "○○교육지원청교육장",
+        "productionNumber": "교육협력과-123",
+        "enforcementDate": "2026. 6. 27.",
+        "disclosure": "공개",
+    })
+    dp = _bridge_to_design_plan(plan, "official_notice")
+    texts = " ".join(b.text for b in dp.blocks)
+    assert "○○교육지원청교육장" in texts
+    assert "교육협력과-123" in texts
+    assert "2026. 6. 27." in texts
+    assert "공개" in texts
+
+
+# --- Task 4: route (contract preserved) ---
+def test_gongmun_routes_to_profile_and_opens():
+    doc = create_document_from_plan(_plan())
+    assert isinstance(doc, HwpxDocument)
+    text = "\n".join(p.text for p in doc.paragraphs)
+    assert "협조" in text
+    doc.close()
+
+
+def test_unknown_type_uses_from_scratch_path():
+    doc = create_document_from_plan(_plan(metadata={"document_type": "메모"}))
+    assert isinstance(doc, HwpxDocument)
+    doc.close()
+
+
+# --- Task 3: authoring quality surfaces 공문 gate + korean_proofing_status ---
+def _quality_of(plan):
+    import tempfile
+    from pathlib import Path
+    from hwpx.authoring import inspect_document_authoring_quality
+
+    doc = create_document_from_plan(plan)
+    with tempfile.TemporaryDirectory() as tmp:
+        f = Path(tmp) / "g.hwpx"
+        doc.save_to_path(str(f))
+        doc.close()
+        return inspect_document_authoring_quality(str(f), plan=plan)
+
+
+def test_quality_surfaces_gongmun_structure_and_proofing():
+    plan = _plan(
+        blocks=[{"type": "paragraph", "text": "수신  각급학교장"},
+                {"type": "heading", "level": 1, "text": "1. 관련"},
+                {"type": "paragraph", "text": "가. 협조하여 주시기 바랍니다.  끝."}],
+        gyeolmun={"issuer": "○○교육지원청교육장", "enforcementDate": "2026. 6. 27.", "disclosure": "공개"},
+    )
+    rep = _quality_of(plan)
+    assert rep["korean_proofing_status"] == "unverified"
+    assert rep["gongmun_structure"] is not None
+    assert rep["gongmun_structure"]["structure_pass"] is True
+
+
+def test_quality_proofing_llm_label():
+    plan = _plan(
+        metadata={"document_type": "공문", "korean_proofing": "llm_proofed"},
+        blocks=[{"type": "paragraph", "text": "수신  각급학교장"},
+                {"type": "heading", "level": 1, "text": "1. 관련"},
+                {"type": "paragraph", "text": "가. 협조.  끝."}],
+        gyeolmun={"issuer": "○○교육지원청교육장", "enforcementDate": "2026. 6. 27.", "disclosure": "공개"},
+    )
+    rep = _quality_of(plan)
+    assert rep["korean_proofing_status"] == "llm_proofed_not_oracle_verified"