@litfamily/litclaude 1.0.10 → 1.0.13

package/plugins/litclaude/skills/lit-docx/scripts/generate_docx_templates.py

@@ -0,0 +1,500 @@
+#!/usr/bin/env python3
+"""Generate publisher-style DOCX templates from templates/registry.yaml.
+
+Data-driven: every publisher defined in the registry becomes
+``templates/docx/<publisher>.docx``. Safe to re-run; output is idempotent in
+content (docx zip metadata may differ across runs, but word/document.xml and
+word/styles.xml content are stable).
+
+Usage:
+    python scripts/generate_docx_templates.py
+    python scripts/generate_docx_templates.py --publisher elsevier
+    python scripts/generate_docx_templates.py --registry path/to/registry.yaml --out-dir path/to/docx
+"""
+from __future__ import annotations
+
+import os as _os
+import sys as _sys
+
+_sys.dont_write_bytecode = True  # the installed skill directory stays read-only
+_sys.path.insert(0, _os.path.join(_os.path.dirname(_os.path.abspath(__file__)), "..", "..", "..", "lib"))
+from office_runtime_bootstrap import ensure_runtime  # noqa: E402
+
+ensure_runtime(["docx", "yaml"])
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Any
+
+try:
+    import yaml
+except ImportError:
+    print("Error: 'pyyaml' not found. pip install pyyaml", file=sys.stderr)
+    raise
+
+try:
+    from docx import Document
+    from docx.enum.style import WD_STYLE_TYPE
+    from docx.enum.text import WD_ALIGN_PARAGRAPH, WD_LINE_SPACING
+    from docx.oxml import OxmlElement
+    from docx.oxml.ns import qn
+    from docx.shared import Cm, Pt, RGBColor
+except ImportError:
+    print("Error: 'python-docx' not found. pip install python-docx", file=sys.stderr)
+    raise
+
+
+# ---------------------------------------------------------------------------
+# OOXML helpers (python-docx high-level API does not cover these)
+# ---------------------------------------------------------------------------
+
+
+def set_fonts_on_rpr(rpr, latin: str, cjk: str | None) -> None:
+    """Apply w:rFonts (ascii/hAnsi/cs + optional eastAsia) to an rPr element."""
+    rfonts = rpr.find(qn("w:rFonts"))
+    if rfonts is None:
+        rfonts = OxmlElement("w:rFonts")
+        rpr.append(rfonts)
+    rfonts.set(qn("w:ascii"), latin)
+    rfonts.set(qn("w:hAnsi"), latin)
+    rfonts.set(qn("w:cs"), latin)
+    if cjk:
+        rfonts.set(qn("w:eastAsia"), cjk)
+
+
+def set_style_fonts(style, latin: str, cjk: str | None) -> None:
+    """Set ascii+hAnsi+cs+eastAsia on a style's rPr."""
+    element = style.element
+    rpr = element.find(qn("w:rPr"))
+    if rpr is None:
+        rpr = OxmlElement("w:rPr")
+        element.append(rpr)
+    set_fonts_on_rpr(rpr, latin, cjk)
+
+
+def set_run_fonts(run, latin: str, cjk: str | None) -> None:
+    """Set ascii+hAnsi+cs+eastAsia on a run's rPr."""
+    rpr = run._element.get_or_add_rPr()
+    set_fonts_on_rpr(rpr, latin, cjk)
+
+
+def ensure_ppr(element):
+    ppr = element.find(qn("w:pPr"))
+    if ppr is None:
+        ppr = OxmlElement("w:pPr")
+        element.insert(0, ppr)
+    return ppr
+
+
+def set_style_widow_control(style) -> None:
+    ppr = ensure_ppr(style.element)
+    wc = ppr.find(qn("w:widowControl"))
+    if wc is None:
+        wc = OxmlElement("w:widowControl")
+        ppr.append(wc)
+    wc.set(qn("w:val"), "1")
+
+
+def set_style_hanging_indent(style, hanging_cm: float) -> None:
+    """Set hanging indent on a paragraph style (twips)."""
+    ppr = ensure_ppr(style.element)
+    ind = ppr.find(qn("w:ind"))
+    if ind is None:
+        ind = OxmlElement("w:ind")
+        ppr.append(ind)
+    # hanging requires left >= hanging for Word to render properly
+    twips = int(round(hanging_cm * 567))
+    ind.set(qn("w:left"), str(twips))
+    ind.set(qn("w:hanging"), str(twips))
+
+
+def enable_auto_hyphenation(doc) -> None:
+    settings = doc.settings.element
+    if settings.find(qn("w:autoHyphenation")) is None:
+        settings.append(OxmlElement("w:autoHyphenation"))
+
+
+def set_section_page(section, page_cfg: dict, title_pg: bool) -> None:
+    """Set page size (A4) and margins from the registry.
+
+    python-docx exposes Section.page_width/page_height/margins. We use those
+    for the high-level attributes and drop in w:titlePg if first_page_different.
+    """
+    size = (page_cfg.get("size") or "A4").upper()
+    if size == "A4":
+        section.page_width = Cm(21.0)
+        section.page_height = Cm(29.7)
+    elif size == "LETTER":
+        section.page_width = Cm(21.59)
+        section.page_height = Cm(27.94)
+    section.top_margin = Cm(page_cfg.get("margin_top_cm", 2.5))
+    section.bottom_margin = Cm(page_cfg.get("margin_bottom_cm", 2.5))
+    section.left_margin = Cm(page_cfg.get("margin_left_cm", 2.5))
+    section.right_margin = Cm(page_cfg.get("margin_right_cm", 2.5))
+    if title_pg:
+        sect_pr = section._sectPr
+        if sect_pr.find(qn("w:titlePg")) is None:
+            sect_pr.append(OxmlElement("w:titlePg"))
+
+
+# ---------------------------------------------------------------------------
+# Style builders
+# ---------------------------------------------------------------------------
+
+
+def configure_normal_style(doc, publisher: dict) -> int:
+    """Configure Normal style: body font, CJK pairing, indent/justify/line-spacing."""
+    body = publisher["docx"]["font"]["body"]
+    body_cjk = publisher["docx"]["font"].get("body_cjk") or {}
+    design = publisher["design"]
+    para_cfg = design["paragraph"]
+
+    style = doc.styles["Normal"]
+    style.font.name = body["family"]
+    style.font.size = Pt(body["size_pt"])
+    set_style_fonts(style, body["family"], body_cjk.get("family"))
+
+    pf = style.paragraph_format
+    indent_cm = para_cfg.get("first_line_indent_cm", 0)
+    if indent_cm:
+        pf.first_line_indent = Cm(indent_cm)
+    line_spacing = para_cfg.get("line_spacing") or body.get("line_spacing") or 1.15
+    pf.line_spacing = float(line_spacing)
+    pf.line_spacing_rule = WD_LINE_SPACING.MULTIPLE
+    pf.space_before = Pt(para_cfg.get("space_before_pt", 0))
+    pf.space_after = Pt(para_cfg.get("space_after_pt", 0))
+    if para_cfg.get("alignment") == "justify":
+        pf.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+    elif para_cfg.get("alignment") == "left":
+        pf.alignment = WD_ALIGN_PARAGRAPH.LEFT
+    if para_cfg.get("widow_control"):
+        set_style_widow_control(style)
+    return 1
+
+
+def suppress_style_numbering(style) -> None:
+    """Force-disable any list or outline numbering on a paragraph style.
+
+    Some readers (LibreOffice in particular) auto-apply a bullet / chapter
+    marker to paragraphs whose style carries `w:outlineLvl` unless an explicit
+    `w:numPr` with `numId=0` is set. `numId=0` is the OOXML sentinel for
+    "no numbering". Set it on both ilvl and numId to override inheritance from
+    any ancestor style.
+    """
+    ppr = style.element.find(qn("w:pPr"))
+    if ppr is None:
+        ppr = OxmlElement("w:pPr")
+        style.element.append(ppr)
+    # Remove any pre-existing numPr first (idempotent regenerate)
+    for existing in ppr.findall(qn("w:numPr")):
+        ppr.remove(existing)
+    num_pr = OxmlElement("w:numPr")
+    ilvl = OxmlElement("w:ilvl")
+    ilvl.set(qn("w:val"), "0")
+    num_id = OxmlElement("w:numId")
+    num_id.set(qn("w:val"), "0")
+    num_pr.append(ilvl)
+    num_pr.append(num_id)
+    ppr.append(num_pr)
+
+
+def configure_heading_styles(doc, publisher: dict) -> int:
+    """Override Heading 1..4 with publisher hierarchy values."""
+    body = publisher["docx"]["font"]["body"]
+    body_cjk = publisher["docx"]["font"].get("body_cjk") or {}
+    latin = body["family"]
+    cjk = body_cjk.get("family")
+    hh = publisher["design"]["heading_hierarchy"]
+    touched = 0
+    for level, key in enumerate(["h1", "h2", "h3", "h4"], start=1):
+        cfg = hh.get(key)
+        if cfg is None:
+            continue
+        style = doc.styles[f"Heading {level}"]
+        style.font.name = latin
+        style.font.size = Pt(cfg["size_pt"])
+        weight = cfg.get("weight", "regular")
+        style.font.bold = weight in ("bold", "semibold")
+        style.font.italic = bool(cfg.get("italic", False))
+        # All headings black (color discipline)
+        style.font.color.rgb = RGBColor(0x00, 0x00, 0x00)
+        set_style_fonts(style, latin, cjk)
+
+        pf = style.paragraph_format
+        pf.space_before = Pt(cfg.get("space_before_pt", 12))
+        pf.space_after = Pt(cfg.get("space_after_pt", 4))
+        pf.keep_with_next = bool(cfg.get("keep_with_next", True))
+        pf.keep_together = True
+
+        # Hard-disable any inherited list/outline numbering so readers never
+        # render a bullet or chapter marker in front of the heading text.
+        suppress_style_numbering(style)
+        touched += 1
+    return touched
+
+
+def configure_hyperlink_style(doc, publisher: dict) -> int:
+    """Override (or create) Hyperlink character style with publisher link color."""
+    link_hex = publisher["design"]["color_palette"]["link"].lstrip("#")
+    # On a blank Document, 'Hyperlink' char style exists after the first
+    # hyperlink is inserted. We ensure it exists by creating it defensively.
+    try:
+        style = doc.styles["Hyperlink"]
+    except KeyError:
+        style = doc.styles.add_style("Hyperlink", WD_STYLE_TYPE.CHARACTER)
+    style.font.color.rgb = RGBColor.from_string(link_hex)
+    style.font.underline = True
+    # Also set via OOXML so it persists on all readers
+    rpr = style.element.find(qn("w:rPr"))
+    if rpr is None:
+        rpr = OxmlElement("w:rPr")
+        style.element.append(rpr)
+    color = rpr.find(qn("w:color"))
+    if color is None:
+        color = OxmlElement("w:color")
+        rpr.append(color)
+    color.set(qn("w:val"), link_hex)
+    return 1
+
+
+def configure_bibliography_style(doc, publisher: dict) -> int:
+    """Create a 'Bibliography' paragraph style with hanging indent."""
+    body = publisher["docx"]["font"]["body"]
+    body_cjk = publisher["docx"]["font"].get("body_cjk") or {}
+    bib = publisher["design"]["bibliography"]
+    if "Bibliography" in [s.name for s in doc.styles]:
+        style = doc.styles["Bibliography"]
+    else:
+        style = doc.styles.add_style("Bibliography", WD_STYLE_TYPE.PARAGRAPH)
+    style.base_style = doc.styles["Normal"]
+    style.font.name = body["family"]
+    style.font.size = Pt(bib.get("font_size_pt", 10))
+    set_style_fonts(style, body["family"], body_cjk.get("family"))
+    pf = style.paragraph_format
+    pf.line_spacing = float(bib.get("line_spacing", 1.15))
+    pf.space_after = Pt(bib.get("space_between_entries_pt", 6))
+    pf.first_line_indent = None  # hanging indent instead
+    set_style_hanging_indent(style, bib.get("hanging_indent_cm", 0.6))
+    return 1
+
+
+def configure_caption_style(doc, publisher: dict) -> int:
+    body = publisher["docx"]["font"]["body"]
+    body_cjk = publisher["docx"]["font"].get("body_cjk") or {}
+    # python-docx's blank document does include a 'Caption' style; if not, make it.
+    try:
+        style = doc.styles["Caption"]
+    except KeyError:
+        style = doc.styles.add_style("Caption", WD_STYLE_TYPE.PARAGRAPH)
+    style.font.name = body["family"]
+    style.font.size = Pt(publisher["design"]["figure_style"].get("caption_font_size_pt", 10))
+    style.font.italic = True
+    style.font.color.rgb = RGBColor(0x00, 0x00, 0x00)
+    set_style_fonts(style, body["family"], body_cjk.get("family"))
+    return 1
+
+
+# ---------------------------------------------------------------------------
+# Self-describing title block sample
+# ---------------------------------------------------------------------------
+
+
+def add_sample_title_block(doc, publisher: dict) -> None:
+    """Add title/authors/affiliations/abstract/keywords placeholders."""
+    design = publisher["design"]
+    tb = design["title_block"]
+    body = publisher["docx"]["font"]["body"]
+    body_cjk = publisher["docx"]["font"].get("body_cjk") or {}
+    latin = body["family"]
+    cjk = body_cjk.get("family")
+
+    def _p(text: str, *, size: int, bold: bool = False, italic: bool = False,
+           align=WD_ALIGN_PARAGRAPH.CENTER, space_after: int = 4) -> None:
+        p = doc.add_paragraph()
+        p.alignment = align
+        p.paragraph_format.first_line_indent = Cm(0)
+        p.paragraph_format.space_after = Pt(space_after)
+        run = p.add_run(text)
+        run.font.name = latin
+        run.font.size = Pt(size)
+        run.bold = bold
+        run.italic = italic
+        set_run_fonts(run, latin, cjk)
+
+    _p("Manuscript Title — replace with your title",
+       size=tb["title"]["size_pt"], bold=True,
+       space_after=tb["title"].get("space_after_pt", 12))
+
+    # Authors paragraph with superscript affiliation markers
+    authors_p = doc.add_paragraph()
+    authors_p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    authors_p.paragraph_format.first_line_indent = Cm(0)
+    authors_p.paragraph_format.space_after = Pt(tb["authors"].get("space_after_pt", 4))
+    sep = tb.get("author_separator", ", ")
+    samples = [("Author One", "1", True), ("Author Two", "2", False)]
+    for idx, (name, aff, corr) in enumerate(samples):
+        if idx > 0:
+            sep_run = authors_p.add_run(sep)
+            sep_run.font.name = latin
+            sep_run.font.size = Pt(tb["authors"]["size_pt"])
+            set_run_fonts(sep_run, latin, cjk)
+        name_run = authors_p.add_run(name)
+        name_run.font.name = latin
+        name_run.font.size = Pt(tb["authors"]["size_pt"])
+        set_run_fonts(name_run, latin, cjk)
+        sup_run = authors_p.add_run(aff)
+        sup_run.font.superscript = True
+        sup_run.font.name = latin
+        sup_run.font.size = Pt(tb["authors"]["size_pt"])
+        set_run_fonts(sup_run, latin, cjk)
+        if corr:
+            star = authors_p.add_run(tb.get("corresponding_marker", "*"))
+            star.font.superscript = True
+            star.font.name = latin
+            set_run_fonts(star, latin, cjk)
+
+    _p("¹ Affiliation one — department, institution, city, country",
+       size=tb["affiliations"]["size_pt"], italic=True, space_after=2)
+    _p("² Affiliation two — department, institution, city, country",
+       size=tb["affiliations"]["size_pt"], italic=True,
+       space_after=tb["affiliations"].get("space_after_pt", 8))
+
+    # Abstract label + placeholder
+    ap = doc.add_paragraph()
+    ap.paragraph_format.first_line_indent = Cm(0)
+    ap.paragraph_format.space_after = Pt(4)
+    lab = ap.add_run(tb.get("abstract_label", "Abstract"))
+    lab.bold = True
+    lab.font.name = latin
+    lab.font.size = Pt(tb.get("abstract_font_size_pt", 10))
+    set_run_fonts(lab, latin, cjk)
+
+    abs_p = doc.add_paragraph()
+    abs_p.paragraph_format.first_line_indent = Cm(0)
+    abs_p.paragraph_format.space_after = Pt(6)
+    abs_run = abs_p.add_run(
+        "Replace this paragraph with your abstract. Keep it focused on the "
+        "problem, approach, key results, and implications. Straight quotes, "
+        "hyphens-as-dashes, and missing nbsp before units will be auto-fixed "
+        "by convert_md_to_docx.py when --publisher is set."
+    )
+    abs_run.font.name = latin
+    abs_run.font.size = Pt(tb.get("abstract_font_size_pt", 10))
+    set_run_fonts(abs_run, latin, cjk)
+
+    kw_p = doc.add_paragraph()
+    kw_p.paragraph_format.first_line_indent = Cm(0)
+    kw_p.paragraph_format.space_after = Pt(12)
+    lab2 = kw_p.add_run(tb.get("keywords_label", "Keywords") + ": ")
+    lab2.bold = True
+    lab2.font.name = latin
+    lab2.font.size = Pt(tb.get("abstract_font_size_pt", 10))
+    set_run_fonts(lab2, latin, cjk)
+    kw_val = kw_p.add_run("keyword1; keyword2; keyword3")
+    kw_val.font.name = latin
+    kw_val.font.size = Pt(tb.get("abstract_font_size_pt", 10))
+    set_run_fonts(kw_val, latin, cjk)
+
+
+# ---------------------------------------------------------------------------
+# Main build
+# ---------------------------------------------------------------------------
+
+
+def build_template(publisher_key: str, publisher: dict, out_path: Path) -> int:
+    doc = Document()
+
+    # Page geometry (first section)
+    section = doc.sections[0]
+    page_cfg = publisher["docx"]["page"]
+    hf = publisher["design"]["header_footer"]
+    set_section_page(section, page_cfg, title_pg=bool(hf.get("first_page_different")))
+
+    # Auto-hyphenation
+    enable_auto_hyphenation(doc)
+
+    # Style configuration
+    style_count = 0
+    style_count += configure_normal_style(doc, publisher)
+    style_count += configure_heading_styles(doc, publisher)
+    style_count += configure_hyperlink_style(doc, publisher)
+    style_count += configure_bibliography_style(doc, publisher)
+    style_count += configure_caption_style(doc, publisher)
+
+    # Self-describing sample title block
+    add_sample_title_block(doc, publisher)
+
+    # Sample section heading so Heading 1 style is exercised
+    sh = doc.add_paragraph("1 Introduction", style="Heading 1")
+    sh_body = doc.add_paragraph(
+        "Replace this paragraph with your manuscript body. This template was "
+        "generated from templates/registry.yaml — do not hand-edit. To update "
+        "style, edit the registry and rerun scripts/generate_docx_templates.py."
+    )
+    sh_body.paragraph_format.first_line_indent = Cm(
+        publisher["design"]["paragraph"].get("first_line_indent_cm", 0.5)
+    )
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    doc.save(str(out_path))
+    return style_count
+
+
+def load_registry(path: Path) -> dict:
+    with path.open("r", encoding="utf-8") as fh:
+        data = yaml.safe_load(fh)
+    if "publishers" not in data:
+        raise SystemExit(f"registry {path} missing top-level 'publishers' key")
+    return data
+
+
+def parse_args() -> argparse.Namespace:
+    script_dir = Path(__file__).resolve().parent
+    default_registry = script_dir.parent / "templates" / "registry.yaml"
+    default_out = script_dir.parent / "templates" / "docx"
+
+    p = argparse.ArgumentParser(description="Generate publisher DOCX templates")
+    p.add_argument("--publisher", help="Only generate this publisher (default: all)")
+    p.add_argument("--registry", default=str(default_registry),
+                   help=f"Path to registry.yaml (default: {default_registry})")
+    p.add_argument("--out-dir", default=str(default_out),
+                   help=f"Output directory for .docx files (default: {default_out})")
+    return p.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    registry_path = Path(args.registry).expanduser().resolve()
+    out_dir = Path(args.out_dir).expanduser().resolve()
+
+    if not registry_path.exists():
+        print(f"Error: registry not found: {registry_path}", file=sys.stderr)
+        return 1
+
+    registry = load_registry(registry_path)
+    publishers = registry["publishers"]
+
+    if args.publisher:
+        if args.publisher not in publishers:
+            print(f"Error: publisher {args.publisher!r} not in registry "
+                  f"(known: {', '.join(publishers)})", file=sys.stderr)
+            return 1
+        targets = {args.publisher: publishers[args.publisher]}
+    else:
+        targets = publishers
+
+    for key, publisher in targets.items():
+        out_path = out_dir / f"{key}.docx"
+        n = build_template(key, publisher, out_path)
+        rel = out_path
+        try:
+            rel = out_path.relative_to(Path.cwd())
+        except ValueError:
+            pass
+        print(f"generated {rel} ({n} styles applied)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/plugins/litclaude/skills/lit-docx/scripts/qa_docx.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""qa_docx.py — one pass/fail gate for a generated .docx and its Markdown source.
+
+The document counterpart of lit-pptx's qa_deck.py. It combines:
+
+  1. Integrity  — plugins/litclaude/lib/ooxml_integrity.py (the package opens,
+                  relationships resolve, no NaN attribute values, python-docx reopens)
+  2. Prose lint — slop_lint rules on the Markdown source (AI-tell phrases, hedging
+                  pile-ups, stock openers/closers, adjective stacks, Korean rules);
+                  --kind report drops the journal-manuscript outline rules
+  3. Design     — slop_lint's DOCX audit (banned fonts, profile margins, booktabs
+                  tables, highlights, tracked changes, ASCII ellipsis) and the Hangul
+                  eastAsia font pairing check
+  4. Content    — the document has body text, every Markdown heading reached it, no
+                  unfilled blank ([제품명], [금액], XXX, TBD, ○○, {{…}}) is left, and
+                  no YAML frontmatter leaked into the body
+
+Rendering is separate (visual_audit.py) because it needs soffice; a clean gate
+is defect-absence, not a verdict on how the pages read.
+
+Usage:
+    python3 qa_docx.py out.docx --source draft.md --publisher korean-generic [--kind report]
+    python3 qa_docx.py out.docx --source draft.md                       # plain profile
+
+Prints JSON; exit 0 on PASS, 1 on FAIL.
+"""
+
+from __future__ import annotations
+
+import os as _os
+import sys as _sys
+
+_sys.dont_write_bytecode = True  # the installed skill directory stays read-only
+_sys.path.insert(0, _os.path.join(_os.path.dirname(_os.path.abspath(__file__)), "..", "..", "..", "lib"))
+from office_runtime_bootstrap import ensure_runtime  # noqa: E402
+
+ensure_runtime(["docx", "markdown", "bs4", "yaml"])
+
+import argparse  # noqa: E402
+import json  # noqa: E402
+import re  # noqa: E402
+from pathlib import Path  # noqa: E402
+
+from docx import Document  # noqa: E402
+from ooxml_integrity import check_package  # noqa: E402
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+_sys.path.insert(0, str(SCRIPT_DIR))
+import slop_lint  # noqa: E402
+
+HEADING = re.compile(r"^(#{1,6})\s+(.+?)\s*#*\s*$")
+# A bracket with a digit in it is a citation marker ([1], [S3]); a blank has none.
+PLACEHOLDER = re.compile(
+    r"\[(?![^\]\n]*\d)[^\]\n]{1,24}\]|\bX{3,}\b|\bTBD\b|\bTODO\b|○○|OOO|\{\{[^}]*\}\}|_{4,}|＿{2,}"
+)
+FRONTMATTER_LEAK = re.compile(r"^(?:---|title:|author:|authors:|date:|subtitle:)\s*", re.M)
+
+
+def source_headings(markdown_text: str) -> list[str]:
+    headings, in_fence = [], False
+    for line in markdown_text.splitlines():
+        if line.lstrip().startswith(("```", "~~~")):
+            in_fence = not in_fence
+            continue
+        match = None if in_fence else HEADING.match(line)
+        if match:
+            headings.append(re.sub(r"[*_`]", "", match.group(2)).strip())
+    return headings
+
+
+def check_content(docx_path: Path, markdown_text: str | None) -> dict:
+    document = Document(str(docx_path))
+    paragraphs = [p.text.strip() for p in document.paragraphs if p.text.strip()]
+    body_chars = sum(len(p) for p in paragraphs) + sum(
+        len(cell.text) for table in document.tables for row in table.rows for cell in row.cells
+    )
+    cells = [cell.text for table in document.tables for row in table.rows for cell in row.cells]
+    blanks = sorted({m.group(0) for text in paragraphs + cells for m in PLACEHOLDER.finditer(text)})
+    leaked = [p for p in paragraphs[:8] if FRONTMATTER_LEAK.match(p)]
+    missing = []
+    if markdown_text:
+        text = "\n".join(paragraphs)
+        for heading in source_headings(markdown_text):
+            if heading not in text:
+                missing.append(heading)
+    return {
+        "pass": body_chars > 0 and not missing and not blanks and not leaked,
+        "placeholders": blanks[:20],
+        "frontmatter_leak": leaked[:4],
+        "paragraphs": len(paragraphs),
+        "tables": len(document.tables),
+        "body_chars": body_chars,
+        "missing_headings": missing[:20],
+    }
+
+
+def lint(source: Path | None, docx_path: Path, publisher_name: str, kind: str) -> dict:
+    registry = SCRIPT_DIR.parent / "templates" / "registry.yaml"
+    phrase_rules = slop_lint.load_phrase_rules(SCRIPT_DIR.parent / "references" / "slop_phrase_list.yaml")
+    publisher = slop_lint.load_publisher(registry, publisher_name)
+    findings = []
+    locale = "auto"
+    if source is not None:
+        found, _front, _body, locale = slop_lint.lint_text(source.read_text(encoding="utf-8"), publisher, phrase_rules, "auto")
+        findings.extend(found)
+        if kind == "report":
+            findings = [f for f in findings if f.rule_id not in slop_lint.MANUSCRIPT_ONLY_RULES]
+    design = slop_lint.audit_docx_design(docx_path, publisher)
+    if locale in {"ko", "mixed"} or source is None:
+        design.extend(slop_lint.audit_docx_cjk(docx_path))
+    craft_blocking, craft_advisory = slop_lint.audit_docx_craft(docx_path)
+    design.extend(craft_blocking)
+    as_dict = lambda f: {"rule": f.rule_id, "line": f.line, "section": f.section, "message": f.message, "excerpt": f.excerpt}  # noqa: E731
+    return {
+        "pass": not findings and not design,
+        "locale": locale,
+        "prose": [as_dict(f) for f in findings][:40],
+        "design": [as_dict(f) for f in design][:40],
+        "advisories": [as_dict(f) for f in craft_advisory][:40],
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Pass/fail gate for a generated DOCX.")
+    parser.add_argument("docx", type=Path)
+    parser.add_argument("--source", type=Path, default=None, help="Markdown the DOCX was built from")
+    parser.add_argument(
+        "--publisher",
+        default=None,
+        help="Profile the DOCX was built with (korean-generic, elsevier, acs, ieee, nature). Omit for the plain profile.",
+    )
+    parser.add_argument("--kind", choices=("report", "manuscript"), default="report")
+    args = parser.parse_args(argv)
+
+    docx_path = args.docx.expanduser().resolve()
+    source = args.source.expanduser().resolve() if args.source else None
+    integrity = check_package(docx_path)
+    content = check_content(docx_path, source.read_text(encoding="utf-8") if source else None) if integrity["pass"] else {"pass": False}
+    # The plain profile has no registry entry; its prose is still linted with the
+    # korean-generic phrase rules, and the design audit is limited to what every
+    # profile shares.
+    lint_report = lint(source, docx_path, args.publisher or "korean-generic", args.kind) if integrity["pass"] else {"pass": False}
+    if args.publisher is None and lint_report.get("design"):
+        shared = {"rule-45-highlighted-text", "rule-46-tracked-changes", "rule-55-ellipsis", "rule-60-numeric-column-alignment"}
+        lint_report["design"] = [f for f in lint_report["design"] if f["rule"] in shared]
+        lint_report["pass"] = not lint_report["prose"] and not lint_report["design"]
+
+    reasons = []
+    if not integrity["pass"]:
+        reasons.append("integrity: " + "; ".join(integrity["problems"][:5]))
+    if content.get("placeholders"):
+        reasons.append(f"content: unfilled blanks {content['placeholders'][:5]} — fill them with realistic values and label them as examples or assumptions")
+    if content.get("frontmatter_leak"):
+        reasons.append("content: YAML frontmatter printed as body text — convert with the converter that reads frontmatter")
+    if not content.get("pass") and not content.get("placeholders") and not content.get("frontmatter_leak"):
+        reasons.append("content: empty document or headings missing from the output")
+    if lint_report.get("prose"):
+        reasons.append(f"prose lint: {len(lint_report['prose'])} finding(s)")
+    if lint_report.get("design"):
+        reasons.append(f"design audit: {len(lint_report['design'])} finding(s)")
+
+    report = {
+        "file": str(docx_path),
+        "pass": not reasons,
+        "failure_reasons": reasons,
+        "profile": args.publisher or "plain",
+        "kind": args.kind,
+        "integrity": {"pass": integrity["pass"], "problems": integrity["problems"][:20]},
+        "content": content,
+        "lint": lint_report,
+    }
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+    return 0 if report["pass"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())