@huicai/cli 2026.814.0 → 2026.1019.0

package/skills/tech-doc/scripts/archive_check.py

@@ -0,0 +1,1307 @@
+# 研发项目**档案级**体检：把整个项目目录一起看，查单份文档看不见的那一层。
+#
+# 单份文档体检（docx_check）管「这一份写得规不规范」；本模块管四件它管不了的事：
+#   ① 齐不齐 —— 必备文档缺哪份、12 期周期性报告缺哪几期、5 个阶段评审报告与签到表是否配对；
+#   ② 对不对得上 —— 项目名称/编号/负责人/电话/建设单位/起止时间在几十份文档里是否处处一致；
+#   ③ 干不干净 —— 模板的「提示：」块删没删、XX 占位符换没换、有没有粘进别的项目的内容；
+#   ④ 填没填串 —— 「项目联系人」栏里填的是电话、「联系电话」栏里填的是人名这类。
+#
+# 这四类在真实归档里出错最多，也最容易在验收与审计现场被当场挑出来。
+
+import json
+import os
+import re
+import sys
+import warnings
+from collections import Counter, defaultdict
+
+warnings.simplefilter('ignore')
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from openpyxl import load_workbook   # noqa: E402
+
+import archive_spec as S          # noqa: E402
+
+SKIP_NAMES = ('.DS_Store', 'Thumbs.db')
+DOC_EXT = ('.docx', '.doc')
+SHEET_EXT = ('.xlsx', '.xls', '.xlsm')
+
+
+def _issue(level, group, kind, where, msg, detail='', suggest=''):
+    return {'level': level, 'group': group, 'kind': kind, 'where': where,
+            'msg': msg, 'detail': detail, 'suggest': suggest}
+
+
+def _norm(s):
+    return re.sub(r'[\s　]', '', str(s or '')).strip()
+
+
+# ── 读取 ───────────────────────────────────────────────────────────────────
+def read_docx(path):
+    """返回 {text, headings[], fields{}, tables[]}。fields 取自各表格的「键|值」对。"""
+    from docx import Document
+    from docx.oxml.ns import qn                       # noqa: F401  (保持与 docx_check 同一套解析)
+    d = Document(path)
+    heads, lines, fields, tables = [], [], {}, []
+    # **必须按文档顺序遍历 body**：段落归段落、表格归表格地分开收集，会把「考核指标」这一节
+    # 和紧跟它的指标表拆开，于是「这一节里有没有量化指标」永远判成没有——
+    # 那正是本模块最值钱的一条勾稽检查，顺序一错它就失效了。
+    pm = {x._p: x for x in d.paragraphs}
+    tm = {x._tbl: x for x in d.tables}
+    for ch in d.element.body.iterchildren():
+        tag = ch.tag.split('}')[-1]
+        if tag == 'p' and ch in pm:
+            para = pm[ch]
+            t = para.text.strip()
+            if not t:
+                continue
+            lines.append(t)
+            name = str(para.style.name or '')
+            if name.startswith('Heading'):
+                heads.append((int(name[-1]) if name[-1].isdigit() else 1, t))
+            else:
+                # 有些文档把封面信息栏写成「项目名称：XXX」这样的居中段落而不是表格。
+                # 只认表格就会把这类文档的字段全漏掉——漏掉的后果不是报错，
+                # 是「一致性检查永远说没问题」，比报错更坏。
+                m = re.match(r'^\s*([^：:]{2,12})\s*[：:]\s*(\S.{0,60})$', t)
+                if m:
+                    k = S.field_key(m.group(1))
+                    if k and k not in fields:
+                        fields[k] = m.group(2).strip()
+        elif tag == 'tbl' and ch in tm:
+            rows = []
+            for row in tm[ch].rows:
+                try:
+                    cells = [c.text.strip() for c in row.cells]
+                except Exception:
+                    continue
+                ded = []
+                for c in cells:
+                    if not ded or ded[-1] != c:
+                        ded.append(c)
+                rows.append(ded)
+                lines.extend(x for x in ded if x)
+                for i in range(0, len(ded) - 1, 2):      # 键值对：两格一组，左键右值
+                    k = S.field_key(ded[i])
+                    if k and ded[i + 1].strip() and k not in fields:
+                        fields[k] = ded[i + 1].strip()
+            tables.append(rows)
+    return {'text': '\n'.join(lines), 'headings': heads, 'fields': fields, 'tables': tables,
+            'figures': len(d.inline_shapes)}
+
+
+def read_sheet(path):
+    import pandas as pd
+    try:
+        xf = pd.ExcelFile(path)
+    except Exception as e:
+        return {'text': '', 'headings': [], 'fields': {}, 'tables': [], 'error': str(e)[:80]}
+    lines, fields = [], {}
+    for s in xf.sheet_names[:6]:
+        try:
+            df = xf.parse(s, header=None, dtype=object).head(80)
+        except Exception:
+            continue
+        for _i, row in df.iterrows():
+            vals = ['' if str(v) == 'nan' else str(v).strip() for v in row.tolist()]
+            lines.extend(v for v in vals if v)
+            for i in range(len(vals) - 1):
+                k = S.field_key(vals[i])
+                if k and vals[i + 1] and k not in fields:
+                    fields[k] = vals[i + 1]
+    return {'text': '\n'.join(lines), 'headings': [], 'fields': fields, 'tables': []}
+
+
+def _read_legacy_doc(path):
+    """旧版二进制 .doc（OLE2）：python-docx 读不了，借系统自带的转换器取纯文本。
+
+    真实归档里 12 份月度验收报告都是这个格式。读不到不等于没事——
+    它们照样参与模板残留、项目名一致性、雷同度这些**纯文本**判据；
+    读不到就只能整份跳过，而报告里以前对此一个字都没说。
+
+    表格与标题层次拿不到，所以结构类检查自然不会对它们发言——这是如实的降级，
+    不是猜。转换器一个都没有时，如实标记 unreadable，由 inspect 点名。
+    """
+    import shutil as _sh
+    import subprocess as _sp
+    for argv in (['textutil', '-convert', 'txt', '-stdout', path],   # macOS 自带
+                 ['antiword', path]):                                 # 多数 Linux 发行版
+        if not _sh.which(argv[0]):
+            continue
+        try:
+            r = _sp.run(argv, capture_output=True, timeout=30)
+        except Exception:
+            continue
+        if r.returncode == 0 and r.stdout:
+            txt = r.stdout.decode('utf-8', 'replace').replace('\r\n', '\n')
+            # textutil 会把 Word 域代码当正文吐出来（TOC \o "1-2"、HYPERLINK \l _Toc123、
+            # PAGEREF）。这些是**每份文档都一样**的样板，留着会虚抬雷同度，
+            # 也会混进正文类判据。目录项本身不是内容，一并去掉。
+            txt = re.sub(r'(?m)^.*(?:\\o\s|HYPERLINK|PAGEREF|\bTOC\b).*$', '', txt)
+            lines = [ln.strip() for ln in txt.split('\n')]
+            fields = {}
+            for i, ln in enumerate(lines[:-1]):     # 「键：值」同行或下一行
+                m = re.match(r'^(.{2,10})[：:]\s*(.*)$', ln)
+                if m:
+                    k = S.field_key(m.group(1))
+                    v = m.group(2).strip() or lines[i + 1].strip()
+                    if k and v and k not in fields:
+                        fields[k] = v
+            return {'text': '\n'.join(l for l in lines if l), 'headings': [],
+                    'fields': fields, 'tables': [], 'legacy': True}
+    return {'text': '', 'headings': [], 'fields': {}, 'tables': [],
+            'error': 'legacy-doc', 'unreadable': True}
+
+
+def scan(root, spec=None):
+    """扫描项目目录 → [{rel, path, kind, ext, doc}]。"""
+    spec = spec or S.SPEC
+    out = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if not d.startswith('.')]
+        for f in sorted(filenames):
+            if f in SKIP_NAMES or f.startswith('~$') or f.startswith('.'):
+                continue
+            p = os.path.join(dirpath, f)
+            rel = os.path.relpath(p, root)
+            ext = os.path.splitext(f)[1].lower()
+            rec = {'rel': rel, 'path': p, 'ext': ext, 'kind': S.kind_of(f, spec), 'doc': None}
+            try:
+                if ext == '.docx':
+                    rec['doc'] = read_docx(p)
+                elif ext in SHEET_EXT:
+                    rec['doc'] = read_sheet(p)
+                elif ext == '.doc':
+                    rec['doc'] = _read_legacy_doc(p)
+            except Exception as e:
+                rec['doc'] = {'text': '', 'headings': [], 'fields': {}, 'tables': [],
+                              'error': f'{type(e).__name__}: {str(e)[:70]}'}
+            out.append(rec)
+    return out
+
+
+# ── ① 完整性 ───────────────────────────────────────────────────────────────
+def check_complete(files, spec):
+    out = []
+    kinds = Counter(f['kind'] for f in files if f['kind'])
+    for it in spec['items']:
+        if not it.get('required'):
+            continue
+        if not kinds.get(it['kind']):
+            out.append(_issue('error', 'complete', 'missing-doc', it['kind'],
+                              f"缺必备文档：{it['dir'] + '/' if it['dir'] else ''}{it['file']}",
+                              f"（{it['stage']}阶段）",
+                              '按规范补齐；确实不适用的要在档案清册里注明原因'))
+    for p in spec['periodic']:
+        if not p.get('required', True):
+            continue          # 选做的周期性文档缺席不算缺陷
+        got = []
+        for f in files:
+            m = re.search(p['match'], os.path.splitext(os.path.basename(f['rel']))[0])
+            if m:
+                try:
+                    got.append(int(m.group(1)))
+                except (ValueError, IndexError):
+                    pass
+        got = sorted(set(got))
+        want = list(range(1, p['count'] + 1))
+        miss = [n for n in want if n not in got]
+        if not got:
+            out.append(_issue('error', 'complete', 'missing-periodic', p['kind'],
+                              f"{p['kind']}一期都没有（应有 {p['count']} 期，按{p['freq']}）",
+                              '', '周期性文档的份数是硬指标，研发费用加计扣除与高企核查都会点数'))
+        elif miss:
+            out.append(_issue('error', 'complete', 'missing-periodic', p['kind'],
+                              f"{p['kind']}缺 {len(miss)} 期：第 {miss} 期（已有 {len(got)}/{p['count']}）",
+                              '', '补齐，或在档案清册里写明为何缺'))
+    for r in spec['reviews']:
+        rep = [f for f in files if re.search(r['match'], f['rel']) and f['ext'] in SHEET_EXT]
+        sig = [f for f in files if re.search(r['match'], f['rel']) and '签到' in f['rel']]
+        if not rep and not sig:
+            out.append(_issue('error', 'complete', 'missing-review', f"{r['stage']}评审",
+                              f"缺{r['stage']}阶段评审文件（评审报告 + 会议签到表）", '',
+                              '五个阶段评审是流程闭环的证据，缺一个阶段就无法证明评审真的开过'))
+        elif not rep:
+            out.append(_issue('error', 'complete', 'review-unpaired', f"{r['stage']}评审",
+                              f"{r['stage']}评审有签到表但没有评审报告", '', ''))
+        elif not sig:
+            out.append(_issue('error', 'complete', 'review-unpaired', f"{r['stage']}评审",
+                              f"{r['stage']}评审有报告但没有会议签到表", '',
+                              '签到表是「会真的开过」的唯一物证'))
+    unknown = [f['rel'] for f in files if not f['kind'] and f['ext'] in DOC_EXT + SHEET_EXT]
+    if unknown:
+        out.append(_issue('info', 'complete', 'unclassified', '归档',
+                          f'{len(unknown)} 份文件不在规范目录内：{unknown[:5]}', '',
+                          '不是错，但归档清册里要能说清它们是什么'))
+    legacy = [f['rel'] for f in files if f['ext'] == '.doc']
+    if legacy:
+        out.append(_issue('warn', 'complete', 'legacy-doc', '归档',
+                          f'{len(legacy)} 份仍是旧版 .doc：{legacy[:4]}', '',
+                          '.doc 无法被工具解析核对，长期归档建议统一另存为 .docx'))
+    return out
+
+
+# ── ② 跨文档一致性 ─────────────────────────────────────────────────────────
+def _canonical(values):
+    """一组同字段取值里挑基准写法，返回（基准, 被截断的那些, 前缀族）。
+
+    **基准取最长的，不取最高频的。** 真实归档里被截断的写法反而可能占多数：
+    深度学习项目的封面「项目名称」有 11 份写「…风控系统研」（少一个「发」）、
+    10 份写「…风控系统的研发」、8 份写「…风控系统研发」——按票数选，
+    基准就成了那个断掉的写法，整改指引会把人从对的改成错的。
+
+    这个判定有两个使用者（字段一致性、项目名一致性），必须共用一份：
+    各写各的必然漂移，而漂移的表现是「一边说 A 对、一边说 A 错」这种最难查的矛盾。
+    """
+    if not values:
+        return '', [], []
+    fam = [v for v in values if any(v.startswith(o) or o.startswith(v)
+                                    for o in values if o != v)]
+    if not fam:
+        return values[0], [], []
+    main = max(fam, key=len)
+    return main, [v for v in fam if v != main], fam
+
+
+def check_consistency(files, spec):
+    out = []
+    vals = defaultdict(lambda: defaultdict(list))
+    for f in files:
+        d = f['doc'] or {}
+        for k, v in (d.get('fields') or {}).items():
+            v = _norm(v)
+            if v and v not in ('/', '-', '—', '无'):
+                vals[k][v].append(f['rel'])
+    for k in spec['consistency']:
+        forms = vals.get(k)
+        if not forms or len(forms) < 2:
+            continue
+        ranked = sorted(forms.items(), key=lambda x: -len(x[1]))
+        main, trunc, fam = _canonical([v for v, _w in ranked])
+        detail = '；'.join(f'「{v}」×{len(w)}（如 {w[0]}）' for v, w in ranked[:4])
+        if trunc:
+            # 前缀关系有两种，不能都叫「截断」：
+            #   「…公司」vs「…公司研发二部」是**粒度**不同（都不算错，但全档要统一）；
+            #   「…系统研」vs「…系统研发」才是复制时少选了字。按后缀形态区分，措辞要准，
+            # 否则给出的整改指引会把人带偏。
+            suffix = main[len(min(trunc, key=len)):] if trunc else ''
+            org_like = bool(re.search(r'[部处科组]$|中心$|公司$|事业部$', suffix))
+            if org_like:
+                out.append(_issue('error', 'consistency', 'field-granularity', k,
+                                  f'「{k}」全档写法粒度不一致：{detail}', '',
+                                  f'择一并全档统一（正式文件通常用「{main}」这种最完整的写法）'))
+            else:
+                out.append(_issue('error', 'consistency', 'field-truncated', k,
+                                  f'「{k}」在全档中不一致，其中有被截断的写法：{detail}', '',
+                                  f'以「{main}」为准全档统一——截断是复制时少选了几个字'))
+        else:
+            out.append(_issue('error', 'consistency', 'field-mismatch', k,
+                              f'「{k}」在全档中有 {len(forms)} 种取值：{detail}', '',
+                              '同一项目的这些字段必须处处相同，验收与审计会逐份比对'))
+    # 字段串位：按「字段」聚合报，不按文件——同一个模板复制出去的错会散在几十份文件里，
+    # 逐份报会刷屏，聚合成一条「哪个字段在哪几份文件里填串了」才看得懂。
+    shape_bad = defaultdict(list)
+    for f in files:
+        for k, (pat, why) in S.FIELD_SHAPES.items():
+            v = _norm((f['doc'] or {}).get('fields', {}).get(k, ''))
+            if v and not pat.match(v):
+                shape_bad[(k, why, v)].append(f['rel'])
+    for (k, why, v), where in shape_bad.items():
+        out.append(_issue('error', 'consistency', 'field-shape', k,
+                          f'「{k}」栏填的是「{v}」，{why}（{len(where)} 份文件）',
+                          '例：' + '、'.join(where[:3]),
+                          '相邻两栏填串了，核对封面信息表'))
+    return out
+
+
+# ── ③ 模板残留 ─────────────────────────────────────────────────────────────
+def check_leak(files, spec):
+    out = []
+    for f in files:
+        txt = (f['doc'] or {}).get('text') or ''
+        if not txt:
+            continue
+        for kind, pat, level, msg, why in S.LEAK_PATTERNS:
+            hits = pat.findall(txt)
+            if hits:
+                out.append(_issue(level, 'leak', kind, f['rel'],
+                                  f'{msg}（{len(hits)} 处）', why,
+                                  '交付前全文搜一遍删干净'))
+    # 模板批注残留：模板写给填表人的说明（注：由…填写 / 请选择以下结论 / 下同。）
+    tn = re.compile('|'.join(S.TEMPLATE_NOTES))
+    for f in files:
+        txt = (f['doc'] or {}).get('text') or ''
+        hits = tn.findall(txt)
+        if hits:
+            out.append(_issue('error', 'leak', 'template-note', f['rel'],
+                              f'模板给填表人的批注未删除（{len(hits)} 处）',
+                              '如「注：由项目单位如实填写实际完成情况，下同。」——'
+                              '这是模板的填表说明，不是给读者看的注释',
+                              '交付前全文搜「下同」「请选择」「如实填写」删干净'))
+    # 选择项一个都没勾：这道题根本没做（专家审查结论全空是验收件的硬伤）
+    for f in files:
+        txt = (f['doc'] or {}).get('text') or ''
+        # 方框型：整份文档里一个勾都找不到 = 这些选择题一道都没做。
+        # 判「一个都没勾」而不是「还剩几个没勾」——多选题选完必然剩下未选项。
+        boxes = S.EMPTY_BOX_RE.findall(txt)
+        if len(boxes) >= 2 and not S.FILLED_BOX_RE.search(txt):
+            out.append(_issue('error', 'leak', 'empty-box', f['rel'],
+                              f'{len(boxes)} 个选择框一个都没勾',
+                              '如人员变更申请表的「是否变更 □是 □否」原样交出——'
+                              '这道题根本没做，不是选了「否」',
+                              '逐个勾选（■/☑）后再交付'))
+        empty = S.EMPTY_CHOICE_RE.findall(txt)
+        if len(empty) >= 3 and not S.FILLED_CHOICE_RE.search(txt):
+            out.append(_issue('error', 'leak', 'unchecked-choice', f['rel'],
+                              f'{len(empty)} 处选择项一个都没勾',
+                              '整份文档没有任何一个括号被填——结论没人做、字没人签',
+                              '逐条勾选并签字；专家审查结论是验收件的核心，空着等于没验收'))
+    # 他项目内容残留：文档正文里出现了别的项目名
+    names = Counter()
+    for f in files:
+        n = _norm((f['doc'] or {}).get('fields', {}).get('项目名称', ''))
+        if n:
+            names[n] += 1
+    if names:
+        main = names.most_common(1)[0][0]
+        for f in files:
+            txt = _norm((f['doc'] or {}).get('text') or '')
+            for other, _c in names.most_common():
+                if other != main and len(other) > 8 and other in txt and main not in txt:
+                    out.append(_issue('warn', 'leak', 'other-project', f['rel'],
+                                      f'正文里出现了另一个项目名「{other}」而没有本项目名', '',
+                                      '多半是从别的项目复制来的，逐处替换'))
+                    break
+    return out
+
+
+# ── ④ 单份结构（章节 / 表单字段 / 签批栏）───────────────────────────────────
+DATE_RE = re.compile(r'(20\d{2})\s*[年\-/.]\s*(\d{1,2})\s*[月\-/.]\s*(\d{1,2})?\s*日?')
+
+
+def _cover_date(doc):
+    """取封面落款日期。
+
+    **优先取「编制时间/编制日期」字段**，取不到才扫正文前 800 字。
+    直接扫正文会先撞上标题里的期间标签（「研发进度报告（2026年07月）」），
+    那个月份天然等于期号，拿它去校验期号等于自己跟自己比，检查形同虚设。
+    """
+    fv = (doc.get('fields') or {}).get('编制时间')
+    if fv:
+        m = DATE_RE.search(str(fv))
+        if m:
+            y, mo, d = int(m.group(1)), int(m.group(2)), int(m.group(3) or 1)
+            if 1 <= mo <= 12 and 1 <= d <= 31:
+                return (y, mo, d)
+    m = DATE_RE.search((doc.get('text') or '')[:800])
+    if not m:
+        return None
+    y, mo, d = int(m.group(1)), int(m.group(2)), int(m.group(3) or 1)
+    if not (1 <= mo <= 12 and 1 <= d <= 31):
+        return None
+    return (y, mo, d)
+
+
+def check_timeline(files, spec):
+    """时间线自洽：期号与落款月份对不对得上、五个阶段评审是不是按顺序开的。
+
+    这两条都是硬规则，不需要人判断：第 7 期月报的落款不可能是 8 月，
+    结项评审不可能开在验收评审之前。真实归档里这类错不多，但一旦有，
+    核查时是「材料是补的」的直接证据——比任何文字问题都难解释。
+    """
+    out = []
+    # ① 周期性文档：文件名里的期号 vs 落款月份
+    for p in spec['periodic']:
+        if p.get('freq') != '月':
+            continue
+        bad = []
+        for f in files:
+            if f['kind'] != p['kind'] or f['ext'] != '.docx':
+                continue
+            m = re.search(p['match'], os.path.splitext(os.path.basename(f['rel']))[0])
+            dt = _cover_date(f['doc'] or {})
+            if not m or not dt:
+                continue
+            try:
+                n = int(m.group(1))
+            except (ValueError, IndexError):
+                continue
+            if 1 <= n <= 12 and dt[1] != n:
+                bad.append((f['rel'], n, dt))
+        if bad:
+            out.append(_issue('error', 'timeline', 'period-date-mismatch', p['kind'],
+                              f'{len(bad)} 期{p["kind"]}的落款月份与期号对不上',
+                              '；'.join(f'{os.path.basename(r)} 落款 {d[0]}-{d[1]:02d}（应为 {n} 月）'
+                                        for r, n, d in bad[:3]),
+                              '期号与落款月份必须一致，否则是「材料后补」的直接证据'))
+    # ② 五个阶段评审必须按顺序
+    order, dates = [r['stage'] for r in spec['reviews']], {}
+    for f in files:
+        for r in spec['reviews']:
+            if re.search(r['match'], f['rel']) and f['ext'] == '.docx':
+                dt = _cover_date(f['doc'] or {})
+                if dt and r['stage'] not in dates:
+                    dates[r['stage']] = (dt, f['rel'])
+    seq = [(st, dates[st]) for st in order if st in dates]
+    for (s1, (d1, f1)), (s2, (d2, f2)) in zip(seq, seq[1:]):
+        if d2 < d1:
+            out.append(_issue('error', 'timeline', 'review-out-of-order', f'{s1}→{s2}评审',
+                              f'{s2}评审（{d2[0]}-{d2[1]:02d}-{d2[2]:02d}）早于'
+                              f'{s1}评审（{d1[0]}-{d1[1]:02d}-{d1[2]:02d}）',
+                              f'{os.path.basename(f2)} / {os.path.basename(f1)}',
+                              '评审阶段有先后：立项→设计→测试用例→验收→结项，顺序倒了说明流程没真走'))
+    return out
+
+
+def check_unfinished(files, spec):
+    """验收件里承认「进行中 / 预计完成」——指标没完成却在做验收。
+
+    这不是文字游戏：验收结论要么达标要么不达标，「进行中」既不是达标也不是不达标，
+    等于把判断推给了后面的人。真实归档里两个项目都在「实际完成情况」栏写了
+    「进行中，指标为预计完成指标」，而专家审查结论一个都没勾。
+    """
+    out = []
+    for f in files:
+        if f['kind'] not in S.ACCEPT_KINDS:
+            continue
+        hits = []
+        for rows in ((f['doc'] or {}).get('tables') or []):
+            if not rows:
+                continue
+            # 先按**表头**认出这是不是「立项书规定 vs 实际完成情况」的对照表，
+            # 再看数据行的右栏。左栏是立项书原文，里面出现「预计」是正常的。
+            head = _norm(' '.join(str(c) for c in rows[0]))
+            if '实际完成' not in head and '规定' not in head:
+                continue
+            for row in rows[1:]:
+                if len(row) < 2:
+                    continue
+                for cell in row[1:]:
+                    t = str(cell)
+                    if '实际完成情况' in t:
+                        continue
+                    for w in S.UNFINISHED_WORDS:
+                        if w in t:
+                            hits.append((w, t.replace('\n', '')[:26]))
+                            break
+        if hits:
+            out.append(_issue('error', 'unfinished', 'accepting-unfinished', f['rel'],
+                              f'{len(hits)} 项指标的「实际完成情况」写着未完成措辞，却在做验收',
+                              '；'.join(f'「{c}」' for _w, c in hits[:3]),
+                              '验收结论只有达标/不达标两档：没完成就如实写不达标并说明整改，'
+                              '不能用「进行中」把判断推给后面的人'))
+    return out
+
+
+def check_figures(files, spec):
+    """该有图的文档一张图都没有。技术路线、系统架构、流程这些东西，
+    用文字硬描是读者的负担，也是评审最常见的追问点。"""
+    out = []
+    for f in files:
+        if f['ext'] != '.docx' or f['kind'] not in S.FIGURE_EXPECTED:
+            continue
+        n = (f['doc'] or {}).get('figures')
+        if n is None:
+            continue
+        # 门槛在**空骨架与写实文档之间的空隙**里，量出来的：
+        # 刚生成的骨架 260~551 字，写实的最短 1464 字（BigDataRisk 的技术总结报告），
+        # 真实归档 5243 字起。原来定 1500 落进了写实区，那份 1464 字的差 36 字擦边漏过——
+        # 门槛的作用是「别对空骨架挑刺」，不是「短就不算文档」。
+        if n == 0 and len((f['doc'] or {}).get('text') or '') > 800:
+            out.append(_issue('warn', 'structure', 'no-figure', f['rel'],
+                              f'{f["kind"]}全文没有一张图',
+                              '技术路线、系统架构、关键流程用文字硬描，评审必追问',
+                              '用 render_diagram 画出来再插进去'))
+    return out
+
+
+def check_structure(files, spec):
+    out = []
+    for f in files:
+        kind, d = f['kind'], f['doc'] or {}
+        if not kind or d.get('error'):
+            continue
+        secs = spec['sections'].get(kind)
+        text = d.get('text') or ''
+        if secs:
+            hd = d.get('headings') or []
+            heads = ' '.join(t for _lv, t in hd)
+            # **有标题树就只认标题树**：正文里出现「项目考核指标」可能只是某张表的题注，
+            # 拿题注当「这一节写了」，真的缺节反而判成不缺。标题不足三条的（表单式文档）
+            # 才退回全文匹配。
+            hay = heads if len(hd) >= 3 else (heads + ' ' + text[:20000])
+            miss_must, miss_should = [], []
+            for title, _subs, level, aliases in secs:
+                if any(_loose_in(a, hay) for a in [title] + list(aliases)):
+                    continue
+                (miss_must if level == 'must' else miss_should).append(title)
+            if miss_must:
+                out.append(_issue('error', 'structure', 'missing-section', f['rel'],
+                                  f'缺必备章节：{"、".join(miss_must)}', f'（{kind}）',
+                                  '评审是按章节核对的，缺一节就是缺一项'))
+            if miss_should:
+                out.append(_issue('warn', 'structure', 'missing-optional-section', f['rel'],
+                                  f'模板有但本篇没写：{"、".join(miss_should)}', f'（{kind}）',
+                                  '真实归档里这几节常被省略；要不要补由项目决定，别默认忽略'))
+        fields = spec['form_fields'].get(kind)
+        if fields:
+            hay = text
+            miss = [x for x in fields if not _loose_in(x, hay)]
+            if miss:
+                out.append(_issue('error', 'structure', 'missing-field', f['rel'],
+                                  f'表单缺 {len(miss)} 个字段：{miss[:6]}', f'（{kind}）',
+                                  '表单类文档的失分点几乎全在字段缺项'))
+        ap = spec['approvals'].get(kind)
+        if ap:
+            miss = [x for x in ap if not _loose_in(x, text)]
+            if miss:
+                out.append(_issue('error', 'structure', 'missing-approval', f['rel'],
+                                  f'缺签批栏：{"、".join(miss)}', f'（{kind}）',
+                                  '少一级签批 = 流程没走完，交上去会被退'))
+            else:
+                blank = [x for x in ap if _approval_blank(text, x)]
+                if blank:
+                    out.append(_issue('warn', 'structure', 'blank-approval', f['rel'],
+                                      f'签批栏是空的：{"、".join(blank)}', '',
+                                      '归档前要签字盖章，空栏等于没审批'))
+    return out
+
+
+def _loose_in(needle, hay):
+    """去掉空白与全角括号差异后判断是否包含（模板里字段名常带空格：「项 目 名 称」）。"""
+    return _norm(needle).replace('（', '(').replace('）', ')') in \
+        _norm(hay).replace('（', '(').replace('）', ')')
+
+
+def _approval_blank(text, label):
+    """签批栏后面 30 字内还有没有实质内容（人名/意见/日期）。"""
+    i = _norm(text).find(_norm(label))
+    if i < 0:
+        return False
+    tail = _norm(text)[i + len(_norm(label)): i + len(_norm(label)) + 30]
+    tail = tail.lstrip('：:')
+    return not re.search(r'[一-鿿\d]', tail.replace('年月日', ''))
+
+
+# ── 周期性文档雷同度 ───────────────────────────────────────────────────────
+# 为什么要有这条：12 期月报交齐了、份数也对，档案体检一切正常——但把 12 份摊开一读，
+# 正文相似度 98%，等于同一份文档改个日期交了十二次。「逐月记录研发过程」这件事
+# 实际上没有发生。研发费用加计扣除与高企认定的核查员一眼就能看出来，而份数检查看不出来。
+#
+# 阈值是**量出来的**，不是拍的（4-gram Jaccard，相邻两期）：
+#   真实那两个项目的 12 期月报 → 中位 0.984 / 0.986（其中一对恰好 1.000，两期完全相同）
+#   三份不同类型的正式文档     → 0.19
+#   刚生成的空骨架             → 0.73（且正文均长 230 字，低于判定门槛，本就不判）
+SHINGLE_K = 4
+SAME_BODY_MIN = 300        # 正文均长不到这个数就是还没填的骨架，不判
+SAME_ERR = 0.90
+SAME_WARN = 0.75
+FIELD_LINE_RE = re.compile(r'^[^：:]{2,12}[：:]\S{0,40}$')
+# 独立成行的日期是落款，不是散文。各期落款天然不同（1 月末、2 月末…），
+# 把它算进「实质正文」会让两份逐字相同的报告显得不同，冲淡真正要量的东西。
+DATE_LINE_RE = re.compile(r'^\s*20\d{2}\s*[年\-/.]\s*\d{1,2}\s*[月\-/.]?\s*\d{0,2}\s*日?\s*$')
+
+
+def _body_lines(doc):
+    """取「实质正文」：去掉标题、封面键值行与过短的碎行——它们本就该在各期之间相同。"""
+    heads = {t for _lv, t in (doc.get('headings') or [])}
+    out = []
+    for line in (doc.get('text') or '').split('\n'):
+        t = line.strip()
+        if not t or t in heads or len(t) < 15:
+            continue
+        if FIELD_LINE_RE.match(t) or DATE_LINE_RE.match(t):
+            continue
+        out.append(t)
+    return ''.join(out)
+
+
+def _shingles(text, k=SHINGLE_K):
+    t = re.sub(r'[\s　]', '', text)
+    return {t[i:i + k] for i in range(max(len(t) - k + 1, 0))}
+
+
+def _jaccard(a, b):
+    return len(a & b) / len(a | b) if a and b else 0.0
+
+
+def check_sameness(files, spec):
+    out = []
+    by_kind = defaultdict(list)
+    kinds = {p['kind'] for p in spec['periodic']}
+    for f in files:
+        # **只查叙述型文档（.docx），不查表格件**。这是量过之后的取舍，不是偷懒：
+        # 真实项目的 4 个季度「实际进度表」相似度同样高达 96–98%，但字符数逐季递增
+        # （3912 → 4116 → 4473 → 4775）——那是累计型表格逐季补录实际数据的正常形态。
+        # 把它一并判成雷同，就是对正确做法喊狼来了。
+        if f['kind'] in kinds and f['ext'] in ('.docx', '.doc') and (f['doc'] or {}).get('text'):
+            # **按扩展名分组比**：旧版 .doc 走的是纯文本转换，取不到表格内容，
+            # 文本厚度天然比 .docx 薄。混在一起比等于拿两把尺量同一件事，
+            # 阈值是在 .docx 上量出来的，套到 .doc 上会误报。
+            by_kind[(f['kind'], f['ext'])].append(f)
+    for (kind, _ext), fs in by_kind.items():
+        if len(fs) < 3:
+            continue
+        fs = sorted(fs, key=lambda x: x['rel'])
+        bodies = [_body_lines(f['doc']) for f in fs]
+        avg = sum(len(b) for b in bodies) / len(bodies)
+        if avg < SAME_BODY_MIN:
+            continue                      # 还是空骨架，等着人填
+        shs = [_shingles(b) for b in bodies]
+        pairs = [(_jaccard(shs[i], shs[i + 1]), fs[i]['rel'], fs[i + 1]['rel'])
+                 for i in range(len(shs) - 1)]
+        sims = sorted(x[0] for x in pairs)
+        med = sims[len(sims) // 2]
+        same = [(a, b) for v, a, b in pairs if v > 0.995]
+        if med >= SAME_ERR:
+            detail = f'相邻两期相似度中位 {med*100:.1f}%，正文均长 {avg:.0f} 字'
+            if same:
+                detail += f'；其中 {len(same)} 对几乎逐字相同（如 {os.path.basename(same[0][0])} 与 '\
+                          f'{os.path.basename(same[0][1])}）'
+            out.append(_issue('error', 'sameness', 'periodic-duplicate', kind,
+                              f'{len(fs)} 期{kind}正文高度雷同，等于同一份改日期交了 {len(fs)} 次',
+                              detail,
+                              '周期性文档的价值在「逐期记录了什么」而不是份数；'
+                              '每期至少写清本期实际完成、与计划的偏差、下期安排——'
+                              '核查员会摊开来对着读'))
+        elif med >= SAME_WARN:
+            out.append(_issue('warn', 'sameness', 'periodic-similar', kind,
+                              f'{len(fs)} 期{kind}正文相似度偏高（中位 {med*100:.1f}%）',
+                              f'正文均长 {avg:.0f} 字',
+                              '固定结构可以复用，但每期的实际进展、偏差与问题应当各不相同'))
+    return out
+
+
+# ── ⑤ 指标勾稽（立项 → 验收）───────────────────────────────────────────────
+# 只认**看得出是目标值**的写法：带比较词的（≥92%、≤300ms、不低于 5 万元），
+# 或裸百分比（准确率 92%）。不带比较词的「5000 条」「1 项」多半出现在测试方法或序号里，
+# 把它们当考核指标会让勾稽结论全是噪声——宁可少认，也不能认错。
+NUM_IND = re.compile(
+    r'(?:≥|≤|>|<|⩾|⩽|不低于|不少于|不超过|不高于|达到|大于|小于)\s*\d+(?:\.\d+)?\s*'
+    r'(?:%|％|万元|亿元|元|人月|个|项|次|ms|毫秒|秒|分钟|小时|天|TPS|QPS|条|倍|分)?'
+    r'|\d+(?:\.\d+)?\s*[%％]')
+
+
+def check_indicators(files, spec):
+    out = []
+    src = next((f for f in files if f['kind'] == '立项申请书'), None)
+    if not src or not (src['doc'] or {}).get('text'):
+        return out
+    sect = _section_text(src['doc'], '项目考核指标')
+    if not sect:
+        return out
+    inds = []
+    for m in NUM_IND.finditer(sect):
+        t = _norm(m.group(0))
+        if t not in inds:
+            inds.append(t)
+    if not inds:
+        out.append(_issue('warn', 'indicator', 'no-quantified', '立项申请书',
+                          '「项目考核指标」一节里没有可量化的指标值', '',
+                          '指标写不出数就没法验收：每条给指标值 + 测试方法 + 判定依据'))
+        return out
+    targets = [f for f in files if f['kind'] in ('项目验收报告', '工作总结报告', '技术总结报告')]
+    if not targets:
+        return out
+    hay = _norm(' '.join((f['doc'] or {}).get('text') or '' for f in targets))
+    missing = [x for x in inds if x not in hay]
+    if missing:
+        out.append(_issue('warn', 'indicator', 'unverified', '立项申请书 → 验收/总结',
+                          f'{len(missing)}/{len(inds)} 条立项考核指标在验收与总结文档里找不到对应实测值：'
+                          f'{missing[:6]}', '',
+                          '验收报告要逐条对照立项书指标给出实测值与判定，一条都不能少'))
+    else:
+        out.append(_issue('info', 'indicator', 'traced', '立项申请书 → 验收/总结',
+                          f'{len(inds)} 条立项考核指标在验收与总结文档中均能找到对应表述', '', ''))
+    return out
+
+
+def _section_text(doc, title, limit=200000):
+    """取某一节的正文：从标题行的下一行起，到**下一个标题行**为止。
+
+    边界必须按「整行等于某个标题」判，不能按「标题文字在正文里出现的位置」判——
+    正文经常引用别的节名（真实语料：「基于2.1的**项目立项背景**，项目依据…」），
+    按子串截断会把整节裁成 6 个字，字数、要素这些按节长度的判据就全部静默漏报。
+    """
+    heads = {t for _lv, t in (doc.get('headings') or [])}
+    lines = (doc.get('text') or '').split('\n')
+    start = next((i for i, ln in enumerate(lines) if ln.strip() == title), None)
+    if start is None:                      # 标题不独占一行（表格型文档）时退回子串定位
+        start = next((i for i, ln in enumerate(lines) if title in ln), None)
+        if start is None:
+            return ''
+    body = []
+    for ln in lines[start + 1:]:
+        if ln.strip() in heads:
+            break
+        body.append(ln)
+    return '\n'.join(body)[:limit]
+
+
+# ── 表格类归档件的内容自洽 ─────────────────────────────────────────────────
+SCHED_COLS = ('任务名称', '计划开始', '计划结束', '实际开始', '实际结束', '进度')
+
+
+def _read_sheet_df(path, must_have='任务名称', scan=6):
+    """读带标题行的业务表：第一行常是大标题，真正的表头在第 2~3 行。
+    按「哪一行含关键列名」定位表头，而不是硬编码 header=1——真实表格的标题行数并不统一。"""
+    import pandas as pd
+    try:
+        raw = pd.read_excel(path, header=None, dtype=object)
+    except Exception:
+        return None
+    for i in range(min(scan, len(raw))):
+        if any(str(v).strip() == must_have for v in raw.iloc[i].tolist()):
+            try:
+                return pd.read_excel(path, header=i)
+            except Exception:
+                return None
+    return None
+
+
+def check_schedule(files, spec):
+    """进度表的逻辑自洽。
+
+    真实归档里抓到过：3 条任务标着「进度 100%」，实际工时 0、实际开始与结束全空——
+    也就是「说完成了，但没有任何完成的痕迹」。这类矛盾在表里安安静静躺着，
+    份数检查、章节检查都碰不到它，只有按这张表自己的语义去核对才看得见。
+    """
+    import pandas as pd
+    out = []
+    # **必须先把计划表找出来再比对**：按文件名排序会把「…实际-第1季度」排在「…计划」前面
+    # （Unicode 里「实」<「计」），一趟扫下来比对时计划表还没读到，整条检查静默失效。
+    sheets = [f for f in files
+              if f['ext'] in SHEET_EXT and str(f['kind'] or '').startswith('项目研发进度表')]
+    plan_tasks = None
+    for f in sheets:
+        if str(f['kind']).endswith('计划'):
+            df0 = _read_sheet_df(f['path'])
+            if df0 is not None and '任务名称' in df0.columns:
+                plan_tasks = [str(x) for x in df0['任务名称'].dropna().tolist()]
+            break
+    for f in sorted(sheets, key=lambda x: x['rel']):
+        df = _read_sheet_df(f['path'])
+        if df is None or '任务名称' not in df.columns:
+            continue
+        tasks = [str(x) for x in df['任务名称'].dropna().tolist()]
+        if str(f['kind']).endswith('计划'):
+            pass
+        elif plan_tasks is not None and tasks and tasks != plan_tasks:
+            out.append(_issue('warn', 'schedule', 'task-list-drift', f['rel'],
+                              f'实际表的任务列表与计划表对不上（计划 {len(plan_tasks)} 条 / '
+                              f'实际 {len(tasks)} 条）', '',
+                              '实际表应在计划表基础上填实际值，不该增删任务；'
+                              '确有增删要走变更流程并留变更单'))
+        def col(name):
+            return df[name] if name in df.columns else None
+        prog, ae, as_, ah = col('进度'), col('实际结束'), col('实际开始'), col('实际工时')
+        pe, ps = col('计划结束'), col('计划开始')
+        # 进度是 0~1 的比例（真实语料里有 0.03/0.38/0.75 这样的值）。
+        # 2.0 这种越界值不是「超额完成」，是填错了——量纲搞混或多敲了一位。
+        if prog is not None:
+            oor = [v for v in prog.dropna().tolist()
+                   if isinstance(v, (int, float)) and (v > 1.0001 or v < 0)]
+            if oor:
+                out.append(_issue('error', 'schedule', 'progress-out-of-range', f['rel'],
+                                  f'{len(oor)} 处进度值越界：{sorted(set(oor))[:4]}',
+                                  '该列是 0~1 的完成比例', '按比例填（0.75 表示 75%），不要填 2'))
+        if f['kind'].endswith('计划') and prog is not None:
+            nz = [v for v in prog.dropna().tolist()
+                  if isinstance(v, (int, float)) and v > 0]
+            if nz:
+                out.append(_issue('warn', 'schedule', 'plan-has-progress', f['rel'],
+                                  f'计划表里填了 {len(nz)} 处进度值', '',
+                                  '计划表只写计划，进度填在实际表里；两张表混着填会让'
+                                  '「计划 vs 实际」的对比失去意义'))
+        done = prog.apply(lambda v: isinstance(v, (int, float)) and v >= 1) if prog is not None else None
+        if done is not None and ae is not None:
+            n = int((done & ae.isna()).sum())
+            if n:
+                rows = df.index[(done & ae.isna())].tolist()[:5]
+                out.append(_issue('error', 'schedule', 'done-without-date', f['rel'],
+                                  f'{n} 条任务标记完成，却没有实际结束日期',
+                                  '表内第 ' + '、'.join(str(int(r) + 2) for r in rows) + ' 行',
+                                  '说完成了就得有完成的痕迹：补实际起止与实际工时，'
+                                  '或把进度改回真实值'))
+        if done is not None and ah is not None:
+            n = int((done & ah.apply(lambda v: isinstance(v, (int, float)) and v == 0)).sum())
+            if n:
+                out.append(_issue('warn', 'schedule', 'done-zero-hours', f['rel'],
+                                  f'{n} 条任务标记完成但实际工时为 0', '',
+                                  '工时是研发费用归集的依据，0 工时的完成项在加计扣除核查时要解释'))
+        for a, b, kind, msg in ((as_, ae, 'actual-reversed', '实际'),
+                                (ps, pe, 'plan-reversed', '计划')):
+            if a is None or b is None:
+                continue
+            try:
+                bad = (a.notna() & b.notna() & (pd.to_datetime(b, errors='coerce')
+                                                < pd.to_datetime(a, errors='coerce')))
+                n = int(bad.sum())
+            except Exception:
+                continue
+            if n:
+                out.append(_issue('error', 'schedule', kind, f['rel'],
+                                  f'{n} 条任务的{msg}结束早于{msg}开始', '', '核对日期填反了没有'))
+    return out
+
+
+def _open_wb(path):
+    """打开工作簿；.xls 老格式 openpyxl 读不了，退回 pandas 造一个等价的只读视图。"""
+    if str(path).lower().endswith(('.xlsx', '.xlsm')):
+        try:
+            return load_workbook(path, data_only=True)
+        except Exception:
+            return None
+    try:
+        import pandas as pd
+        xf = pd.ExcelFile(path)
+    except Exception:
+        return None
+
+    class _Cell:
+        __slots__ = ('value',)
+        def __init__(self, v): self.value = v
+
+    class _WS:
+        def __init__(self, title, df):
+            self.title, self._df = title, df
+        def iter_rows(self, min_row=1):
+            for row in self._df.values.tolist()[min_row - 1:]:
+                yield [_Cell(None if (isinstance(v, float) and v != v) else v) for v in row]
+
+    class _WB:
+        def __init__(self, xf):
+            self.worksheets = []
+            self.sheetnames = list(xf.sheet_names)
+            for s2 in self.sheetnames:
+                try:
+                    self.worksheets.append(_WS(s2, xf.parse(s2, header=None, dtype=object)))
+                except Exception:
+                    pass
+        def __getitem__(self, name):
+            return next(w for w in self.worksheets if w.title == name)
+
+    return _WB(xf)
+
+
+def check_sheet_content(files, spec):
+    """评审报告与预算表：填没填。
+
+    判断要**直接读工作簿**，不能在扁平化文本上做——标题里的年份「2026」会被当成金额，
+    表头字样会被当成记录内容，两头都会给出「看着有内容其实是空的」的错误结论。
+    """
+    out = []
+    for f in files:
+        if f['ext'] not in SHEET_EXT:
+            continue
+        kind = str(f['kind'] or '')
+        if not (kind.endswith('评审报告') or '预算' in kind):
+            continue
+        # 只跳过「打不开」，不吞掉别的异常。
+        # 早先这里是裸 except：漏了 load_workbook 的 import，NameError 被一并咽掉，
+        # 整条检查从未执行过却一声不响——比报错坏得多。
+        wb = _open_wb(f['path'])
+        if wb is None:
+            continue
+        if kind.endswith('评审报告'):
+            for name in ('评审记录', '评审结论'):
+                ws = next((wb[t] for t in wb.sheetnames if name in t), None)
+                if ws is None:
+                    continue
+                filled = 0
+                for row in ws.iter_rows(min_row=1):
+                    for c in row:
+                        v = c.value
+                        if v is None or str(v).strip() == '':
+                            continue
+                        t = str(v).strip()
+                        if t in ('ID', '问题描述', '提出人', '解决建议', '解决方式', '严重程度',
+                                 '预计解决时间', '修改人', '跟踪人', '跟踪意见、签字',
+                                 '评审内容', '评审结论', '评审记录', name):
+                            continue
+                        if re.fullmatch(r'\d{1,3}', t):      # 序号不算内容
+                            continue
+                        filled += 1
+                if filled < 2:
+                    out.append(_issue('warn', 'schedule', 'empty-review-sheet', f['rel'],
+                                      f'{kind}的「{name}」几乎是空的',
+                                      f'除表头与序号外只有 {filled} 格有内容',
+                                      '会开过就该留下记录：问题、责任人、解决时间；'
+                                      '一条都没有，等于无法证明评审真的发生过'))
+        else:
+            nz = 0
+            for ws in wb.worksheets:
+                for row in ws.iter_rows():
+                    for c in row:
+                        if isinstance(c.value, (int, float)) and not isinstance(c.value, bool) \
+                                and c.value != 0:
+                            nz += 1
+            if nz == 0:
+                # 建议档而非必修：与「签批栏是空的」「评审记录是空的」同属**待填状态**。
+                # 刚生成的骨架、或档案卡没给预算科目时，表就是零——那是等着人填，不是错。
+                # 三处用两套标准会让「生成即零必修」这条不变量时灵时不灵。
+                out.append(_issue('warn', 'schedule', 'empty-budget', f['rel'],
+                                  '预算表里没有任何非零金额', '',
+                                  '预算表全零等于没有编制预算：把科目金额填进档案卡的「预算科目」再生成，'
+                                  '或直接在表里补数'))
+    return out
+
+
+# ── 汇总与报告 ─────────────────────────────────────────────────────────────
+LEVEL = {'error': '必修', 'warn': '建议', 'info': '提示'}
+GROUP = {'complete': '齐全性', 'consistency': '一致性', 'leak': '模板残留',
+         'structure': '结构', 'indicator': '指标勾稽', 'sameness': '雷同度',
+         'unfinished': '验收结论', 'timeline': '时间线', 'schedule': '表格内容'}
+ORDER = {'error': 0, 'warn': 1, 'info': 2}
+
+
+# ── 项目名称的全档一致性 ───────────────────────────────────────────────────
+def _typo_like(a, b, maxd=2):
+    """只差一两个字 = 错字，不是另一个项目。
+    真实归档里「数字权益**开发**系统」被写了 25 处，正名是「开放系统」——
+    差一个字，肉眼扫过去根本发现不了，全文替换却能一次改干净。
+
+    用编辑距离而不是逐位比对：**掉一个字、多一个字同样是错字**，
+    逐位比对遇到长度不等直接判否，这类错字就会被归到「另一个项目」里去，
+    整改指引也跟着说错（该说「改错字」却说「拿错文件了」）。"""
+    if a == b or abs(len(a) - len(b)) > maxd or min(len(a), len(b)) < 6:
+        return False
+    prev = list(range(len(b) + 1))
+    for i, x in enumerate(a, 1):
+        cur = [i]
+        for j, y in enumerate(b, 1):
+            cur.append(min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (x != y)))
+        if min(cur) > maxd:               # 整行都超了，后面只会更大
+            return False
+        prev = cur
+    return prev[-1] <= maxd
+
+
+def _official_name(files, spec):
+    """本项目的正式名：封面「项目名称」栏里最高频的取值。
+    用封面字段而不是正文最高频串——正文里错字可能反超（12 期进度报告复制同一个错标题）。"""
+    votes = Counter()
+    for f in files:
+        v = _norm((f['doc'] or {}).get('fields', {}).get('项目名称', ''))
+        if v and len(v) >= 6:
+            votes[v] += 1
+    if votes:
+        ranked = [v for v, _n in votes.most_common()]
+        # 同样不能取最高频：封面被截断的写法可能占多数（见 _canonical）
+        return _canonical(ranked)[0]
+    body = Counter()
+    for f in files:
+        for m in S.PROJECT_NAME_RE.findall((f['doc'] or {}).get('text') or ''):
+            body[m] += 1
+    return body.most_common(1)[0][0] if body else ''
+
+
+def check_project_name(files, spec):
+    """项目名在全档里是不是同一个名字。
+
+    三种写法要分开对待，混为一谈就没法用：
+      · **简称**（「…系统研发」「…系统」）——真实归档混用 144 次，完全正常，一律放过；
+      · **错字**（开放→开发）——等长差一两字，全档 25 处，必修；
+      · **他项目**（「基于信用模型算法的供应商管理系统」出现在本项目的签到表里）——
+        拿上一个项目的文件改的，标题忘了改。表单类文件里出现他项目名是必修，
+        正文叙述里出现只报提示：项目建议书里对比友商、总结报告里写软著名称都是正当的。
+    """
+    out = []
+    official = _official_name(files, spec)
+    if not official:
+        return out
+    key = S.name_key(official)
+    typo = defaultdict(list)
+    alien = defaultdict(list)
+    for f in files:
+        txt = (f['doc'] or {}).get('text') or ''
+        if not txt:
+            continue
+        for name in set(S.PROJECT_NAME_RE.findall(txt)):
+            k = S.name_key(name)
+            # 前缀关系也算简称：正式名常带正则吃不下的尾巴（「（二期）」「V2.0」、
+            # 批次序号），只认全等的话，官方名本身的每一次提及都会被判成「另一个项目」。
+            if k == key or k.startswith(key) or key.startswith(k):
+                continue                       # 简称，正常
+            if _typo_like(k, key):
+                typo[name].append(f['rel'])
+            else:
+                alien[name].append(f['rel'])
+    for name, where in sorted(typo.items(), key=lambda x: -len(x[1])):
+        diff = '、'.join(f'{y}→{x}' for x, y in zip(S.name_key(name), key) if x != y)
+        out.append(_issue('error', 'naming', 'name-typo', where[0],
+                          f'项目名写成了「{name}」（{len(where)} 份文件），与正式名差 {diff}',
+                          '例：' + '、'.join(where[:3]),
+                          f'全文替换成「{official}」——差一个字，肉眼审读发现不了'))
+    for name, where in sorted(alien.items(), key=lambda x: -len(x[1])):
+        forms = [w for w in where if any(t in w for t in S.FORM_KINDS)]
+        if forms:
+            out.append(_issue('error', 'naming', 'name-alien', forms[0],
+                              f'表单里写的是另一个项目「{name}」',
+                              '涉及：' + '、'.join(forms[:3]) +
+                              '——签到表/评审报告/申请书的抬头只该出现本项目名',
+                              f'拿上一个项目的文件改的，标题没改：应为「{official}」'))
+        rest = [w for w in where if w not in forms]
+        if rest:
+            out.append(_issue('info', 'naming', 'name-other', rest[0],
+                              f'正文提到了另一个项目「{name}」（{len(rest)} 份）',
+                              '例：' + '、'.join(rest[:3]) +
+                              '——可能正当（引用软著名称、对比同类项目），也可能是复制粘贴没改干净',
+                              '逐处确认是有意引用还是改漏了'))
+    return out
+
+
+# ── 模板写死的字数上限 ─────────────────────────────────────────────────────
+def check_wordlimit(files, spec):
+    """模板写着「（500字内）」，交付件写了 4000 字。
+
+    这不是文风问题：高企认定与研发费用加计扣除的审查人按模板逐条核，
+    篇幅要求写在模板正文里就是填表要求。留 1.5 倍宽限——
+    模板也写「500字左右」，卡死 500 会把 520 字报出来，那是噪声。
+    """
+    out = []
+    for f in files:
+        kind = str(f['kind'] or '')
+        doc = f['doc'] or {}
+        if not doc.get('text'):
+            continue
+        for want_kind, title, limit, note in S.WORD_LIMITS:
+            if want_kind not in kind and want_kind not in f['rel']:
+                continue
+            body = _section_text(doc, title, limit=200000)
+            # _section_text 从标题处切起，标题本身要去掉——
+            # 否则「500 字内」实际是按「500 减去标题长度」在卡，报出来的字数也偏大
+            body = (body or '')[len(title):] if (body or '').startswith(title) else (body or '')
+            n = len(re.sub(r'\s', '', body))
+            if n > limit * S.WORD_LIMIT_SLACK:
+                out.append(_issue('warn', 'wordlimit', 'over-limit', f['rel'],
+                                  f'「{title}」写了约 {n} 字，模板要求 {limit} 字内',
+                                  f'超出 {n / limit:.1f} 倍' + (f'（模板附注：{note}）' if note else ''),
+                                  '按模板压缩到要求字数，展开的内容放到对应正文章节去'))
+    return out
+
+
+# ── 模板点名的必备要素 / 签到表与会人 ─────────────────────────────────────
+def check_required_elements(files, spec):
+    """模板在节标题后括号里写明「包括立项文件号、合同号、研究起止时间」——
+    那就是这一节的验收项。两个参考项目都只写到「依据…文件精神」，号一个都没有。"""
+    out = []
+    for f in files:
+        doc = f['doc'] or {}
+        if not doc.get('text'):
+            continue
+        for want_kind, title, needs in S.SECTION_MUST_MENTION:
+            if want_kind not in str(f['kind'] or '') and want_kind not in f['rel']:
+                continue
+            body = _section_text(doc, title)
+            if not body:
+                continue
+            miss = [nm for nm, pat in needs if not pat.search(body)]
+            if miss:
+                out.append(_issue('warn', 'wordlimit', 'missing-element', f['rel'],
+                                  f'「{title}」里没有{"、".join(miss)}',
+                                  '模板在这一节标题后写明了必须包含的要素',
+                                  '补上文号与起止时间；自研项目没有合同号的，写明「自研，无合同」'
+                                  '也比留空好——审查人分不清是没有还是漏填'))
+    return out
+
+
+def check_signin(files, spec):
+    """签到表有表头没人名：这个会没有任何与会记录。
+
+    判建议不判必修——纸质签到原件常在线下，电子件留空是常见做法。
+    但归档里只剩这份电子件时，它就是唯一的证据。
+    """
+    out = []
+    for f in files:
+        if '签到表' not in f['rel'] or f['ext'] not in DOC_EXT:
+            continue
+        for tb in (f['doc'] or {}).get('tables') or []:
+            hdr = next((i for i, r in enumerate(tb)
+                        if any(any(h in str(c) for h in S.SIGNIN_HEADER) for c in r)), None)
+            if hdr is None:
+                continue
+            col = next((j for j, c in enumerate(tb[hdr])
+                        if any(h in str(c) for h in S.SIGNIN_HEADER)), 0)
+            names = [r for r in tb[hdr + 1:]
+                     if col < len(r) and re.fullmatch(r'[一-鿿·]{2,6}', str(r[col]).strip() or '')]
+            if not names:
+                out.append(_issue('warn', 'structure', 'signin-empty', f['rel'],
+                                  '签到表有表头但一个与会人都没填',
+                                  f'「{"/".join(S.SIGNIN_HEADER)}」列下方 '
+                                  f'{max(len(tb) - hdr - 1, 0)} 行全空',
+                                  '把实际与会人录进去；纸质原件已签的，扫描件一并归档'))
+            break
+    return out
+
+
+def check_boilerplate(files, spec):
+    """一段话逐字出现在多种**用途完全不同**的文档里 = 没人按各自的用途写。
+
+    真实语料里最严重的一段 449 字，同时出现在项目建议书、可行性研究报告、研发任务书、
+    项目研发实施计划、12 期研发进度报告、工作总结报告、技术总结报告、研发评价总结纪要——
+    九种类型二十份文件。进度报告的职责是记录本期干了什么，它不该和立项建议书开同一个头。
+
+    判**建议**不判必修：这是质量信号不是事实错误，而且总有正当的复用
+    （立项三件套共享背景），门槛已按真语料定在 4 种类型以避开那一类。
+    聚合成一条报，34 段逐段报会把整张报告刷掉。
+    """
+    para2files = defaultdict(set)
+    kind_of = {}
+    for f in files:
+        if f['ext'] not in DOC_EXT:
+            continue
+        kind_of[f['rel']] = f['kind'] or os.path.basename(f['rel'])
+        for ln in ((f['doc'] or {}).get('text') or '').split('\n'):
+            t = re.sub(r'\s', '', ln)
+            if len(t) >= S.BOILER_MIN_CHARS:
+                para2files[t].add(f['rel'])
+    rows = []
+    for text, rels in para2files.items():
+        ks = {kind_of[r] for r in rels}
+        if len(ks) >= S.BOILER_MIN_KINDS:
+            rows.append((len(ks), len(rels), len(text), sorted(ks), text))
+    if not rows:
+        return []
+    rows.sort(reverse=True)
+    total = sum(r[2] for r in rows)
+    worst = rows[0]
+    return [_issue('warn', 'sameness', 'cross-boilerplate', worst[3][0],
+                   f'{len(rows)} 段正文逐字出现在 {S.BOILER_MIN_KINDS} 种以上不同用途的文档里'
+                   f'（合计 {total} 字）',
+                   f'最严重的一段 {worst[2]} 字，横跨 {worst[0]} 种类型 / {worst[1]} 份文件：'
+                   f'{"、".join(worst[3][:6])}{"…" if len(worst[3]) > 6 else ""}'
+                   f'——「{worst[4][:40]}…」',
+                   '每类文档有各自的职责：进度报告写本期实际进展，验收报告写达标情况，'
+                   '不该和立项建议书开同一个头。背景介绍可以复用，正文主体应当各写各的')]
+
+
+def inspect(root, spec_name='hengtong', deep=False):
+    spec = S.load(spec_name)
+    files = scan(root, spec)
+    issues = []
+    issues += check_complete(files, spec)
+    issues += check_consistency(files, spec)
+    issues += check_leak(files, spec)
+    issues += check_structure(files, spec)
+    issues += check_indicators(files, spec)
+    issues += check_sameness(files, spec)
+    issues += check_figures(files, spec)
+    issues += check_unfinished(files, spec)
+    issues += check_timeline(files, spec)
+    issues += check_schedule(files, spec)
+    issues += check_sheet_content(files, spec)
+    issues += check_project_name(files, spec)
+    issues += check_wordlimit(files, spec)
+    issues += check_required_elements(files, spec)
+    issues += check_signin(files, spec)
+    issues += check_boilerplate(files, spec)
+    # 读不进来的文件要点名。**沉默是最坏的降级**：份数检查照样通过，
+    # 用户看到「必修 0」会以为这些文件查过了，其实它们的正文一个字都没进过判据。
+    dead = [f['rel'] for f in files if (f['doc'] or {}).get('unreadable')]
+    if dead:
+        issues.append(_issue('warn', 'structure', 'unreadable', dead[0],
+                             f'{len(dead)} 份文件读不进来，正文类检查没覆盖到它们',
+                             '、'.join(dead[:4]) + ('…' if len(dead) > 4 else '')
+                             + '——旧版二进制 .doc，本机没有 textutil/antiword 可用',
+                             '转存为 .docx 后重跑，这些文件才会参与模板残留、'
+                             '项目名一致性、雷同度等判据'))
+    if deep:
+        issues += _deep(files)
+    counts = Counter(i['level'] for i in issues)
+    kinds = Counter(f['kind'] for f in files if f['kind'])
+    return {
+        'root': root, 'spec': spec['name'], 'spec_label': spec['label'],
+        'stats': {'files': len(files),
+                  'docs': sum(1 for f in files if f['ext'] in DOC_EXT),
+                  'sheets': sum(1 for f in files if f['ext'] in SHEET_EXT),
+                  'classified': sum(kinds.values()), 'kinds': dict(kinds),
+                  'unclassified': [f['rel'] for f in files if not f['kind']]},
+        'counts': {k: counts.get(k, 0) for k in ('error', 'warn', 'info')},
+        'issues': issues,
+    }
+
+
+def _deep(files):
+    """顺带对每份 .docx 跑一遍单文档排版体检（慢，默认关）。"""
+    out = []
+    here = os.path.dirname(os.path.abspath(__file__))
+    cand = os.path.join(os.path.dirname(os.path.dirname(here)), 'docx-author', 'scripts')
+    if cand not in sys.path:
+        sys.path.insert(0, cand)
+    try:
+        import docx_check
+    except Exception as e:
+        return [_issue('info', 'structure', 'deep-unavailable', '深度体检',
+                       f'单文档体检不可用：{e}')]
+    for f in files:
+        if f['ext'] != '.docx':
+            continue
+        try:
+            r = docx_check.inspect(f['path'])
+        except Exception:
+            continue
+        for it in r['issues']:
+            if it['level'] == 'error':
+                out.append(_issue('error', 'structure', 'doc-' + it['kind'], f['rel'],
+                                  it['msg'], it.get('detail', ''), ''))
+    return out
+
+
+def report(res, limit=6, show_info=True):
+    s, c = res['stats'], res['counts']
+    lines = [f"【档案体检】{os.path.basename(os.path.normpath(res['root']))} · {res['spec_label']}",
+             f"  规模：{s['files']} 个文件（{s['docs']} 份文档 / {s['sheets']} 张表），"
+             f"其中 {s['classified']} 份可对应到规范条目",
+             f"  结论：必修 {c['error']} · 建议 {c['warn']} · 提示 {c['info']}"]
+    # 对不上规范条目的文件要点名。只报个数等于把它们无声吞掉：
+    # 对不上通常有两种原因——文件命名不规范（会连带把齐全性判成缺件），
+    # 或者确实是规范之外的附件。两种都得让人自己看一眼，工具不该替他决定。
+    unk = s.get('unclassified') or []
+    if unk:
+        lines.append(f"  未对应到规范条目的 {len(unk)} 份：" + '、'.join(unk[:6])
+                     + ('…' if len(unk) > 6 else '')
+                     + '（命名不规范会连带误判缺件，规范外的附件则可忽略）')
+    # 按**消息原文**分组，不按 kind：同一个 kind 下「项目名称不一致」与「建设单位不一致」
+    # 是两件事，揉成一条会把第二条的正文吃掉，只剩一个孤零零的 where。
+    grouped = defaultdict(list)
+    for it in res['issues']:
+        grouped[(it['level'], it['group'], it['kind'], it['msg'])].append(it)
+    for key in sorted(grouped, key=lambda k: (ORDER[k[0]], k[1], k[3])):
+        lvl, grp, _kind, msg = key
+        if lvl == 'info' and not show_info:
+            continue
+        items = grouped[key]
+        head = f"  [{LEVEL[lvl]}·{GROUP.get(grp, grp)}] {msg}"
+        if len(items) > 1:
+            head += f'（{len(items)} 处）'
+        lines.append(head)
+        for it in items[:limit]:
+            w = it['where'] or ''
+            d = f" — {it['detail']}" if it['detail'] else ''
+            if w or d:
+                lines.append(f'      · {w}{d}')
+        if len(items) > limit:
+            lines.append(f'      · …另有 {len(items)-limit} 处')
+        if items[0]['suggest']:
+            lines.append(f"      → {items[0]['suggest']}")
+    if not res['issues']:
+        lines.append('  未发现问题。')
+    return '\n'.join(lines)
+
+
+def main(argv):
+    args = [a for a in argv if not a.startswith('--')]
+    if not args:
+        print('用法：python archive_check.py 项目目录 [--deep] [--json] [--spec=名或路径]')
+        return 2
+    spec = 'hengtong'
+    for a in argv:
+        if a.startswith('--spec='):
+            spec = a.split('=', 1)[1]
+    res = inspect(args[0], spec, deep='--deep' in argv)
+    print(json.dumps(res, ensure_ascii=False, default=str) if '--json' in argv else report(res))
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))