gongwen-skill 2.4.0 → 2.6.0

package/CHANGELOG.md

@@ -4,6 +4,31 @@
   Licensed under the MIT License. See the LICENSE file for details.
 -->
 
+## v2.6.0 (2026-09-02)
+
+### Added
+- **check-update 判定渠道精简为 PyPI + GitHub 双权威源**：对齐 EasyTier 单权威源 + 加速代理设计，GitCode/AtomGit 不再参与版本判定（零增量镜像），降为 GitHub 不可达时的国内拉取镜像提示；--json 输出新增 mirrors 字段
+- **GitHub 国内访问优化**：并发查询 + 分级超时（PyPI 10s / GitHub 8s 快速降级），GitHub 不可达时提示 GitHub520 hosts 方案与国内镜像地址
+- **发布流程修复（三平台 Release 统一编号）**：ci.yml 新增 release job，tag 推送自动创建 GitHub Release（编号 = tag）；RELEASE.md 发布流程新增 GitHub Release 自动创建 + GitCode/AtomGit Release 同步（编号与 tag 统一）
+- **非必要文件不同步原则写入发布流程**：RELEASE.md 明确临时/调试文件（tmp_*、_gw_* 等）不提交、不入库、不同步三仓库
+
+### Changed
+- check-update 头部与末尾文案同步为 PyPI + GitHub 判定；--json 的 channels 字段只含 PyPI/GitHub
+- README / RELEASE.md 文档同步更新（判定渠道、镜像提示、Release 统一编号说明）
+
+### Fixed
+- 历史遗留：v2.0.0~v2.5.0 在 GitHub/GitCode 从未创建 Release 对象（仅 tag），已补建且编号与 tag 统一
+## v2.5.0 (2026-09-01)
+
+### Added
+- **样式学习引擎修复**：style-learn 多 section 文档只学主文档（不再把横向附件页当正文页）；页边距 mm→cm 换算修复（26.9mm 不再写成 26.9cm）；角色判定增强（识别红头版头/发文字号/整段日期/落款机关名）；解析 styles.xml 样式链（basedOn + docDefaults），run 未指定 eastAsia 时继承段落样式字体，修复落款误学 Times New Roman
+- **模板规则断链打通**：manager 新增 _sync_style_expected，将配置段权威样式值（doc_title/body/signature/date/table/page_setup 等）同步到 CHK expected 与 FIX value（标量覆盖 + 复合 dict 保守合并），使 style-learn 模板 / user_rules / config-overrides 覆盖配置段后 check/optimize 期望值自动跟随
+
+### Fixed
+- **style-learn 学错横向附件页**：多 section 文档（正文纵向 + 附件横向）此前学到 297×210mm 横向纸张与附件页边距
+- **样式继承未解析**：run 无显式 eastAsia 时直接回退 ascii=Times New Roman，现按段落样式链（basedOn → docDefaults）解析正确中文字体
+- **模板样式不生效**：style-learn 生成的模板仅覆盖配置段，但 CHK expected/FIX value 硬编码在规则 YAML，导致 -t 模板时检查/修复仍用默认值——现已打通
+
 ## v2.4.0 (2026-09-01)
 
 ### Added

package/README.md

@@ -45,7 +45,7 @@ Licensed under the MIT License. See the LICENSE file for details.
 | 🔍 审稿生成 | `review` | 按五角色审稿机制生成审稿意见 |
 | 🧩 完整审校 | `full-review` | 修订+批注联合命令（句子级差异修订 + 分类批注） |
 | 🎨 样式学习 | `style-learn` / `style-list` | 上传标准文档学习 Run/段落/页面三级样式（字体/字号/字间距/行距/缩进/页边距），生成命名模板持久化，后续用 `optimize -t 模板名` 套用 |
-| 🔄 版本自检 | `check-update` | 多渠道版本自检（GitHub/GitCode/AtomGit 三仓库比对取最新） |
+| 🔄 版本自检 | `check-update` | 版本自检（PyPI + GitHub 双判定渠道，GitCode/AtomGit 作国内镜像提示） |
 | 🩺 自我诊断 | `doctor` / `repair` | 全面诊断 22 项（Python/依赖/版本一致性/字体/DSH 文件/DSH 技能 frontmatter/代码风格），自动修复常见问题 |
 | 🕵️ 文档审计 | `audit` | 检查删除线/加粗/AI 声明等痕迹 |
 | 🤝 会话交接 | `handoff` | 跨会话上下文传递（`--list` / `--latest` / Agent 长任务收尾必写） |
@@ -150,7 +150,7 @@ python -m gongwen footer 红头公文.docx --cc "各单位" --printer "XX办公
 # 注入页码（Word PAGE 域动态页码）
 python -m gongwen pagenum 红头公文.docx --alignment right
 
-# 多渠道版本自检
+# 版本自检（PyPI + GitHub 双判定渠道）
 python -m gongwen check-update
 
 # 安装公文标准字体（方正小标宋简体/仿宋_GB2312/楷体_GB2312）
@@ -317,7 +317,7 @@ python -m gongwen rule-list notice
 
 Agent 加载 skill 后**必须执行版本追新自检**，确保使用最新版本：
 
-1. **多渠道远程自检**（首选）：`python -m gongwen check-update`——自动查询 GitHub/GitCode/AtomGit 三仓库最新 tag，取最高版本比对本地；任一渠道可达即不遗漏，全部不可达时明确告知"版本自检跳过"
+1. **远程自检**（首选）：`python -m gongwen check-update`——以 **PyPI（发布源）+ GitHub（代码权威源）双判定渠道**并发查询，取最高版本比对本地；任一判定渠道可达即不遗漏，全部不可达时明确告知"版本自检跳过"。GitHub 为海外渠道（国内常超时）采用短超时快速降级；GitHub 不可达时自动提示国内代码镜像（GitCode/AtomGit，与 GitHub 同源 tag）与 GitHub520 hosts 加速方案
 2. **本地 git tag 对比**（补充）：对 skill 安装目录执行 `git -C "<skill安装目录>" describe --tags --abbrev=0`；若安装目录不在 git 管理下，应告知用户"无法执行版本对比，建议手动检查 GitHub 更新"
 3. **落后则警告**：发现本地版本落后于最新 tag 时，**必须在执行前警告用户**并提示更新（`cd <gongwen-skill目录> && git pull && git fetch --tags`），不得静默使用旧版本
 
@@ -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.4.0
+python -m gongwen --version       # 检验：gongwen-skill v2.6.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.4.0"
+    "gongwen-skill": "^2.6.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.4.0+ |
+| DSH 配置化排版参数（页边距/行距/字体/默认模板版本） | ✅ v2.6.0+ |
 
-### DSH 插件配置化（v2.4.0+）
+### DSH 插件配置化（v2.6.0+）
 
 DSH 插件支持通过配置文件管理排版参数，Agent 调用时自动注入，纯 CLI 用户不受影响。
 
@@ -574,7 +574,7 @@ pip install -r requirements.txt
 用户：帮我优化这份会议通知的第二章节措辞
 
 Agent：📋 合规自检报告
-Skill 版本: v2.4.0（多渠道自检已确认最新）
+Skill 版本: v2.6.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.4.0+)
+// 公文全流程处理工具 - DSH plugin bridge (gongwen-skill, v2.6.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/rules/manager.py

@@ -80,6 +80,8 @@ def load_rules_merged(doc_type: str = "") -> dict[str, Any]:
     # Merge fix_rules and check_rules as distinct lists, not overwritten
     merged.setdefault("fix_rules", [])
     merged.setdefault("check_rules", [])
+    # 配置段 → 规则期望值同步：使模板/用户规则覆盖配置段后 check/optimize 自动跟随
+    _sync_style_expected(merged)
     return merged
 
 
@@ -117,6 +119,93 @@ def _deep_merge(base: dict, overlay: dict) -> None:
             base[key] = copy.deepcopy(val)
 
 
+# 字段前缀 → 配置段键（配置段是样式的权威定义）
+_FIELD_CFG_SECTION = {
+    'title': 'doc_title', 'doc_title': 'doc_title', 'heading_0': 'doc_title',
+    'heading_1': 'heading_1', 'heading_2': 'heading_2',
+    'heading_3': 'heading_3', 'heading_4': 'heading_4',
+    'body': 'body', 'signature': 'signature', 'date': 'date',
+    'meeting_date': 'meeting_date', 'salutation': 'salutation',
+    'introduction': 'introduction', 'transition': 'transition',
+}
+# 可直接同名映射的样式子键
+_STYLE_KEYS = {'font', 'size', 'line_spacing', 'align', 'bold',
+               'first_line_indent', 'fill'}
+
+
+def _resolve_style_config(rules: dict[str, Any], field: str):
+    """按 field 路径取配置段的权威样式值；无法解析返回 None。
+
+    样式配置段（doc_title/body/signature/date/heading_*/table/page_setup）
+    是样式的权威定义；check_rules.expected 与 fix_rules.value 默认是它的快照副本。
+    模板/用户规则覆盖配置段后，此函数负责把覆盖值回填到检查/修复规则。
+    """
+    if not field or '.' not in field:
+        return None
+    prefix, sub = field.split('.', 1)
+
+    # table.* / page_setup.* 直接按路径取（table.header.font → table.header.font）
+    if prefix in ('table', 'page_setup'):
+        node = rules
+        for part in field.split('.'):
+            if not isinstance(node, dict) or part not in node:
+                return None
+            node = node[part]
+        if isinstance(node, (dict, list)):
+            return None
+        return node
+
+    section = _FIELD_CFG_SECTION.get(prefix)
+    if section is None or sub not in _STYLE_KEYS:
+        return None
+    cfg = rules.get(section)
+    if not isinstance(cfg, dict) or sub not in cfg:
+        return None
+    val = cfg[sub]
+    if isinstance(val, (dict, list)):
+        return None
+    return val
+
+
+def _sync_style_expected(rules: dict[str, Any]) -> None:
+    """把配置段的权威样式值同步到 CHK expected 与 FIX value（就地修改）。
+
+    使 style-learn 模板 / user_rules / config-overrides 覆盖配置段后，
+    check 与 optimize 的期望值自动跟随，而默认配置下幂等（配置段值==快照值）。
+    """
+    # 1) 同步 check_rules.expected
+    for rule in rules.get('check_rules', []):
+        resolved = _resolve_style_config(rules, rule.get('field', ''))
+        if resolved is not None:
+            rule['expected'] = resolved
+
+    # 2) 同步 fix_rules.value（经 ref_check 定位 CHK → field → 配置值）
+    # 保守策略：标量 value 可直接覆盖；复合 dict value（一次修复多属性）仅合并
+    # 格式一致的键（alignment/bold/fill），避免破坏 FIX-C013/C041 等复合修复。
+    chk_by_id = {r.get('id'): r for r in rules.get('check_rules', []) if r.get('id')}
+    for rule in rules.get('fix_rules', []):
+        ref = rule.get('ref_check')
+        if not ref or ref not in chk_by_id:
+            continue
+        resolved = _resolve_style_config(rules, chk_by_id[ref].get('field', ''))
+        if resolved is None or rule.get('value') is None:
+            continue
+        value = rule['value']
+        # 样式配置子键（如 body.align → align）→ FIX value dict 中的键名映射
+        _FIX_DICT_KEY = {
+            'align': 'alignment',
+            'bold': 'bold',
+            'fill': 'fill',
+        }
+        if isinstance(value, dict):
+            sub_field = chk_by_id[ref].get('field', '').split('.', 1)[-1]
+            dk = _FIX_DICT_KEY.get(sub_field)
+            if dk and dk in value and not isinstance(resolved, (dict, list)):
+                value[dk] = resolved
+        else:
+            rule['value'] = resolved
+
+
 def _dedup_extend(base_list: list, new_items: list, dedup_key) -> None:
     """Extend base_list with new_items, replacing duplicates by dedup_key."""
     # P2-25 修复：dedup_key 返回 None 时给出 warning，避免静默追加重复项
@@ -327,6 +416,8 @@ def apply_config_overrides(rules: dict[str, Any], overrides: dict[str, Any]) ->
     if not overrides or not isinstance(overrides, dict):
         return rules
     _deep_merge(rules, copy.deepcopy(overrides))
+    # 配置段 → 规则期望值同步：config-overrides 覆盖后 check/optimize 自动跟随
+    _sync_style_expected(rules)
     return rules
 
 

package/engine/style_profile.py

@@ -110,7 +110,9 @@ def _extract_run_style(rPr) -> Dict[str, Any]:
             v = rFonts.get(f'{{{W}}}{attr}')
             if v:
                 style[f'font_{attr}'] = v
-        style['font'] = (rFonts.get(f'{{{W}}}eastAsia') or rFonts.get(f'{{{W}}}ascii') or '')
+        # font 仅取 eastAsia（中文字体）；ascii 仅用于西文 run，
+        # 避免中文 run 无 eastAsia 时误学成 Times New Roman 等默认拉丁字体
+        style['font'] = (rFonts.get(f'{{{W}}}eastAsia') or '')
 
     sz = rPr.find(f'{{{W}}}sz')
     if sz is not None:
@@ -181,6 +183,64 @@ def _extract_para_style(pPr) -> Dict[str, Any]:
     return style
 
 
+def _load_style_fonts(docx_path: str | Path) -> Dict[str, Dict[str, Any]]:
+    """解析 styles.xml，构建 styleId → 解析后的中文字体/字号映射。
+
+    沿 basedOn 样式链向上解析（含环保护），最终回退到 docDefaults，
+    供 run 未显式指定 eastAsia 字体时继承段落样式的中文字体。
+    """
+    fonts: Dict[str, Dict[str, Any]] = {}
+    with zipfile.ZipFile(docx_path) as z:
+        if 'word/styles.xml' not in z.namelist():
+            return fonts
+        styles = etree.fromstring(z.read('word/styles.xml'))
+
+    raw: Dict[str, Dict[str, Any]] = {}
+    for st in styles.findall(f'{{{W}}}style'):
+        sid = st.get(f'{{{W}}}styleId')
+        if not sid:
+            continue
+        rPr = st.find(f'{{{W}}}rPr')
+        rf = rPr.find(f'{{{W}}}rFonts') if rPr is not None else None
+        sz = rPr.find(f'{{{W}}}sz') if rPr is not None else None
+        bo = st.find(f'{{{W}}}basedOn')
+        sz_val = sz.get(f'{{{W}}}val') if sz is not None else None
+        raw[sid] = {
+            'eastAsia': rf.get(f'{{{W}}}eastAsia') if rf is not None else None,
+            'size_pt': int(sz_val) / 2.0 if sz_val else None,
+            'basedOn': bo.get(f'{{{W}}}val') if bo is not None else None,
+        }
+
+    # docDefaults（文档默认字体）
+    defaults: Dict[str, Any] = {'eastAsia': None, 'size_pt': None}
+    dd = styles.find(f'{{{W}}}docDefaults')
+    if dd is not None:
+        rf = dd.find(f'{{{W}}}rPrDefault/{{{W}}}rPr/{{{W}}}rFonts')
+        if rf is not None:
+            defaults['eastAsia'] = rf.get(f'{{{W}}}eastAsia')
+        sz = dd.find(f'{{{W}}}rPrDefault/{{{W}}}rPr/{{{W}}}sz')
+        sz_val = sz.get(f'{{{W}}}val') if sz is not None else None
+        if sz_val:
+            defaults['size_pt'] = int(sz_val) / 2.0
+
+    def resolve(sid: str, seen: frozenset) -> Dict[str, Any]:
+        if sid in fonts:
+            return fonts[sid]
+        if sid in seen or sid not in raw:
+            return dict(defaults)
+        cur = raw[sid]
+        parent = resolve(cur.get('basedOn') or '', seen | {sid}) if cur.get('basedOn') else dict(defaults)
+        return {
+            'eastAsia': cur.get('eastAsia') or parent.get('eastAsia'),
+            'size_pt': cur.get('size_pt') if cur.get('size_pt') is not None else parent.get('size_pt'),
+        }
+
+    for sid in raw:
+        if sid not in fonts:
+            fonts[sid] = resolve(sid, frozenset())
+    return fonts
+
+
 # ---------------------------------------------------------------------------
 #  主学习流程
 # ---------------------------------------------------------------------------
@@ -199,8 +259,30 @@ def learn_style_profile(docx_path: str | Path) -> StyleProfile:
 
     profile = StyleProfile()
 
+    # 加载 styles.xml 样式链字体映射（供 run 未显式指定 eastAsia 时继承段落样式字体）
+    style_fonts = _load_style_fonts(docx_path)
+
     # ---- 页面设置 ----
-    sectPr = body.find(f'{{{W}}}sectPr')
+    def _find_main_sect_pr(body_el) -> Optional[etree._Element]:
+        """定位主文档（第一节）的 sectPr。
+
+        多 section 文档（如正文纵向 + 附件横向）第一节的 sectPr 内嵌于
+        首个分节符段落 pPr；单 section 文档即 body 末尾 sectPr。
+        避免用 body.find() 只能取到最后一节（如横向附件页）而学错纸张/边距。
+        """
+        for child in body_el:
+            tag = etree.QName(child.tag).localname if child.tag else ''
+            if tag == 'p':
+                pPr = child.find(f'{{{W}}}pPr')
+                if pPr is not None:
+                    s = pPr.find(f'{{{W}}}sectPr')
+                    if s is not None:
+                        return s
+            elif tag == 'sectPr':
+                return child
+        return body_el.find(f'{{{W}}}sectPr')
+
+    sectPr = _find_main_sect_pr(body)
     if sectPr is not None:
         pgSz = sectPr.find(f'{{{W}}}pgSz')
         if pgSz is not None:
@@ -232,12 +314,33 @@ def learn_style_profile(docx_path: str | Path) -> StyleProfile:
         if not texts:
             continue
         pPr = p.find(f'{{{W}}}pPr')
+        # 段落样式 id（用于 run 无显式 eastAsia 时的样式继承解析）
+        p_style_id = None
+        if pPr is not None:
+            _ps = pPr.find(f'{{{W}}}pStyle')
+            if _ps is not None:
+                p_style_id = _ps.get(f'{{{W}}}val')
+        para_style_font = style_fonts.get(p_style_id, {}) if p_style_id else {}
+
         runs = p.findall(f'{{{W}}}r')
         run_styles = []
         for r in runs:
+            # 跳过无文本或纯空白 run（如落款/署名前导空格产生的空 run），
+            # 避免把 Word 默认 Latin 字体（Times New Roman）误学成中文样式
+            r_text = ''.join(t.text or '' for t in r.iter(f'{{{W}}}t')).strip()
+            if not r_text:
+                continue
             rPr = r.find(f'{{{W}}}rPr')
             if rPr is not None:
                 rs = _extract_run_style(rPr)
+                # 样式继承：run 未显式指定 eastAsia/字号时，从段落样式链回退
+                # （font 可能被 _extract_run_style 置为空串 ''，需用直接赋值覆盖）
+                if rs.get('font_eastAsia') is None and para_style_font.get('eastAsia'):
+                    if not rs.get('font'):
+                        rs['font'] = para_style_font['eastAsia']
+                    rs['font_eastAsia'] = para_style_font['eastAsia']
+                if rs.get('size_pt') is None and para_style_font.get('size_pt'):
+                    rs['size_pt'] = para_style_font['size_pt']
                 if rs:
                     run_styles.append(rs)
 
@@ -251,7 +354,14 @@ def learn_style_profile(docx_path: str | Path) -> StyleProfile:
         size = first_run.get('size_pt', 0)
         _font = first_run.get('font', '')  # noqa: F841
 
-        if idx == 0 and align == 'center':
+        # 红头版头：超大字号（>=36pt）居中，跳过学习（不计入 doc_title/body）
+        if size >= 36 and align == 'center':
+            role = 'letterhead'
+        # 发文字号：居中、含〔〕或【】、字小、文本短（如 民筹办函〔2026〕 号），跳过学习
+        elif align == 'center' and ('〔' in texts or '【' in texts) \
+                and size <= 18 and len(texts) < 30:
+            role = 'letterhead'
+        elif idx == 0 and align == 'center':
             role = 'doc_title'
         elif size >= 20 and align == 'center':
             role = 'doc_title'
@@ -261,10 +371,15 @@ def learn_style_profile(docx_path: str | Path) -> StyleProfile:
             role = 'heading_2'
         elif re.match(r'^\d+[\.、]', texts):
             role = 'heading_3'
-        elif align == 'right' and ('年' in texts and '月' in texts and '日' in texts):
+        # 成文日期：整段为 YYYY年M月D日（与对齐无关，优先于落款判定）
+        elif re.fullmatch(r'[\s\u3000]*\d{4}年\d{1,2}月\d{1,2}日[\s\u3000]*', texts):
             role = 'date'
         elif align == 'right':
             role = 'signature'
+        # 落款机关名：右对齐或居中且以机关特征词结尾
+        elif align in ('right', 'center') and re.search(
+                r'(办公室|委员会|运动会|管理局|人民政府|厅|局)$', texts.strip()):
+            role = 'signature'
         elif texts.endswith(('：', ':')):
             role = 'recipient'  # 与 parser 一致：冒号结尾为主送机关
 
@@ -341,10 +456,11 @@ def build_user_rule_yaml(profile: StyleProfile, template_name: str) -> str:
             'paper_width_mm': profile.page.get('width_mm'),
             'paper_height_mm': profile.page.get('height_mm'),
             'margins': {
-                'top': f"{profile.margins.get('top', 2.8)}cm",
-                'bottom': f"{profile.margins.get('bottom', 2.8)}cm",
-                'left': f"{profile.margins.get('left', 2.7)}cm",
-                'right': f"{profile.margins.get('right', 2.7)}cm",
+                # margins 值存的是 mm，此处换算为 cm（与 _common.yaml 单位一致）
+                'top': f"{profile.margins.get('top', 28.0) / 10.0:.1f}cm",
+                'bottom': f"{profile.margins.get('bottom', 28.0) / 10.0:.1f}cm",
+                'left': f"{profile.margins.get('left', 27.0) / 10.0:.1f}cm",
+                'right': f"{profile.margins.get('right', 27.0) / 10.0:.1f}cm",
             },
         }
 

package/gongwen/__init__.py

@@ -7,7 +7,7 @@
 #
 # 公文全流程处理工具 - gongwen-skill Python package
 
-__version__ = "2.4.0"
+__version__ = "2.6.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.4.0"
+__version__ = "2.6.0"
 # 版本号应与 gongwen/__init__.py 保持一致，每次发版同步更新
 """
 中文公文全流程处理工具 —— 基于 GB/T 9704《党政机关公文格式》国家标准。
@@ -857,7 +857,7 @@ _STYLE_DEVIATION_HINTS = {
 # _VALID_STYLES 已迁移到 gongwen/cli/style_helpers.py
 
 
-# 官方镜像仓库（多渠道版本自检用）
+# 官方镜像仓库（GitHub 为 check-update 判定渠道，GitCode/AtomGit 作国内镜像）
 # PyPI JSON API（无需 git，pip 用户首选渠道）
 # ---------------------------------------------------------------------------
 #  字体管理（install/list/check）
@@ -1076,8 +1076,8 @@ def main():
     p = sub.add_parser("style-list", help="列出所有通过 style-learn 学习的自定义样式模板")
     p.set_defaults(func=cmd_style_list)
 
-    # ---- 多渠道版本自检（PyPI/GitHub/GitCode/AtomGit 比对取最新） ----
-    p = sub.add_parser("check-update", help="多渠道版本自检：查询 PyPI/GitHub/GitCode/AtomGit 四渠道最新版本，取最高版本比对本地")
+    # ---- 版本自检（PyPI + GitHub 双判定渠道，GitCode/AtomGit 作国内镜像） ----
+    p = sub.add_parser("check-update", help="版本自检：PyPI + GitHub 双判定渠道比对本地版本（GitCode/AtomGit 作国内镜像提示）")
     p.add_argument("--json", action="store_true",
                    help="输出 JSON 格式结果（便于 Agent 解析）")
     p.set_defaults(func=cmd_check_update)

package/gongwen/cli/helpers.py

@@ -38,7 +38,7 @@ TYPE_KEYWORDS = {
     "讲话稿": "speech", "主持词": "speech", "新闻稿": "news", "简报": "news",
 }
 
-# 官方镜像仓库（多渠道版本自检用）
+# 官方镜像仓库（GitHub 为 check-update 判定渠道，GitCode/AtomGit 作国内镜像）
 REPO_MIRRORS = {
     "GitHub": "https://github.com/linhut/gongwen-skill.git",
     "GitCode": "https://gitcode.com/linhut/gongwen-skill.git",

package/gongwen/cli/update_cmds.py

@@ -57,11 +57,45 @@ def _latest_tag_from_remote(remote_url: str, timeout: int = 15) -> tuple[bool, s
         return False, str(e)[:120]
 
 
+# 判定渠道（版本从哪来）：
+#   - PyPI   ：发布源（pip 用户首选，国内有镜像）
+#   - GitHub ：代码仓库权威源（git 用户，CI 触发源）
+# GitCode/AtomGit 与 GitHub 是同一份 tag 的镜像（发布时同步 push），
+# 参与版本判定零增量，不列为判定渠道；仅在 GitHub 不可达时作为
+# 国内拉取/加速代理提示（参考 EasyTier「单权威源 + 加速代理」设计）。
+_JUDGMENT_CHANNELS = ("PyPI", "GitHub")
+
+# 渠道分级超时（秒）：GitHub 为海外渠道，国内常超时，用短超时快速降级；
+# PyPI 有国内镜像 CDN，可用较长超时。
+_CHANNEL_TIMEOUTS = {
+    "PyPI": 10,
+    "GitHub": 8,
+}
+
+# 国内代码镜像（加速代理层，非判定渠道）：GitHub 不可达时的 git 拉取替代。
+# 从 REPO_MIRRORS 派生（排除 GitHub），避免 URL 重复维护。
+_GIT_MIRRORS = {k: v for k, v in REPO_MIRRORS.items() if k != "GitHub"}
+
+
+def _fetch_channel(name: str, url: str | None, timeout: int) -> tuple[str, bool, str]:
+    """查询单个渠道，返回 (渠道名, 是否成功, 版本或错误信息)。
+
+    在线程池中执行；内部已捕获异常，不会向外抛出。
+    """
+    if name == "PyPI":
+        ok, val = _latest_version_from_pypi(timeout=timeout)
+    else:
+        ok, val = _latest_tag_from_remote(url, timeout=timeout)
+    return name, ok, val
+
+
 def cmd_check_update(args):
-    """多渠道版本自检：查询 PyPI/GitHub/GitCode/AtomGit 四渠道最新版本，取最高版本比对本地。
+    """版本自检：以 PyPI + GitHub 双判定渠道取最高版本比对本地。
 
-    渠道优先级：PyPI（pip 用户首选）> GitHub > GitCode > AtomGit
-    全部不可达时明确告知并返回退出码 2。
+    判定渠道：PyPI（发布源，pip 用户首选）+ GitHub（代码仓库权威源，CI 触发源）。
+    GitCode/AtomGit 与 GitHub 同步同 tag，不参与版本判定（零增量），
+    仅在 GitHub 不可达时作为国内拉取镜像提示（JSON 输出于 mirrors 字段）。
+    全部判定渠道不可达时明确告知并返回退出码 2。
     支持 --json 输出结构化结果，便于 Agent 解析。
     """
     import json as _json
@@ -71,36 +105,40 @@ def cmd_check_update(args):
     local_ver = __version__
 
     if not use_json:
-        print(f"🔍 版本自检（多渠道，本地 v{local_ver}）")
+        print(f"🔍 版本自检（PyPI + GitHub 判定，本地 v{local_ver}）")
         print(f"{'─' * 50}")
 
     results: dict[str, str] = {}
     ok_count = 0
 
-    # 渠道1：PyPI（无需 git，pip 用户首选）
-    ok, val = _latest_version_from_pypi()
-    if ok:
-        results["PyPI"] = val
-        ok_count += 1
-        if not use_json:
-            print(f"  ✅ PyPI     最新: {val}")
-    else:
-        results["PyPI"] = ""
-        if not use_json:
-            print(f"  ⚠️  PyPI     不可达: {val}")
-
-    # 渠道2-4：Git 仓库
-    for name, url in REPO_MIRRORS.items():
-        ok, val = _latest_tag_from_remote(url)
-        if ok:
-            results[name] = val
-            ok_count += 1
-            if not use_json:
-                print(f"  ✅ {name:<8} 最新: {val}")
-        else:
-            results[name] = ""
-            if not use_json:
-                print(f"  ⚠️  {name:<8} 不可达: {val}")
+    # 判定渠道并发查询：PyPI（发布源）+ GitHub（代码权威源）。
+    # 两渠道并发，总耗时 = 最坏单渠道超时（GitHub 短超时快速降级）。
+    from concurrent.futures import ThreadPoolExecutor
+    channels = [
+        (name, REPO_MIRRORS[name] if name in REPO_MIRRORS else None)
+        for name in _JUDGMENT_CHANNELS
+    ]
+    with ThreadPoolExecutor(max_workers=len(channels)) as pool:
+        futures = [pool.submit(_fetch_channel, name, url, _CHANNEL_TIMEOUTS[name])
+                   for name, url in channels]
+        for fut in futures:
+            name, ok, val = fut.result()
+            if ok:
+                results[name] = val
+                ok_count += 1
+                if not use_json:
+                    print(f"  ✅ {name:<8} 最新: {val}")
+            else:
+                results[name] = ""
+                if not use_json:
+                    print(f"  ⚠️  {name:<8} 不可达: {val}")
+
+    # GitHub 海外渠道不可达时，给出国内加速指引（EasyTier 式加速代理 + GitHub520 hosts）
+    if not use_json and results.get("GitHub", "") == "" and ok_count > 0:
+        print("  💡 国内访问 GitHub 常超时，可用国内代码镜像：")
+        for _name, _url in _GIT_MIRRORS.items():
+            print(f"     - {_name}: {_url}")
+        print("     或参考 GitHub520 hosts 加速方案：https://github.com/521xueweihan/GitHub520")
 
     if not use_json:
         print(f"{'─' * 50}")
@@ -111,18 +149,22 @@ def cmd_check_update(args):
             print("   ⚠️ 版本自检因无法访问远程而跳过，本地版本可能不是最新")
             print("   💡 拉取地址：")
             print("      - PyPI:  pip install --upgrade gongwen-skill")
-            for name, url in REPO_MIRRORS.items():
+            for name in _JUDGMENT_CHANNELS:
+                if name == "PyPI":
+                    continue
+                print(f"      - {name}: {REPO_MIRRORS[name]}")
+            for name, url in _GIT_MIRRORS.items():
                 print(f"      - {name}: {url}")
         return 2
 
-    # 取多渠道中的最高版本
+    # 取判定渠道中的最高版本
     valid = [v for v in results.values() if v]
     latest = max(valid, key=_parse_version)
 
     # 判断安装方式（用于给出对应的更新命令）
     # pip 安装的用户应使用 pip install --upgrade，git clone 的用户应使用 git pull
     pypi_ok = bool(results.get("PyPI"))
-    git_ok = any(results.get(name) for name in REPO_MIRRORS)
+    git_ok = bool(results.get("GitHub"))
 
     has_update = _parse_version(latest) > _parse_version(local_ver)
 
@@ -136,6 +178,7 @@ def cmd_check_update(args):
                 name: {"reachable": bool(v), "version": v.lstrip("v") if v else None}
                 for name, v in results.items()
             },
+            "mirrors": {name: url for name, url in _GIT_MIRRORS.items()},
             "reachable_channels": ok_count,
             "elapsed_seconds": round(time.time() - t0, 1),
         }
@@ -153,7 +196,10 @@ def cmd_check_update(args):
         print(f"⏱️  自检耗时 {time.time() - t0:.1f}s")
         return 1
     elif _parse_version(latest) == _parse_version(local_ver):
-        print(f"✅ 已是最新版本：v{local_ver}（多渠道一致）")
+        if ok_count >= 2:
+            print(f"✅ 已是最新版本：v{local_ver}（PyPI 与 GitHub 一致）")
+        else:
+            print(f"✅ 已是最新版本：v{local_ver}（单渠道确认）")
     else:
         print(f"ℹ️  本地版本 v{local_ver} 高于远程 {latest}（本地领先或渠道不同步）")
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gongwen-skill",
-  "version": "2.4.0",
+  "version": "2.6.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.4.0
+Skill 版本: v2.6.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.4.0"
+version = "2.6.0"
 description = "公文全流程处理工具 - GB/T 9704 格式检查/修复/内容优化/模板生成/版式注入"
 readme = "README.md"
 license = {text = "MIT"}