gongwen-skill 2.1.0 → 2.2.0

package/CHANGELOG.md

@@ -4,6 +4,25 @@
   Licensed under the MIT License. See the LICENSE file for details.
 -->
 
+## v2.2.0 (2026-08-28)
+
+### Added
+- **内容要素检查规则真正生效**：修复 37 条 `content.*` 规则（通知事项/会议要素/请示理由等）此前"定义但从不执行"的问题，新增 `_check_content_field` 按字段名映射要素关键词做宽松检查，消除每次 check 的"未支持检查字段"告警
+- **版头检查规则生效**：修复 `header.*` 规则（CHK-CM002 令号检查、CHK-R003 主送机关检查）此前无分发分支的问题，新增 `_check_header_field`
+- **成文日期"右空四字"**：md2docx 渲染日期段新增右缩进 4em（GB/T 9704 规范），消除 CHK-C017 长期存在的日期右空四字检查项
+
+### Changed
+- **signature 段落选择器修正**：`_select_paragraphs` 的 `signature` target 不再包含 `date` 段落——修复 FIX-C013（署名居中）与 FIX-C013b（18pt）误把成文日期强制居中/放大字号的问题，日期段独立按"右对齐 + 右空四字 + 16pt"处理
+- **页码重复注入幂等化**：`_inject_even_page_footer_direct` 重写为幂等版，多次注入仅保留一个 even footerReference 与完整关系，杜绝 Word 打开报"文档损坏"（BUG-1）
+- **加粗+链接/代码组合不再整段加粗**：markdown_converter 单片段按自身 bold 标志处理，重建片段继承原 run 字体字号（BUG-2）
+- **标题启发式误判修复**：黑体/楷体/仿宋加粗正文句不再误判为标题（新增 `_SENTENCE_END` 句末标点保护，Level 1/2/3 三级判定）
+- **CHK-C030 整段加粗误报修复**：忽略纯标点 run、单句段落不报，多句整段加粗仍正确检出
+
+### Fixed
+- `is_title` vs `is_heading` 属性引用错误：`_check_ending`/`_check_content_field` 此前用不存在的 `is_title` 属性，导致标题段被误纳入正文统计
+- 一是/二是 领句段改用仿宋_GB2312（原误用楷体触发标题误判/正文字体误报）
+- 令号正则 `\d` 被 JS 转义破坏（`d`），导致含令号命令误报 CHK-CM002
+
 ## v2.1.0 (2026-08-20)
 
 ### Added

package/README.md

@@ -337,7 +337,7 @@ DSH 采用 **Cordis 模块化微内核架构**：技能体系基于本地文件
 git clone https://github.com/linhut/gongwen-skill.git
 cd gongwen-skill
 pip install -r requirements.txt   # 或 pip install gongwen-skill（已上 PyPI）
-python -m gongwen --version       # 检验：gongwen-skill v2.1.0
+python -m gongwen --version       # 检验：gongwen-skill v2.2.0
 ```
 
 ### 方式一：作为 DSH Skill 注册（基于本地文件系统）
@@ -393,7 +393,7 @@ pnpm add -w gongwen-skill
   "dependencies": {
     "@deepseek-ai/dsh-base": "...",
     "@deepseek-ai/dsh-web-app": "...",
-    "gongwen-skill": "^2.1.0"
+    "gongwen-skill": "^2.2.0"
   },
   "dsh": {
     "profile": {
@@ -448,9 +448,9 @@ dsh --profile web
 | CLI 独立可执行（`python -m gongwen <命令>`） | ✅ |
 | PyPI 上架（`pip install gongwen-skill`） | ✅ |
 | 零外部运行时依赖（仅 python-docx/pydantic/pyyaml） | ✅ |
-| DSH 配置化排版参数（页边距/行距/字体/默认模板版本） | ✅ v2.1.0+ |
+| DSH 配置化排版参数（页边距/行距/字体/默认模板版本） | ✅ v2.2.0+ |
 
-### DSH 插件配置化（v2.1.0+）
+### DSH 插件配置化（v2.2.0+）
 
 DSH 插件支持通过配置文件管理排版参数，Agent 调用时自动注入，纯 CLI 用户不受影响。
 
@@ -574,7 +574,7 @@ pip install -r requirements.txt
 用户：帮我优化这份会议通知的第二章节措辞
 
 Agent：📋 合规自检报告
-Skill 版本: v2.1.0（多渠道自检已确认最新）
+Skill 版本: v2.2.0（多渠道自检已确认最新）
 路径判定: B（内容优化）
 依据: 用户指定了已有文档，且要求"优化措辞"
 命令调用: 1. python -m gongwen optimize-content 会议通知.docx --changes changes.json --apply --paragraphs "5-8"

package/dsh/index.js

@@ -1,4 +1,4 @@
-// 公文全流程处理工具 - DSH plugin bridge (gongwen-skill, v2.1.0+)
+// 公文全流程处理工具 - DSH plugin bridge (gongwen-skill, v2.2.0+)
 // (c) 2026 Jose AI (https://www.linhut.cn)
 // https://github.com/linhut/gongwen-skill
 // Licensed under the MIT License. See the LICENSE file for details.

package/engine/core/document/markdown_converter.py

@@ -51,6 +51,32 @@ _MD_CODE_BLOCK_RE = re.compile(r'^`{3,}')
 # 行内代码 `code`
 _MD_INLINE_CODE_RE = re.compile(r'`([^`]+)`')
 
+# 加粗标记（**text** 或 __text__）
+_MD_BOLD_SEG_RE = re.compile(r'(\*\*[^*]+\*\*|__[^_]+__)')
+
+
+def _reconstruct_bold_segments(raw: str, cleaned: str):
+    """把含 **..** 的原始文本映射为 [(文本, 是否加粗), ...] 片段。
+
+    片段拼接结果与 cleaned 一致时才返回片段列表；否则（含链接/代码等被清理、
+    或文本被折叠）回退为整段（避免丢失文本）。
+    """
+    if not raw or ('**' not in raw and '__' not in raw):
+        return [(cleaned or "", False)]
+    segments = []
+    for part in _MD_BOLD_SEG_RE.split(raw):
+        if not part:
+            continue
+        if part.startswith('**') and part.endswith('**') and len(part) > 4:
+            segments.append((part[2:-2], True))
+        elif part.startswith('__') and part.endswith('__') and len(part) > 4:
+            segments.append((part[2:-2], True))
+        else:
+            segments.append((part, False))
+    if ''.join(s[0] for s in segments).strip() == (cleaned or "").strip():
+        return segments
+    return [(cleaned or "", False)]
+
 
 def convert_markdown(model: DocumentModel) -> int:
     """
@@ -201,6 +227,7 @@ def convert_markdown(model: DocumentModel) -> int:
         # --- 识别加粗标记 **text** ---
 
         has_bold = False
+        raw_before_bold = text  # 保存剥离 ** 前的原始文本，用于加粗段重构
         if _MD_BOLD_RE.search(text) or _MD_BOLD_UNDER_RE.search(text):
             has_bold = True
             text = _MD_BOLD_RE.sub(r'\1', text)
@@ -257,8 +284,35 @@ def convert_markdown(model: DocumentModel) -> int:
                         r.text = ""
 
                 if has_bold and not para.is_heading:
-                    for r in para.runs:
-                        r.format.bold = True
+                    # 仅加粗 **..** 标记的片段，避免整段误加粗（CHK-C030 修复）
+                    _segments = _reconstruct_bold_segments(raw_before_bold, para.text)
+                    if len(_segments) > 1:
+                        # 重建片段时继承原 run 的字体/字号，避免丢失字体（I20 修复）
+                        _base_format = None
+                        for _r in para.runs:
+                            if _r.text and (_r.format.font_name or _r.format.font_size_pt):
+                                _base_format = _r.format
+                                break
+                        _new_runs = []
+                        for _t, _b in _segments:
+                            if not _t:
+                                continue
+                            _nr = Run(index=len(_new_runs), text=_t,
+                                      format=RunFormat(
+                                          font_name=_base_format.font_name if _base_format else None,
+                                          font_size_pt=_base_format.font_size_pt if _base_format else 16.0,
+                                      ))
+                            if _b:
+                                _nr.format.bold = True
+                            _new_runs.append(_nr)
+                        para.runs = _new_runs
+                    else:
+                        # 单片段：按其自身 bold 标志处理——纯粗体段（**全段**）整段加粗；
+                        # raw/cleaned 不匹配回退的单片段 bold=False 保持不加粗（I20 修复：
+                        # 此前把回退也整段加粗，导致"加粗+链接/代码"段落整段变粗）
+                        if _segments and _segments[0][1]:
+                            for r in para.runs:
+                                r.format.bold = True
 
                 if is_list and list_indent_pt > 0 and not para.is_heading:
                     para.format.left_indent_pt = list_indent_pt

package/engine/core/document/modifier.py

@@ -74,19 +74,33 @@ def _select_paragraphs(model: DocumentModel, target: str) -> list[Paragraph]:
         return [p for p in model.paragraphs
                 if not p.is_heading and p.text.strip() and id(p) not in sig_set]
     elif target == "signature":
-        # 优先使用 role 字段
-        role_sig = [p for p in model.paragraphs if p.role in ('signature', 'date')]
+        # P2-24 修复：signature target 只匹配署名段（role='signature'），不再包含 date——
+        # 此前匹配 role in ('signature','date') 会把落款日期段一并选中，
+        # 导致 FIX-C013（署名居中）把日期改成 center、FIX-C013b（18pt）把日期改成 18pt，
+        # 违反 GB/T 9704 成文日期"右空四字、三号仿宋(16pt)"的规范。
+        # 日期段由 target="date" 分支独立处理（右对齐 + right_indent 保留）。
+        role_sig = [p for p in model.paragraphs if p.role == 'signature']
         if role_sig:
             return role_sig
-        non_empty = [p for p in model.paragraphs if p.text.strip()]
-        return non_empty[-2:] if len(non_empty) >= 2 else non_empty
+        # 仅当无署名 role 时，才允许位置回退（末两段：署名+日期）；
+        # 回退时仍只修署名语义的段落，不影响日期段对齐
+        non_empty = [p for p in model.paragraphs if p.text.strip() and p.role != 'date']
+        if len(non_empty) >= 2:
+            last = non_empty[-1].text.strip()
+            if re.match(r'^\d{4}年\d{1,2}月\d{1,2}日$', last) or re.match(r'^\d{4}[.\-/]\d{1,2}[.\-/]\d{1,2}$', last):
+                return non_empty[-1:]
+        return []
     elif target == "date":
         # 同 signature 的处理逻辑
         role_date = [p for p in model.paragraphs if p.role == 'date']
         if role_date:
             return role_date
         non_empty = [p for p in model.paragraphs if p.text.strip()]
-        return non_empty[-1:] if non_empty else []
+        if non_empty:
+            last = non_empty[-1].text.strip()
+            if re.match(r'^\d{4}年\d{1,2}月\d{1,2}日$', last) or re.match(r'^\d{4}[.\-/]\d{1,2}[.\-/]\d{1,2}$', last):
+                return non_empty[-1:]
+        return []
     elif target in ('salutation', 'introduction', 'transition', 'meeting_date', 'numbered_body'):
         # N2: 段落类型 target —— 使用 detect_paragraph_type 内容匹配
         return [p for p in model.paragraphs if detect_paragraph_type(p.text, p.role) == target]

package/engine/core/document/parser.py

@@ -51,6 +51,10 @@ _H1_WESTERN_PATTERN = re.compile(r'^[IVXLCDM]+\.\s+')
 _H2_WESTERN_PATTERN = re.compile(r'^[A-Z]\.\s+')
 _H4_WESTERN_PATTERN = re.compile(r'^[a-z]\.\s+')
 
+# 句末标点（P2-16 修复：标题不以这些标点结尾，正文强调句/引用句通常会以它们结尾，
+# 用于排除"黑体/楷体/仿宋加粗的正文短句"被误判为标题）
+_SENTENCE_END = ('。', '！', '？', '：', '；', '，', '.', '!', '?', ':', ';', ',')
+
 
 def _detect_heading_heuristic(
     text: str, runs: list[Run], para_format: ParagraphFormat
@@ -103,7 +107,13 @@ def _detect_heading_heuristic(
 
     # --- Level 1: 一级标题（黑体）---
     if has_font_signal and ("黑体" in font_lower or font_lower in ("simhei",)):
-        if alignment == "center" or is_bold or len(text_stripped) < 30:
+        # P2-16 修复：排除以句末标点结尾的正文强调句（如"重要提示：…"）。
+        # 一级标题通常较短且不以句号/冒号等结尾。
+        if alignment == "center":
+            return True, 1
+        if len(text_stripped) < 30 and not text_stripped.endswith(_SENTENCE_END):
+            return True, 1
+        if is_bold and not text_stripped.endswith(_SENTENCE_END):
             return True, 1
 
     # 格式信号："一、" + 加粗或黑体
@@ -115,9 +125,15 @@ def _detect_heading_heuristic(
     if _H1_WESTERN_PATTERN.match(text_stripped) and len(text_stripped) < 50:
         return True, 1
 
-    # --- Level 2: 二级标题（楷体 + 加粗）---
-    if has_font_signal and ("楷体" in font_lower or font_lower in ("kaiti", "楷体_gb2312")) and is_bold:
-        return True, 2
+    # --- Level 2: 二级标题（楷体，无需加粗）---
+    # GB/T 9704 二级标题为楷体，不加粗。若段落字体为楷体（含 楷体_GB2312），
+    # 即使内容为 "2.1" 等数字编号，也优先识别为二级标题而非三级标题，
+    # 避免 converter 的 "###"→二级标题与 check 的 "2.1"→三级标题启发式冲突。
+    # P2-16 修复：增加"不以句末标点结尾"约束，排除正文楷体引用句
+    # （如"会议指出，…。"）被误判为二级标题。
+    if has_font_signal and ("楷体" in font_lower or font_lower in ("kaiti", "楷体_gb2312")):
+        if len(text_stripped) < 40 and not text_stripped.endswith(_SENTENCE_END):
+            return True, 2
 
     # "（一）" 格式（无论字体如何，此模式足够唯一）
     if _H2_PATTERN.match(text_stripped) and len(text_stripped) < 50:
@@ -128,7 +144,8 @@ def _detect_heading_heuristic(
 
     # --- Level 3: 三级标题（仿宋加粗 或 "1." + 加粗）---
     if has_font_signal and ("仿宋" in font_lower or font_lower in ("fangsong", "仿宋_gb2312")) and is_bold:
-        if len(text_stripped) < 50:
+        # P2-16 修复：排除以句末标点结尾的仿宋加粗正文短句被误判为三级标题
+        if len(text_stripped) < 50 and not text_stripped.endswith(_SENTENCE_END):
             return True, 3
 
     if _H3_PATTERN.match(text_stripped) and is_bold and len(text_stripped) < 60:
@@ -340,6 +357,13 @@ def _assign_paragraph_roles(paragraphs: list[Paragraph]) -> None:
         if not para.role and _ATTACHMENT_RE.match(para.text.strip()):
             para.role = 'attachment'
 
+    # AI 声明段（末尾批注，如"（内容由GongWen-skill-AI生成，仅供参考）"）
+    # 标记为 annotation 角色，避免 check 将其误判为正文并报格式违规
+    _AI_DECL_MARKERS = ("由GongWen-skill-AI生成", "由AI生成", "仅供参考")
+    for idx, para in non_empty:
+        if not para.role and any(m in para.text for m in _AI_DECL_MARKERS):
+            para.role = 'annotation'
+
     # 其余非空段落默认为 body
     for idx, para in non_empty:
         if not para.role:

package/engine/core/rules/checker.py

@@ -92,6 +92,16 @@ def check_document(model: DocumentModel, rules: dict[str, Any]) -> list[CheckIss
         elif field_path.startswith("ending."):
             # FIX-V153-02：ending.check 结语检查（CHK-N001/R001/RPT001/RP002/L002 等）
             issues.extend(_check_ending(model, rule_id, severity, name, expected, message))
+        elif field_path.startswith("content."):
+            # P2-22 修复：content.* 内容要素检查（CHK-N003 等 37 条规则此前无分发分支，
+            # 全部"定义但从不执行"且每次 check 刷"未支持字段"告警）
+            issues.extend(_check_content_field(model, rule_id, severity, name, field_path,
+                                               expected, message))
+        elif field_path.startswith("header."):
+            # P2-23 修复：header.* 版头检查（CHK-CM002 令号、CHK-R003 主送机关）
+            # 此前无分发分支，规则定义但从不执行
+            issues.extend(_check_header_field(model, rule_id, severity, name, field_path,
+                                              expected, message))
         else:
             # P1-6 修复：删除 generic else 中的硬编码索引逻辑（model.paragraphs[0]/[1]
             # 不一定是标题/正文，检查结果会指向错误段落），未识别的 field 直接 skip + warning
@@ -313,10 +323,32 @@ def _check_heading_level(model, rule_id, severity, name, field_path, expected, m
     return issues
 
 
+# P2-17：CHK-C030 辅助——纯标点 run 判定（不含任何正文内容的 run）
+# 用字符集判断替代正则，避免 r'...\[...]' 无效转义 SyntaxWarning，且匹配更可靠
+_PUNCT_ONLY_CHARS = set('。！？：；，、.…!?:;,()（）""''《》〈〉【】[]')
+
+
+def _is_punct_only(text: str) -> bool:
+    """判断 run 是否只含标点/空白（用于整段加粗判定时忽略标点 run）。"""
+    t = (text or "").strip()
+    if not t:
+        return True
+    return all(ch in _PUNCT_ONLY_CHARS or ch.isspace() for ch in t)
+
+
+def _count_sentence_end(text: str) -> int:
+    """统计句末标点（。！？ 以及英文 . ! ?）的数量，用于判断单句/多句段落。"""
+    if not text:
+        return 0
+    return sum(1 for ch in text if ch in '。！？.!?')
+
+
 def _check_body(model, rule_id, severity, name, field_path, expected, message) -> list[CheckIssue]:
-    """Check body paragraph formatting (excluding signature/date)."""
+    """Check body paragraph formatting (excluding signature/date/annotation/recipient)."""
     issues = []
-    _EXCLUDE_ROLES = {'signature', 'date'}
+    # 顶格左对齐的段落（主送机关/称呼段、署名、日期、AI 声明批注）不属于正文，
+    # 不应套用正文的缩进/对齐/字体检查
+    _EXCLUDE_ROLES = {'signature', 'date', 'annotation', 'notes', 'recipient', 'salutation'}
     body_paras = [p for p in model.paragraphs
                   if not p.is_heading and p.text.strip() and p.role not in _EXCLUDE_ROLES]
     if not body_paras:
@@ -403,13 +435,23 @@ def _check_body(model, rule_id, severity, name, field_path, expected, message) -
         elif sub_field == "bold_range":
             # 检查正文段落是否整段加粗（通常只有首句/点题词应加粗）
             if para.runs and para.text.strip():
-                all_bold = all(r.format.bold for r in para.runs if r.text.strip())
+                # P2-17 修复：忽略纯标点 run（句号/逗号等不含正文的 run），
+                # 避免"首句加粗含句号"时标点 run 加粗触发整段加粗误报
+                _CONTENT_RUNS = [r for r in para.runs
+                                 if r.text.strip() and not _is_punct_only(r.text)]
+                if not _CONTENT_RUNS:
+                    continue
+                all_bold = all(r.format.bold for r in _CONTENT_RUNS)
                 if all_bold:
                     # B-09（方案三）：排除不应加粗的段落类型（称呼/导语/过渡/署名/会议日期等），
                     # 避免这些段落被误标为 body 后报告"整段加粗"问题造成噪音
                     from engine.core.document.modifier import should_bold_first_sentence
                     if not should_bold_first_sentence(para.text, para.role):
                         continue
+                    # P2-17 修复：单句段落（仅 1 个句末标点）的首句加粗=整段加粗，
+                    # 属于合理排版（首句即整段），不报；多句段落整段加粗才报
+                    if _count_sentence_end(para.text) <= 1:
+                        continue
                     issues.append(CheckIssue(
                         rule_id=rule_id, check_type="content", severity=severity,
                         name=name, location=f"paragraph:{para.index}",
@@ -463,17 +505,32 @@ def _check_page_setup(model, rule_id, severity, name, field_path, expected, mess
 
 
 def _check_signature_area(model, rule_id, severity, name, field_path, expected, message, rules) -> list[CheckIssue]:
-    """Check signature/date area formatting. Only check last 2 non-empty paragraphs (落款+日期)."""
+    """Check signature/date area formatting.
+
+    仅检查落款/日期段落（默认取最后 2 个非空段落）：
+    - signature.* 字段只检查署名段（角色 signature，通常是倒数第 2 段）
+    - date.* 字段只检查日期段（角色 date，通常是最后 1 段）
+    避免把署名/日期规则同时套在两个段落上造成误报。
+    """
     issues = []
-    paras = [p for p in model.paragraphs if not p.is_heading and p.text.strip()]
+    paras = [p for p in model.paragraphs if not p.is_heading and p.text.strip()
+             and p.role not in ('annotation', 'notes')]
     if not paras:
         return issues
 
-    # Signature area: only last 2 paragraphs (落款单位 + 日期)
-    sig_paras = paras[-2:] if len(paras) >= 2 else paras
     sub_field = field_path.split(".", 1)[1] if "." in field_path else ""
+    is_date = field_path.startswith("date.")
 
-    for para in sig_paras:
+    # 按角色取签名段/日期段。仅当文档确实存在落款/日期时才检查，
+    # 避免把无落款的正文末段误判为签名/日期造成误报（位置回退不再使用）。
+    if is_date:
+        target = [p for p in paras if p.role == 'date']
+    else:
+        target = [p for p in paras if p.role == 'signature']
+    if not target:
+        return issues
+
+    for para in target:
         if sub_field == "align":
             if para.format.alignment and para.format.alignment != str(expected).lower():
                 issues.append(CheckIssue(
@@ -561,8 +618,11 @@ def _check_paragraph_type_field(model, rule_id, severity, name, field_path, expe
                     ))
                     break
         elif sub_field == "bold":
-            for run in para.runs:
-                if bool(run.format.bold) != bool(expected):
+            # 编号正文（一是/二是…）：仅要求首句（首 run）加粗，其余正文不应加粗。
+            # 其余段落类型：按首 run 判断即可（段落级加粗风格由 bold_range 规则另行检查）。
+            _runs_to_check = para.runs[:1] if target == 'numbered_body' else para.runs[:1]
+            for run in _runs_to_check:
+                if run.format.bold is not None and bool(run.format.bold) != bool(expected):
                     issues.append(CheckIssue(
                         rule_id=rule_id, check_type="format", severity=severity,
                         name=name, location=f"paragraph:{para.index}",
@@ -646,8 +706,9 @@ def _check_ending(model, rule_id: str, severity: str, name: str,
             text = text.strip()
             role = getattr(p, 'role', '') or ''
             # 排除标题、落款（signature/date）、批注（annotation）段——这些不是正文结语
-            if text and not getattr(p, 'is_title', False) \
-                    and role not in ('signature', 'date', 'annotation'):
+            # P2-22 修复：模型属性是 is_heading 而非 is_title，标题段不应纳入结语统计
+            if text and not getattr(p, 'is_heading', False) and role not in (
+                    'signature', 'date', 'annotation'):
                 body_paras.append(text)
 
         if not body_paras:
@@ -684,6 +745,159 @@ def _check_ending(model, rule_id: str, severity: str, name: str,
     return issues
 
 
+# P2-22：content.* 内容要素检查——字段名 → 要素关键词组（宽松匹配，高召回低误报）
+_CONTENT_FIELD_KEYWORDS = {
+    "notice_items":     ["时间", "地点", "要求", "请", "须", "要", "参加", "召开", "举办",
+                         "组织", "开展", "落实", "遵守", "上报", "报送", "日期", "人员", "对象"],
+    "scope":            ["范围", "适用于", "各", "单位", "部门", "地区", "辖区"],
+    "effective_date":   ["自", "起施行", "施行", "生效", "即日", "之日起", "起执行"],
+    "validity":         ["有效", "期限", "至", "自", "起"],
+    "meeting_elements": ["会议", "时间", "地点", "参加", "人员", "议题", "议程"],
+    "meeting_info":     ["会议", "时间", "地点", "参加", "纪要", "议题"],
+    "reason":           ["因", "由于", "为了", "鉴于", "依据", "根据"],
+    "basis":            ["依据", "根据", "按照", "遵照"],
+    "purpose":          ["为了", "为", "目的", "促进", "推动"],
+    "measures":         ["措施", "办法", "方案", "要求", "应当", "应", "须"],
+    "proposer":         ["提出", "建议", "提议", "呈报", "申报"],
+    "facts":            ["事实", "情况", "经查", "查明", "核实"],
+    "items":            ["事项", "内容", "如下", "包括", "如下"],
+    "legal_basis":      ["依据", "根据", "依照", "按照", "法规", "条例"],
+    "decision_items":   ["决定", "如下", "事项", "内容"],
+    "clauses":          ["条", "款", "项", "规定", "如下"],
+    "structure":        ["结构", "如下", "部分", "章节"],
+    "data":             ["数据", "统计", "指标", "数字", "情况"],
+    "suggestions":      ["建议", "意见", "应", "应当", "建议如下"],
+    "report_items":     ["情况", "报告", "如下", "内容"],
+    "reply_to":         ["关于", "收悉", "来函", "贵", "你"],
+    "attitude":         ["同意", "不同意", "原则同意", "批准"],
+    "single_topic":     ["一", "单一", "专项"],
+    "resolution_items": ["决定", "如下", "事项"],
+    "procedure":        ["程序", "步骤", "按照", "流程"],
+    "background":       ["背景", "概述", "现状", "问题"],
+    "alternatives":     ["方案", "备选", "比较", "选项"],
+    "implementation_plan": ["实施", "计划", "进度", "安排", "时间表"],
+    "objectives":       ["目标", "目的", "要求"],
+    "timeline":         ["时间", "阶段", "进度", "月", "年", "日"],
+    "responsibilities": ["责任", "负责", "分工", "单位"],
+    "lead":             ["导语", "开头", "首先"],
+    "source":           ["来源", "据", "报道"],
+    "report_section":   ["部分", "章节", "如下"],
+}
+
+
+def _check_content_field(model, rule_id: str, severity: str, name: str,
+                         field_path: str, expected: str, message: str) -> list[CheckIssue]:
+    """P2-22 修复：content.* 内容要素检查（此前所有该前缀规则被跳过并告警）。
+
+    策略：按字段名尾部映射要素关键词组，检查正文（body 段落）是否包含任一组关键词。
+    - 宽松匹配：命中任一关键词即通过（避免误报）
+    - 无法映射的字段名保持跳过（返回空列表，不产生告警噪音）
+    """
+    issues = []
+    field_name = field_path.split(".", 1)[1] if "." in field_path else ""
+    keywords = _CONTENT_FIELD_KEYWORDS.get(field_name)
+    if not keywords:
+        return issues
+
+    try:
+        # 收集正文文本（排除标题/落款/日期/批注/称呼段）
+        body_texts = []
+        for p in model.paragraphs:
+            text = (getattr(p, 'text', '') or '').strip()
+            role = getattr(p, 'role', '') or ''
+            # P2-22 修复：模型属性是 is_heading 而非 is_title——原 is_title 永远为
+            # False，导致标题段被误纳入正文统计（标题中的"召开/组织"等词会使
+            # 空壳通知误判为"有要素"而漏报 CHK-N003）
+            if text and not getattr(p, 'is_heading', False) and role not in (
+                    'signature', 'date', 'annotation', 'recipient', 'salutation'):
+                body_texts.append(text)
+        joined = ''.join(body_texts)
+        if not joined:
+            return issues
+
+        found = any(kw in joined for kw in keywords)
+        if not found:
+            issues.append(CheckIssue(
+                rule_id=rule_id,
+                check_type="content",
+                severity=severity,
+                name=name,
+                location="正文",
+                original_text=joined[-80:] if joined else "",
+                suggested_fix=expected,
+                reason=message or f"文档正文缺少相关要素（期望: {expected}）",
+            ))
+    except Exception as e:
+        logger.warning(f"_check_content_field 检查失败: {e}")
+
+    return issues
+
+
+def _check_header_field(model, rule_id: str, severity: str, name: str,
+                        field_path: str, expected: str, message: str) -> list[CheckIssue]:
+    """P2-23 修复：header.* 版头检查（此前规则定义但从不执行）。
+
+    支持字段：
+    - header.doc_number（CHK-CM002 命令）：检查文档是否标注令号（如"〔2026〕1号"、"第1号"）
+    - header.recipient（CHK-R003 请示）：检查是否含主送机关段，且只写一个主送机关
+    """
+    import re
+    issues = []
+    field_name = field_path.split(".", 1)[1] if "." in field_path else ""
+
+    try:
+        if field_name == "doc_number":
+            # 令号模式：〔2026〕1号 / 第1号 / （2026）1号 / 2026年1号 等
+            all_text = ''.join((getattr(p, 'text', '') or '') for p in model.paragraphs)
+            has_doc_number = re.search(
+                r'[〔（(]?\d{4}[〕）)]?\s*\d+号|[第]\d+号|令\d+号|\d+号令',
+                all_text,
+            ) is not None
+            if not has_doc_number:
+                issues.append(CheckIssue(
+                    rule_id=rule_id, check_type="content", severity=severity,
+                    name=name, location="文档开头",
+                    original_text=all_text[:60] if all_text else "",
+                    suggested_fix=expected,
+                    reason=message or "命令（令）应标注令号",
+                ))
+        elif field_name == "recipient":
+            # 主送机关：存在 recipient 角色的段，且应只有一个主送机关
+            recips = [p for p in model.paragraphs
+                      if getattr(p, 'role', '') == 'recipient' and (p.text or '').strip()]
+            if not recips:
+                issues.append(CheckIssue(
+                    rule_id=rule_id, check_type="content", severity=severity,
+                    name=name, location="文档开头",
+                    original_text="",
+                    suggested_fix=expected,
+                    reason=message or "请示应写明主送机关",
+                ))
+                return issues
+            # 只写一个主送机关：一个 recipient 段 + 段内无多个机关分隔符
+            first = recips[0].text
+            if len(recips) > 1:
+                issues.append(CheckIssue(
+                    rule_id=rule_id, check_type="content", severity=severity,
+                    name=name, location=f"paragraph:{recips[0].index}",
+                    original_text=first[:60],
+                    suggested_fix="仅保留一个主送机关",
+                    reason="请示一般只写一个主送机关（发现多个主送机关段）",
+                ))
+            elif re.search(r'[、，,s]{2,}', first.strip().rstrip('：:')) and len(first.strip().rstrip('：:')) > 5:
+                issues.append(CheckIssue(
+                    rule_id=rule_id, check_type="content", severity=severity,
+                    name=name, location=f"paragraph:{recips[0].index}",
+                    original_text=first[:60],
+                    suggested_fix="仅保留一个主送机关",
+                    reason="请示一般只写一个主送机关（段内含多个机关）",
+                ))
+    except Exception as e:
+        logger.warning(f"_check_header_field 检查失败: {e}")
+
+    return issues
+
+
 def _check_page_number(model, rule_id, severity, name, field_path, expected, message) -> list[CheckIssue]:
     """检查页脚页码域格式（P3-10：CHK-C023/024/029）。
 
@@ -711,7 +925,9 @@ def _check_page_number(model, rule_id, severity, name, field_path, expected, mes
                         break
             elif sub_field == "alignment" or sub_field == "align":
                 actual = para.format.alignment
-                if actual and actual != str(expected).lower():
+                # GB/T 9704 允许"居中"或"翻页模式（单右双左，默认 footer 为 right/left）"。
+                # 翻页模式下默认 footer 对齐为 right（单页右空一字），不再强制 center。
+                if actual and actual not in ('center', 'left', 'right'):
                     issues.append(CheckIssue(
                         rule_id=rule_id, check_type="format", severity=severity,
                         name=name, location=f"footer:{hf.section_index}:paragraph:{para.index}",

package/engine/inject.py

@@ -485,7 +485,13 @@ def _apply_page_number_elements(para_elem, elements: list) -> None:
 
 
 def _inject_even_page_footer_direct(output_path: str, fmt: str, font_name: str, size_pt: int) -> None:
-    """直接操作 ZIP，添加偶数页页脚和 evenAndOddHeaders（单双页奇偶排版）。"""
+    """直接操作 ZIP，添加偶数页页脚和 evenAndOddHeaders（单双页奇偶排版）。
+
+    幂等性（I19 修复）：重复调用（如 md2docx 后再跑 pagenum/optimize --layout）
+    不会累积 even footerReference / 关系条目 / footer2.xml 重复条目——
+    此前重复调用会在 document.xml 留下多个 even footerReference、rels 关系缺失、
+    ZIP 出现重复 word/footer2.xml，导致 Word 报"文档损坏"。
+    """
     import zipfile
     import io
     from lxml import etree
@@ -502,6 +508,7 @@ def _inject_even_page_footer_direct(output_path: str, fmt: str, font_name: str,
     elems = _build_page_number_xml(fmt, font_name, size_pt)
     _apply_page_number_elements(even_p, elems)
 
+    even_rid = 'rIdFtrEven'
     buf = io.BytesIO()
     with zipfile.ZipFile(output_path, 'r') as zin:
         with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zout:
@@ -516,8 +523,12 @@ def _inject_even_page_footer_direct(output_path: str, fmt: str, font_name: str,
                     root = etree.fromstring(data)
                     ns_w = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'
                     ns_r = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships'
+                    # I19 幂等：先移除所有已有的 even footerReference，避免重复累积
+                    for sp in root.findall('.//{%s}sectPr' % ns_w):
+                        for ref in list(sp.findall('{%s}footerReference' % ns_w)):
+                            if ref.get('{%s}type' % ns_w) == 'even':
+                                sp.remove(ref)
                     # NS11 修复：动态分配偶数页页脚关系 ID，避免与已有 ID 冲突
-                    even_rid = 'rIdFtrEven'
                     used_ids = {ref.get('{%s}id' % ns_r) for sp in root.findall('.//{%s}sectPr' % ns_w)
                                 for ref in sp.findall('{%s}footerReference' % ns_w)}
                     n = 0
@@ -549,14 +560,21 @@ def _inject_even_page_footer_direct(output_path: str, fmt: str, font_name: str,
                     # I15 修复：结构化 XML 编辑（替代纯文本替换，避免破坏结构）
                     rel_root = etree.fromstring(data)
                     rel_ns = 'http://schemas.openxmlformats.org/package/2006/relationships'
-                    existing_ids = [r.get('Id') for r in rel_root]
-                    if 'rIdFtrEven' not in existing_ids:
-                        rel = etree.SubElement(rel_root, '{%s}Relationship' % rel_ns)
-                        rel.set('Id', 'rIdFtrEven')
-                        rel.set('Type', 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer')
-                        rel.set('Target', 'footer2.xml')
+                    # I19 幂等：清理本工具遗留的偶数页页脚关系（rIdFtrEven / rIdFtrEvenN），
+                    # 避免残留关系堆积；再按实际 even_rid 写入唯一关系
+                    for rel in list(rel_root):
+                        rid = rel.get('Id') or ''
+                        if rid == 'rIdFtrEven' or rid.startswith('rIdFtrEven'):
+                            rel_root.remove(rel)
+                    rel = etree.SubElement(rel_root, '{%s}Relationship' % rel_ns)
+                    rel.set('Id', even_rid)
+                    rel.set('Type', 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer')
+                    rel.set('Target', 'footer2.xml')
                     zout.writestr(item.filename,
                                   etree.tostring(rel_root, xml_declaration=True, encoding='UTF-8', standalone=True))
+                elif item.filename == 'word/footer2.xml':
+                    # I19 幂等：跳过旧 footer2.xml，避免 ZIP 出现重复条目
+                    continue
                 else:
                     zout.writestr(item.filename, data)
             zout.writestr('word/footer2.xml',

package/gongwen/__init__.py

@@ -7,7 +7,7 @@
 #
 # 公文全流程处理工具 - gongwen-skill Python package
 
-__version__ = "2.1.0"
+__version__ = "2.2.0"
 
 # Re-export everything from the legacy module for backward compatibility
 # This allows: from gongwen import main, cmd_check, etc.

package/gongwen/_legacy.py

@@ -45,7 +45,7 @@ from gongwen.cli.helpers import (
     parse_config_overrides as _parse_config_overrides,
     load_rules_with_overrides as _load_rules_with_overrides,
 )
-__version__ = "2.1.0"
+__version__ = "2.2.0"
 # 版本号应与 gongwen/__init__.py 保持一致，每次发版同步更新
 """
 中文公文全流程处理工具 —— 基于 GB/T 9704《党政机关公文格式》国家标准。
@@ -329,7 +329,10 @@ def cmd_md2docx(args):
     - doc_type: 公文类型（默认 notice）
     """
     from datetime import date as _dt
-    from engine.core.document.generator import generate_docx
+    # 既定方案：md2docx 改用 python-docx 直接按 GB/T 9704 生成初稿，
+    # 不再走 DocumentModel → generate_docx 管线（规避技能版本不一致导入错误，
+    # 并保证初稿正文即三号仿宋 16pt，而非回退 11pt）
+    from gongwen.md2docx_render import render_model_to_docx as _render_docx
     from engine.core.document.models import (
         DocumentModel, DocumentMetadata, PageSetup,
         Paragraph, ParagraphFormat, Run, RunFormat,
@@ -455,8 +458,11 @@ def cmd_md2docx(args):
 
     # 领句加粗（路径 C 生成公文时，Markdown 中的"一是/二是/第一/第二"等领句自动加粗）
     _BOLD_LEADIN = {
-        '一是': '楷体_GB2312', '二是': '楷体_GB2312', '三是': '楷体_GB2312',
-        '四是': '楷体_GB2312', '五是': '楷体_GB2312',
+        # P2-18 修复：一是/二是 领句段是"编号列举正文"，字体保持仿宋_GB2312（正文字体），
+        # 仅领句加粗；不再使用楷体（楷体是二级标题字体，正文领句用楷体会触发
+        # parser 楷体标题判定 / CHK-C004 正文字体误报）
+        '一是': '仿宋_GB2312', '二是': '仿宋_GB2312', '三是': '仿宋_GB2312',
+        '四是': '仿宋_GB2312', '五是': '仿宋_GB2312',
         '第一，': '仿宋_GB2312', '第二，': '仿宋_GB2312', '第三，': '仿宋_GB2312',
         '一要': '仿宋_GB2312', '二要': '仿宋_GB2312', '三要': '仿宋_GB2312',
     }
@@ -475,9 +481,11 @@ def cmd_md2docx(args):
         para.runs[0].format.bold = True
         para.runs[0].format.font_name = _BOLD_LEADIN[matched]
         para.runs[0].format.font_size_pt = 16.0
+        # 领句加粗的余下部分沿用领句字体（一律仿宋_GB2312 正文字体），
+        # 使整段字体统一且保持正文字体，符合 CHK-C004 正文字体要求
         para.runs.append(Run(
             index=len(para.runs), text=remaining,
-            format=RunFormat(font_name='仿宋_GB2312', font_size_pt=16.0),
+            format=RunFormat(font_name=_BOLD_LEADIN[matched], font_size_pt=16.0),
         ))
 
     # 落款与日期（P10: 署名前增加2个空行；P4: 署名段居中 18pt）
@@ -527,18 +535,29 @@ def cmd_md2docx(args):
     else:
         today = _dt.today().strftime("%Y-%m-%d")
         out = Path(f"修订版+{doc_type}-草稿+{today}+v1.docx")
-    generate_docx(model, str(out), no_ai_declaration=getattr(args, "no_ai_declaration", False))
+    # 既定方案：直接按 GB/T 9704 渲染初稿（python-docx 直写，不走通用管线）
+    _render_docx(model, str(out), rules=rules,
+                 no_ai_declaration=getattr(args, "no_ai_declaration", False))
 
-    # FIX-B002：md2docx 补充页码注入（默认居中，- X - 格式，省筹委会规范）
+    # FIX-B002：md2docx 补充页码注入（默认从 rules 读取，回退到省筹委会规范）
     try:
-        from inject import inject_page_number
-        inject_page_number(str(out), {
-            "enabled": True,
+        # 页码默认样式取自 rules（FIX-C025 修复规则的值），若 rules 未定义则用硬编码回退
+        _pn = {
             "font": "宋体",
             "size": 14,
-            "alignment": "center",
+            "alignment": "right",  # 翻页模式（单右双左），GB/T 9704
             "format": "- {PAGE} -",
-        })
+        }
+        for fr in (rules or {}).get("fix_rules", []):
+            if fr.get("action") == "set_page_number" and isinstance(fr.get("value"), dict):
+                _pv = fr["value"]
+                _pn["font"] = _pv.get("font", _pn["font"])
+                _pn["size"] = int(str(_pv.get("size", _pn["size"])).replace("pt", ""))
+                _pn["alignment"] = _pv.get("alignment", _pn["alignment"])
+                _pn["format"] = _pv.get("format", _pn["format"])
+                break
+        from inject import inject_page_number
+        inject_page_number(str(out), {"enabled": True, **_pn})
     except Exception as e:
         print(f"  ⚠️ 页码注入失败（{e}），跳过", file=sys.stderr)
 

package/gongwen/md2docx_render.py

@@ -0,0 +1,509 @@
+# -*- coding: utf-8 -*-
+#
+# (c) 2026 Jose AI (https://www.linhut.cn)
+# https://github.com/linhut/gongwen-skill
+# Licensed under the MIT License. See the LICENSE file for details.
+#
+# 本模块仅服务于 gongwen 的 md2docx 子命令。
+"""md2docx 渲染器：直接用 python-docx 按 GB/T 9704 生成公文初稿。
+
+既定方案（改造说明）
+====================
+原 cmd_md2docx 走「DocumentModel → generate_docx」通用管线：
+  1) 该管线跨模块引用（如 engine.core.document.parser 等），存在
+     「技能版本不一致」导致的导入错误风险；
+  2) generate_docx 的 docDefaults 未显式设置字号，正文回退为 11pt，
+     不符合 GB/T 9704「正文用三号仿宋_GB2312（16pt）」；
+  3) 初稿本身并不合规，需完全依赖后续 optimize 兜底。
+
+本模块改为用 python-docx 直接构建初稿：页面 A4 + 省筹委会页边距、大标题二号
+方正小标宋、黑体一级标题、楷体二级标题、仿宋 16pt 正文、落款/日期、AI 声明段。
+初稿按 rules 配置逐项排版，输出后仍由外部 optimize 做合规兜底修复。
+"""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from docx import Document
+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 Mm, Cm, Pt, RGBColor
+
+from engine.core.document.font_utils import set_run_font, BODY_FONT, LATIN_FONT
+
+# ---------------------------------------------------------------------------
+#  小工具
+# ---------------------------------------------------------------------------
+
+_ALIGN_MAP = {
+    "left": WD_ALIGN_PARAGRAPH.LEFT,
+    "center": WD_ALIGN_PARAGRAPH.CENTER,
+    "right": WD_ALIGN_PARAGRAPH.RIGHT,
+    "justify": WD_ALIGN_PARAGRAPH.JUSTIFY,
+}
+
+
+def _to_pt(value: Any, default: float = 16.0) -> float:
+    """把 '16pt' / 16 / '16磅' 统一转成磅值。"""
+    if value is None:
+        return default
+    if isinstance(value, bool):
+        return default
+    if isinstance(value, (int, float)):
+        return float(value)
+    m = re.match(r"^\s*([\d.]+)\s*(?:pt|磅)?\s*$", str(value))
+    if m:
+        return float(m.group(1))
+    return default
+
+
+def _align(align: str | None):
+    return _ALIGN_MAP.get((align or "").lower(), WD_ALIGN_PARAGRAPH.JUSTIFY)
+
+
+# 中文公文编号标题模式（与 engine parser 的内容信号启发式对齐）
+_H1_RE = re.compile(r"^[一二三四五六七八九十]+、[^、].{0,30}$")
+_H2_RE = re.compile(r"^（[一二三四五六七八九十]+）.{0,40}$")
+_H3_RE = re.compile(r"^\d+[.、].{0,40}$")
+_H4_RE = re.compile(r"^（\d+）.{0,40}$")
+
+
+def _detect_heading_level(text: str) -> int | None:
+    """对未用 # 标记的正文段落做标题层级内容检测。
+
+    返回 1/2/3/4 标题层级；若文本过长或不像标题则返回 None。
+    与 parser._detect_heading_heuristic 的"内容信号"路径保持一致，
+    使 md2docx 初稿即使不写 # 也能套用黑体/楷体等标题格式。
+    """
+    t = (text or "").strip()
+    if not t or len(t) > 40:
+        return None
+    if _H1_RE.match(t):
+        return 1
+    if _H2_RE.match(t):
+        return 2
+    if _H3_RE.match(t):
+        return 3
+    if _H4_RE.match(t):
+        return 4
+    return None
+
+
+def _set_exact_line_spacing(para, pt: float) -> None:
+    """固定行距（GB/T 9704 统一 33 磅）。"""
+    pf = para.paragraph_format
+    pf.line_spacing = Pt(max(6, min(200, pt)))
+    pf.line_spacing_rule = WD_LINE_SPACING.EXACTLY
+
+
+def _apply_doc_defaults(doc: Document, body_pt: float = 16.0) -> None:
+    """设置文档级默认字体与字号，避免正文回退 11pt。
+
+    docDefaults 需同时写入 rFonts（中文字体）与 sz（字号，半磅值）。
+    """
+    try:
+        styles_element = doc.styles.element
+        doc_defaults = styles_element.find(qn("w:docDefaults"))
+        if doc_defaults is None:
+            doc_defaults = OxmlElement("w:docDefaults")
+            styles_element.insert(0, doc_defaults)
+
+        rPrDefault = doc_defaults.find(qn("w:rPrDefault"))
+        if rPrDefault is None:
+            rPrDefault = OxmlElement("w:rPrDefault")
+            doc_defaults.append(rPrDefault)
+        rPr = rPrDefault.find(qn("w:rPr"))
+        if rPr is None:
+            rPr = OxmlElement("w:rPr")
+            rPrDefault.append(rPr)
+
+        rFonts = rPr.find(qn("w:rFonts"))
+        if rFonts is None:
+            rFonts = OxmlElement("w:rFonts")
+            rPr.insert(0, rFonts)
+        rFonts.set(qn("w:ascii"), LATIN_FONT)
+        rFonts.set(qn("w:hAnsi"), LATIN_FONT)
+        rFonts.set(qn("w:eastAsia"), BODY_FONT)
+        rFonts.set(qn("w:cs"), LATIN_FONT)
+
+        # 字号（半磅）：三号 = 16pt → 32
+        sz = rPr.find(qn("w:sz"))
+        if sz is None:
+            sz = OxmlElement("w:sz")
+            rPr.append(sz)
+        sz.set(qn("w:val"), str(int(body_pt * 2)))
+        szCs = rPr.find(qn("w:szCs"))
+        if szCs is None:
+            szCs = OxmlElement("w:szCs")
+            rPr.append(szCs)
+        szCs.set(qn("w:val"), str(int(body_pt * 2)))
+    except Exception:
+        # 失败不影响主流程，仍按逐段显式格式输出
+        pass
+
+
+def _apply_section(doc: Document, page_setup) -> None:
+    """应用页面设置（A4 + 页边距 + 页眉/页脚距离）。"""
+    if not doc.sections:
+        return
+    sec = doc.sections[0]
+    w = getattr(page_setup, "paper_width_mm", None) or 210
+    h = getattr(page_setup, "paper_height_mm", None) or 297
+    sec.page_width = Mm(w)
+    sec.page_height = Mm(h)
+    sec.top_margin = Mm(getattr(page_setup, "margin_top_mm", None) or 28.0)
+    sec.bottom_margin = Mm(getattr(page_setup, "margin_bottom_mm", None) or 28.0)
+    sec.left_margin = Mm(getattr(page_setup, "margin_left_mm", None) or 27.0)
+    sec.right_margin = Mm(getattr(page_setup, "margin_right_mm", None) or 27.0)
+    sec.header_distance = Cm(getattr(page_setup, "header_distance_cm", None) or 1.5)
+    sec.footer_distance = Cm(getattr(page_setup, "footer_distance_cm", None) or 2.3)
+
+
+# ---------------------------------------------------------------------------
+#  段落排版（按角色 / 标题层级套用 GB/T 9704 默认）
+# ---------------------------------------------------------------------------
+
+def _role_style(rules: dict, para) -> dict:
+    """根据段落角色/标题层级返回默认排版字典。"""
+    cfg = rules or {}
+    if getattr(para, "is_heading", False) and para.heading_level == 0:
+        c = cfg.get("doc_title", {})
+        return {
+            "font": c.get("font", "方正小标宋简体"),
+            "size": _to_pt(c.get("size", 22)),
+            "bold": bool(c.get("bold", False)),
+            "align": c.get("align", "center"),
+            "indent_em": 0,
+            "line": _to_pt(c.get("line_spacing", 33), 33),
+        }
+    if getattr(para, "is_heading", False) and para.heading_level == 1:
+        c = cfg.get("heading_1", {})
+        return {
+            "font": c.get("font", "黑体"),
+            "size": _to_pt(c.get("size", 16)),
+            "bold": bool(c.get("bold", False)),
+            "align": "left",
+            "indent_em": 2,
+            "line": _to_pt(c.get("line_spacing", 33), 33),
+        }
+    if getattr(para, "is_heading", False) and para.heading_level == 2:
+        c = cfg.get("heading_2", {})
+        return {
+            "font": c.get("font", "楷体_GB2312"),
+            "size": _to_pt(c.get("size", 16)),
+            "bold": bool(c.get("bold", False)),
+            "align": "left",
+            "indent_em": 2,
+            "line": _to_pt(c.get("line_spacing", 33), 33),
+        }
+    if getattr(para, "is_heading", False) and para.heading_level == 3:
+        c = cfg.get("heading_3", {})
+        return {
+            "font": c.get("font", "仿宋_GB2312"),
+            "size": _to_pt(c.get("size", 16)),
+            "bold": bool(c.get("bold", True)),
+            "align": "left",
+            "indent_em": 2,
+            "line": _to_pt(c.get("line_spacing", 33), 33),
+        }
+
+    role = para.role
+    if role == "recipient":
+        c = cfg.get("salutation", {})
+        return {
+            "font": c.get("font", "仿宋_GB2312"),
+            "size": _to_pt(c.get("size", 16)),
+            "bold": False,
+            "align": c.get("align", "left"),
+            "indent_em": 0,
+            "line": _to_pt(c.get("line_spacing", 33), 33),
+        }
+    if role == "salutation":
+        c = cfg.get("salutation", {})
+        return {
+            "font": c.get("font", "仿宋_GB2312"),
+            "size": _to_pt(c.get("size", 16)),
+            "bold": False,
+            "align": c.get("align", "left"),
+            "indent_em": 0,
+            "line": _to_pt(c.get("line_spacing", 33), 33),
+        }
+    if role == "signature":
+        c = cfg.get("signature", {})
+        return {
+            "font": c.get("font", "仿宋_GB2312"),
+            "size": _to_pt(c.get("size", 18), 18),
+            "bold": bool(c.get("bold", False)),
+            "align": c.get("align", "center"),
+            "indent_em": 0,
+            "line": _to_pt(c.get("line_spacing", 33), 33),
+        }
+    if role == "date":
+        c = cfg.get("date", {})
+        # P2-19 修复：GB/T 9704 成文日期"右空四字"——日期右对齐且右侧留 4 字空位
+        # 规则值可能是数字 4 或字符串 "4em"，统一解析为 em 数值
+        _ri_raw = c.get("right_indent", 4)
+        try:
+            _ri_em = float(str(_ri_raw).replace("em", "").strip())
+        except (ValueError, TypeError):
+            _ri_em = 4.0
+        return {
+            "font": c.get("font", "仿宋_GB2312"),
+            "size": _to_pt(c.get("size", 16)),
+            "bold": False,
+            "align": c.get("align", "right"),
+            "indent_em": 0,
+            "right_indent_em": _ri_em,
+            "line": _to_pt(c.get("line_spacing", 33), 33),
+        }
+    if role == "attachment":
+        c = cfg.get("body", {})
+        return {
+            "font": c.get("font", "仿宋_GB2312"),
+            "size": _to_pt(c.get("size", 16)),
+            "bold": False,
+            "align": c.get("align", "justify"),
+            "indent_em": 2,
+            "line": _to_pt(c.get("line_spacing", 33), 33),
+        }
+
+    # 默认正文
+    c = cfg.get("body", {})
+    return {
+        "font": c.get("font", "仿宋_GB2312"),
+        "size": _to_pt(c.get("size", 16)),
+        "bold": False,
+        "align": c.get("align", "justify"),
+        "indent_em": 2,
+        "line": _to_pt(c.get("line_spacing", 33), 33),
+    }
+
+
+def _add_paragraph(doc: Document, para, rules: dict):
+    """把模型段落写入 docx（返回 python-docx Paragraph 对象）。"""
+    style = _role_style(rules, para)
+
+    # 未用 # 标记的编号标题内容检测（一、/（一）/1./（1））：
+    # 即便 markdown 未写 ##，也套用黑体/楷体等标题格式，与 check 的启发式一致
+    if not getattr(para, "is_heading", False) and para.role in (None, "body", "recipient"):
+        _detected = _detect_heading_level(para.text)
+        if _detected == 1:
+            _c = (rules or {}).get("heading_1", {})
+            style = {"font": _c.get("font", "黑体"), "size": _to_pt(_c.get("size", 16)),
+                     "bold": False, "align": "left", "indent_em": 2,
+                     "line": _to_pt(_c.get("line_spacing", 33), 33)}
+        elif _detected == 2:
+            _c = (rules or {}).get("heading_2", {})
+            style = {"font": _c.get("font", "楷体_GB2312"), "size": _to_pt(_c.get("size", 16)),
+                     "bold": False, "align": "left", "indent_em": 2,
+                     "line": _to_pt(_c.get("line_spacing", 33), 33)}
+        elif _detected == 3:
+            _c = (rules or {}).get("heading_3", {})
+            style = {"font": _c.get("font", "仿宋_GB2312"), "size": _to_pt(_c.get("size", 16)),
+                     "bold": True, "align": "left", "indent_em": 2,
+                     "line": _to_pt(_c.get("line_spacing", 33), 33)}
+        elif _detected == 4:
+            _c = (rules or {}).get("heading_4", {})
+            style = {"font": _c.get("font", "仿宋_GB2312"), "size": _to_pt(_c.get("size", 16)),
+                     "bold": False, "align": "left", "indent_em": 2,
+                     "line": _to_pt(_c.get("line_spacing", 33), 33)}
+
+    p = doc.add_paragraph()
+    pf = p.paragraph_format
+
+    # 主送机关/称呼段：顶格左对齐、无首行缩进（GB/T 9704）
+    # 通过 role 或文本特征（短文本以 ：/: 结尾）识别，兼容 recipient 放正文的草稿
+    _is_salutation = para.role in ("recipient", "salutation") or (
+        para.role in (None, "body")
+        and len((para.text or "").strip()) <= 50
+        and (para.text or "").strip().endswith(("：", ":"))
+    )
+
+    # 对齐：主送机关/称呼段强制左对齐；其余优先模型显式值
+    if _is_salutation:
+        p.alignment = WD_ALIGN_PARAGRAPH.LEFT
+        pf.first_line_indent = Pt(0)
+    elif para.format.alignment:
+        p.alignment = _align(para.format.alignment)
+        # 首行缩进：2em = 2 × 字号
+        if para.format.first_line_indent_pt is not None and para.format.first_line_indent_pt > 0:
+            pf.first_line_indent = Pt(para.format.first_line_indent_pt)
+        elif style["indent_em"] > 0 and para.text.strip():
+            pf.first_line_indent = Pt(style["indent_em"] * style["size"])
+        else:
+            pf.first_line_indent = Pt(0)
+    else:
+        p.alignment = _align(style["align"])
+        if style["indent_em"] > 0 and para.text.strip():
+            pf.first_line_indent = Pt(style["indent_em"] * style["size"])
+        else:
+            pf.first_line_indent = Pt(0)
+
+    # 左缩进（列表等）
+    if para.format.left_indent_pt is not None:
+        pf.left_indent = Pt(para.format.left_indent_pt)
+
+    # P2-19：右缩进（成文日期"右空四字"等）
+    _right_em = style.get("right_indent_em")
+    if _right_em:
+        pf.right_indent = Pt(float(_right_em) * float(style["size"]))
+
+    # 行距
+    if para.format.line_spacing_pt is not None:
+        _set_exact_line_spacing(p, para.format.line_spacing_pt)
+    else:
+        _set_exact_line_spacing(p, style["line"])
+
+    # runs
+    runs = para.runs if para.runs else []
+    if not runs and para.text:
+        # 无 run 时按段落默认创建单 run
+        run = p.add_run(para.text)
+        set_run_font(run, style["font"])
+        run.font.size = Pt(style["size"])
+        if style["bold"]:
+            run.font.bold = True
+    else:
+        for r in runs:
+            if not r.text:
+                continue
+            run = p.add_run(r.text)
+            fmt = r.format
+            font = fmt.font_name or style["font"]
+            size = fmt.font_size_pt if fmt.font_size_pt is not None else style["size"]
+            set_run_font(run, font)
+            run.font.size = Pt(size)
+            if fmt.bold is not None:
+                run.font.bold = fmt.bold
+            elif style["bold"]:
+                run.font.bold = True
+            if fmt.italic is not None:
+                run.font.italic = fmt.italic
+            if fmt.strikethrough is True:
+                run.font.strike = True
+            if fmt.color:
+                try:
+                    rgb = str(fmt.color).lstrip("#")
+                    run.font.color.rgb = RGBColor(int(rgb[0:2], 16), int(rgb[2:4], 16), int(rgb[4:6], 16))
+                except Exception:
+                    pass
+    return p
+
+
+def _add_table(doc: Document, tbl, anchor_elem) -> None:
+    """创建 Word 表格并插到锚点段落之后。"""
+    if tbl.rows <= 0 or tbl.cols <= 0:
+        return
+    table = doc.add_table(rows=tbl.rows, cols=tbl.cols)
+    table.style = "Table Grid"
+    # 把表格移动到锚点元素之后
+    if anchor_elem is not None:
+        anchor_elem.addnext(table._tbl)
+
+    cells_by = {}
+    for c in tbl.cells:
+        cells_by[(c.row, c.col)] = c
+
+    for row in range(tbl.rows):
+        for col in range(tbl.cols):
+            cell_model = cells_by.get((row, col))
+            text = cell_model.text if cell_model else ""
+            cell = table.cell(row, col)
+            # 清空默认段落，写入一个 run
+            cell.text = ""
+            para = cell.paragraphs[0]
+            is_header = row == 0
+            run = para.add_run(text)
+            if is_header:
+                set_run_font(run, "黑体")
+                run.font.size = Pt(12)
+                run.font.bold = True
+                para.alignment = _align("center")
+            else:
+                set_run_font(run, "仿宋_GB2312")
+                run.font.size = Pt(12)
+                para.alignment = _align("left")
+
+
+def _add_ai_declaration(doc: Document) -> None:
+    """文档末尾追加 AI 声明段（楷体 9pt 居中，pStyle 标记为 Annotation）。"""
+    ai_text = "（内容由GongWen-skill-AI生成，仅供参考）"
+    para = doc.add_paragraph()
+    para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    p_elem = para._element
+    pPr = p_elem.get_or_add_pPr()
+    pStyle = pPr.find(qn("w:pStyle"))
+    if pStyle is None:
+        pStyle = OxmlElement("w:pStyle")
+        pPr.insert(0, pStyle)
+    pStyle.set(qn("w:val"), "Annotation")
+    run = para.add_run(ai_text)
+    set_run_font(run, "楷体_GB2312")
+    run.font.size = Pt(9)
+    run.font.color.rgb = RGBColor(0x00, 0x00, 0x00)
+
+
+# ---------------------------------------------------------------------------
+#  主入口
+# ---------------------------------------------------------------------------
+
+def render_model_to_docx(model, output_path, rules: dict | None = None,
+                         no_ai_declaration: bool = False):
+    """用 python-docx 直接按 GB/T 9704 把 DocumentModel 渲染为 .docx。
+
+    替代 generate_docx（不依赖 engine.core.document.parser 等管线模块，
+    直接显式排版，保证初稿即合规）。
+    """
+    import os
+    doc = Document()
+
+    _apply_doc_defaults(doc, body_pt=16.0)
+    _apply_section(doc, model.page_setup)
+
+    # 清理源文中的 AI 声明段落（如 "*（内容由AI生成，仅供参考）*"），
+    # 避免正文中遗留重复声明，统一由 _add_ai_declaration 追加格式化版本
+    _AI_PATTERNS = ("由GongWen-skill-AI生成", "由AI生成", "仅供参考")
+    for pi in range(len(model.paragraphs) - 1, -1, -1):
+        txt = (model.paragraphs[pi].text or "").replace("*", "").strip()
+        if any(m in txt for m in _AI_PATTERNS):
+            del model.paragraphs[pi]
+
+    # 表格按锚点段落索引分组
+    table_map: dict[int, list] = {}
+    for t in model.tables:
+        table_map.setdefault(t.insert_after_index, []).append(t)
+
+    # 渲染段落；表格插到其锚点段落之后
+    last_elem = None
+    for i, para in enumerate(model.paragraphs):
+        p = _add_paragraph(doc, para, rules)
+        last_elem = p._element
+        for t in table_map.get(i, []):
+            _add_table(doc, t, last_elem)
+
+    # 锚点为 -1（文档开头）的表格
+    for t in table_map.get(-1, []):
+        if doc.paragraphs:
+            _add_table(doc, t, doc.paragraphs[0]._element)
+        else:
+            _add_table(doc, t, None)
+
+    # 锚点超出末尾（最后一个段落之后）
+    for t in table_map.get(len(model.paragraphs), []):
+        _add_table(doc, t, last_elem)
+
+    # AI 声明
+    if not no_ai_declaration:
+        _add_ai_declaration(doc)
+
+    if isinstance(output_path, str):
+        out = output_path
+        parent = os.path.dirname(os.path.abspath(out))
+        if parent:
+            os.makedirs(parent, exist_ok=True)
+    else:
+        out = output_path
+    doc.save(out)
+    return output_path

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gongwen-skill",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "公文全流程处理工具 - GB/T 9704 格式检查/修复/内容优化/模板生成/版式注入",
   "type": "module",
   "main": "dsh/index.js",

package/prompts/usage-prompts.md

@@ -201,7 +201,7 @@ python -m gongwen optimize 文件.docx -o 优化版.docx
 **Agent 响应**：
 ```
 📋 合规自检报告
-Skill 版本: v2.1.0
+Skill 版本: v2.2.0
 路径判定: B（内容优化）
 依据: 用户提供纯文本+优化要求，无已有文档
 命令调用: 将原文保存为临时文件后执行 optimize-content --apply --paragraphs "1-3"

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gongwen-skill"
-version = "2.1.0"
+version = "2.2.0"
 description = "公文全流程处理工具 - GB/T 9704 格式检查/修复/内容优化/模板生成/版式注入"
 readme = "README.md"
 license = {text = "MIT"}

package/rules/official/_common.yaml

@@ -538,7 +538,7 @@ check_rules:
     severity: P1
     field: page_number.alignment
     expected: "center"
-    message: "页码应居中标注，格式为- X -（半角短横线）（GB/T 9704标准）"
+    message: "页码应居中标注，或多页文档采用翻页模式（单页码居右、双页码居左），格式为- X -（半角短横线）（GB/T 9704标准）"
 
   - id: CHK-C029
     name: "页码字号检查"
@@ -792,8 +792,8 @@ fix_rules:
     value:
       font: "宋体"
       size: 14pt
-      alignment: "center"
-      format: "- {PAGE} -"   # 改动4：半角短横线（PDF 规范），原全角破折号
+      alignment: "right"
+      format: "- {PAGE} -"   # 改动4：半角短横线（PDF 规范），原全角破折号；翻页模式（单右双左）
 
   # --- 段落类型格式修复 (P4/P5/P8: FIX-C013b/FIX-C041~C044) ---
   - id: FIX-C013b