@huicai/cli 2026.804.0 → 2026.1019.0

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

@@ -0,0 +1,860 @@
+# 归档能力压测台：正向生成 → 档案体检零必修；反向造缺陷 → 断言体检真的会响；反误报。
+#
+# 归档这一层的检查全是「跨文档的事实」，人工复核成本极高（一个项目 50 份文件），
+# 所以它比单文档体检更依赖这层证明：**没有反向用例的档案体检等于没有体检**。
+#
+# 用法：python archive_battery.py [份数] [--keep]
+# 改了 archive_spec / archive_check / archive_build 任何一个，必须重跑。
+
+import os
+import random
+import copy
+import glob
+import re
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from docx import Document                       # noqa: E402
+
+import archive_build as B                       # noqa: E402
+import archive_check as C                       # noqa: E402
+import archive_spec as S                        # noqa: E402
+
+# 「同一份月报交十二次」的样本必须**够长且多样**：雷同度判据对正文均长不足 300 字的
+# 一律不判（那是还没填的骨架）。样本写短了，测出来的「没命中」不是判据失灵，是样本不够格。
+COPIED_REPORT = (
+    '本月项目组围绕总体技术方案继续推进各项研发工作。需求侧完成了与业务部门的三轮口径确认，'
+    '澄清了权益核销、跨端同步与异常回滚三类边界场景的处理方式，并同步更新了需求规格说明书，'
+    '新增用例十七条，覆盖此前未明确的并发写入与幂等重试两类情形。'
+    '开发侧完成数据接入层与规则引擎的联调，打通了从原始事件到决策输出的完整链路，'
+    '在测试环境下完成两轮回归，接口平均响应由三百二十毫秒降至二百一十毫秒。'
+    '算法侧对特征工程流水线做了重构，将离线与在线特征的口径统一到同一份配置，'
+    '消除了训练与推理不一致带来的漂移问题。测试侧补充了高并发与网络抖动的专项用例，'
+    '发现并修复三处边界缺陷，其中两处与超时重试的状态机迁移有关。'
+    '文档方面完成概要设计说明书的修订与评审，会议纪要与评审记录已归档。'
+    '经费方面，本月支出主要为人员工资与测试环境租用，与预算安排基本一致。'
+    '风险方面，第三方数据接口的稳定性仍需持续观察，项目组已准备降级方案并纳入下阶段验证计划。')
+
+NAMES = ['智能风控', '联邦学习', '知识图谱', '实时数仓', '边缘计算', '数字孪生']
+DEPTS = ['研发一部', '研发二部', '技术中心']
+
+
+def random_card(rng, i=0):
+    y = rng.choice([2024, 2025, 2026])
+    return {
+        '项目名称': f'基于{rng.choice(NAMES)}的{rng.choice(["权益","出行","支付"])}系统研发{i or ""}',
+        '项目编号': f'ZY{y}{rng.randint(1, 999):05d}', '项目负责人': rng.choice(['张工', '李工', '陈波']),
+        '联系电话': f'138{rng.randint(10000000, 99999999)}',
+        '建设单位': '示例科技股份有限公司', '部门': rng.choice(DEPTS),
+        # 预算总额必须等于科目加总——随机一个总额配固定科目，生成时会（正确地）报「不平」，
+        # 而正向跑批把任何提示都当失败。测试数据自己就得先对得平。
+        '起止时间': f'{y}年1月1日至{y}年12月31日', '预算': 3000000,
+        '考核指标': [[f'指标{k}', f'≥ {rng.randint(80, 99)}%', f'第三方检测{k}']
+                     for k in range(1, rng.randint(2, 5))],
+        '人员': [[f'员工{k}', '研发部', '工程师', f'分工{k}'] for k in range(1, rng.randint(3, 6))],
+        '里程碑': [[f'阶段{k}', f'任务{k}', '张工', 80, f'{y}-{k*2:02d}-01', f'{y}-{k*2+1:02d}-28', '交付物']
+                   for k in range(1, 5)],
+        '预算科目': [['其中：人员工资', 2600000], ['服务费', 400000]],
+    }
+
+
+def forward(n, workdir, verbose=True):
+    rng = random.Random(20260901)
+    bad, worst = 0, []
+    for i in range(n):
+        card = random_card(rng, i)
+        out = os.path.join(workdir, f'f{i}')
+        try:
+            root, made, warns = B.build(card, out)
+        except Exception as e:
+            bad += 1
+            worst.append((f'f{i}', f'生成异常 {type(e).__name__}: {e}'))
+            continue
+        if warns:
+            bad += 1
+            worst.append((f'f{i}', '生成提示：' + '；'.join(warns[:2])))
+            continue
+        res = C.inspect(root)
+        errs = [x for x in res['issues'] if x['level'] == 'error']
+        if errs:
+            bad += 1
+            worst.append((f'f{i}', '; '.join(sorted({x['kind'] + ':' + x['msg'][:44] for x in errs}))))
+        shutil.rmtree(out, ignore_errors=True)
+        if verbose and (i + 1) % 5 == 0:
+            print(f'  正向 {i+1}/{n} …')
+    return bad, worst
+
+
+# ── 反向 ───────────────────────────────────────────────────────────────────
+def _fresh(workdir, name):
+    card = random_card(random.Random(7))
+    root, _made, _w = B.build(card, os.path.join(workdir, name))
+    return root
+
+
+def _fingerprint(root):
+    import hashlib
+    h = hashlib.sha256()
+    for dp, dn, fn in sorted(os.walk(root)):
+        dn.sort()
+        for f in sorted(fn):
+            p = os.path.join(dp, f)
+            h.update(os.path.relpath(p, root).encode())
+            try:
+                h.update(open(p, 'rb').read())
+            except OSError:
+                pass
+    return h.hexdigest()
+
+
+def _kinds(root):
+    return {i['kind'] for i in C.inspect(root)['issues']}
+
+
+def _find(root, frag):
+    for dp, _dn, fn in os.walk(root):
+        for f in fn:
+            if frag in f:
+                return os.path.join(dp, f)
+    return None
+
+
+def _set_cover(path, key, value):
+    """改封面信息栏里某个字段的值（第二列）。返回是否真的改到了。"""
+    d = Document(path)
+    for tb in d.tables:
+        for row in tb.rows:
+            cells = row.cells
+            for i in range(len(cells) - 1):
+                if S.field_key(cells[i].text) == key:
+                    cells[i + 1].text = value
+                    d.save(path)
+                    return True
+    return False
+
+
+def _append_para(path, text, after=None):
+    """追加一段；给了 after 就插到那个标题的**正下方**。
+
+    字数类用例必须插进指定小节：追加到文末会落到最后一节里，
+    「项目立项背景」一个字都没变长，用例看着跑了其实什么都没验到。"""
+    d = Document(path)
+    if after:
+        for para in d.paragraphs:
+            if after in para.text:
+                new_p = copy.deepcopy(para._p)
+                para._p.addnext(new_p)
+                from docx.text.paragraph import Paragraph
+                np = Paragraph(new_p, para._parent)
+                for r in list(np.runs)[1:]:
+                    r._r.getparent().remove(r._r)
+                if np.runs:
+                    np.runs[0].text = text
+                else:
+                    np.add_run(text)
+                np.style = d.styles['Normal']
+                d.save(path)
+                return
+    d.add_paragraph(text)
+    d.save(path)
+
+
+def _drop_heading(path, title):
+    d = Document(path)
+    hit = False
+    for p in list(d.paragraphs):
+        if title in p.text and str(p.style.name or '').startswith('Heading'):
+            p._p.getparent().remove(p._p)
+            hit = True
+    if hit:
+        d.save(path)
+    return hit
+
+
+def reverse(workdir):
+    cases = []
+
+    def case(name, expect, mutate):
+        root = _fresh(workdir, 'r-' + re.sub(r'\W', '', name))
+        # 守卫必须按**内容指纹**判，不能只数文件个数：改一份文档里的字段不改变文件数，
+        # 数文件会把「用例确实改了」误判成「用例没改到」，反过来掩盖真问题。
+        before = _fingerprint(root)
+        mutate(root)
+        if _fingerprint(root) == before:
+            cases.append((name, expect, False, {'<用例没改到文件>'}))
+            return
+        got = _kinds(root)
+        cases.append((name, expect, expect in got, got))
+
+    case('删掉必备文档', 'missing-doc',
+         lambda r: os.remove(_find(r, '研发任务书')))
+    case('周期性报告缺期', 'missing-periodic',
+         lambda r: [os.remove(_find(r, f'研发进度报告-{n:02d}')) for n in (3, 7)])
+    case('评审只有报告没签到表', 'review-unpaired',
+         lambda r: os.remove(_find(r, '立项评审会议签到表')))
+    case('项目名称被截断', 'field-truncated',
+         lambda r: _set_cover(_find(r, '技术总结报告'), '项目名称',
+                              os.path.basename(r)[:-2]))
+    case('项目编号不一致', 'field-mismatch',
+         lambda r: _set_cover(_find(r, '项目验收申请表'), '项目编号', 'ZY99999999'))
+    case('联系电话栏填了人名', 'field-shape',
+         lambda r: _set_cover(_find(r, '立项申请书'), '联系电话', '陈波'))
+    case('模板提示块未删', 'hint',
+         lambda r: _append_para(_find(r, '项目建议书'), '提示：这里要写清楚产品定义。'))
+    case('残留 XX 占位符', 'placeholder',
+         lambda r: _append_para(_find(r, '可行性研究报告'), '本项目由技术中心XX部承担。'))
+    case('留了待办占位', 'todo',
+         lambda r: _append_para(_find(r, '工作总结报告'), '经费明细待补充。'))
+    case('缺必备章节', 'missing-section',
+         lambda r: _drop_heading(_find(r, '立项申请书'), '项目考核指标'))
+    def copy_reports(root):
+        """把 12 期月报换成同一份——真实归档里最常见也最难由份数检查发现的敷衍。"""
+        from docx import Document as _D
+        d = os.path.join(root, '周期性文档', '研发进度报告')
+        for f in sorted(os.listdir(d)):
+            p2 = os.path.join(d, f)
+            doc = _D(p2)
+            for para in list(doc.paragraphs):
+                if not str(para.style.name or '').startswith('Heading') and len(para.text.strip()) >= 15:
+                    para._p.getparent().remove(para._p)
+            doc.add_paragraph(COPIED_REPORT)
+            doc.save(p2)
+    case('12 期月报是同一份', 'periodic-duplicate', copy_reports)
+
+    def add_para(root, rel, text):
+        from docx import Document as _D
+        p2 = os.path.join(root, rel)
+        d2 = _D(p2); d2.add_paragraph(text); d2.save(p2)
+
+    case('模板批注未删', 'template-note',
+         lambda r: add_para(r, '9-10验收/项目验收报告.docx',
+                            '注：由项目单位如实填写实际完成情况，下同。'))
+    case('选择项一个都没勾', 'unchecked-choice',
+         lambda r: add_para(r, '9-10验收/项目验收报告.docx',
+                            '1.全面完成（  ） 2.完成70%及以上（  ） 3.完成70%以下（  ）'))
+
+    def unfinished(root):
+        from docx import Document as _D
+        p2 = os.path.join(root, '9-10验收', '项目验收报告.docx')
+        d2 = _D(p2)
+        for tb in d2.tables:
+            head = ' '.join(c.text for c in tb.rows[0].cells)
+            if '实际完成' in head or '规定' in head:
+                tb.rows[1].cells[1].text = '进行中，指标为预计完成指标'
+                break
+        d2.save(p2)
+    case('验收写「进行中」', 'accepting-unfinished', unfinished)
+
+    def wrong_month(root):
+        from docx import Document as _D
+        p2 = os.path.join(root, '周期性文档', '研发进度报告', '研发进度报告-07.docx')
+        d2 = _D(p2)
+        for tb in d2.tables:
+            for row in tb.rows:
+                for c in row.cells:
+                    if re.match(r'^\s*20\d{2}\s*年', c.text.strip()):
+                        c.text = '2099 年 8 月 31 日'
+        d2.save(p2)
+    case('期号与落款月份不符', 'period-date-mismatch', wrong_month)
+
+    def bad_review_order(root):
+        from docx import Document as _D
+        d = os.path.join(root, '评审文件')
+        for f in os.listdir(d):
+            if not f.endswith('.docx'):
+                continue
+            want = None
+            if '验收评审' in f:
+                want = '2026 年 12 月 20 日'
+            elif '结项评审' in f:
+                want = '2026 年 1 月 5 日'
+            if not want:
+                continue
+            doc = _D(os.path.join(d, f))
+            for tb in doc.tables:
+                for row in tb.rows:
+                    for c in row.cells:
+                        if re.match(r'^\s*20\d{2}\s*年', c.text.strip()):
+                            c.text = want
+            doc.save(os.path.join(d, f))
+    case('结项评审早于验收评审', 'review-out-of-order', bad_review_order)
+
+    def sheet_edit(root, frag, fn):
+        from openpyxl import load_workbook as _lw
+        import glob as _g
+        p2 = _g.glob(os.path.join(root, '**', f'*{frag}*.xlsx'), recursive=True)[0]
+        wb = _lw(p2); fn(wb[wb.sheetnames[0]]); wb.save(p2)
+
+    def _hdr(ws, key='任务名称'):
+        for r in range(1, 8):
+            for c in range(1, ws.max_column + 1):
+                if str(ws.cell(r, c).value).strip() == key:
+                    return r
+        return 1
+
+    def _col(ws, r, name):
+        for c in range(1, ws.max_column + 1):
+            if str(ws.cell(r, c).value).strip() == name:
+                return c
+        return 1
+
+    case('进度值越界', 'progress-out-of-range',
+         lambda r: sheet_edit(r, '实际-第1季度',
+                              lambda ws: ws.cell(_hdr(ws) + 1, _col(ws, _hdr(ws), '进度'),
+                                                 2.0)))
+    def clear_actual_end(ws):
+        # 注意：ws.cell(r, c, None) 是空操作（openpyxl 把 None 当「没传值」），
+        # 清空必须显式赋 .value = None。
+        r = _hdr(ws)
+        ws.cell(r + 1, _col(ws, r, '实际结束')).value = None
+    case('标记完成却无实际结束', 'done-without-date',
+         lambda r: sheet_edit(r, '实际-第4季度', clear_actual_end))
+    case('计划表里填了进度', 'plan-has-progress',
+         lambda r: sheet_edit(r, '进度表-计划',
+                              lambda ws: ws.cell(_hdr(ws) + 1, _col(ws, _hdr(ws), '进度'), 1.0)))
+    case('实际表任务被改名', 'task-list-drift',
+         lambda r: sheet_edit(r, '实际-第2季度',
+                              lambda ws: ws.cell(_hdr(ws) + 1, _col(ws, _hdr(ws), '任务名称'),
+                                                 '偷偷改过的任务')))
+
+    def clear_review(root):
+        from openpyxl import load_workbook as _lw
+        import glob as _g
+        p2 = _g.glob(os.path.join(root, '评审文件', '*立项评审报告*.xlsx'))[0]
+        wb = _lw(p2); ws = wb['评审记录']
+        for rr in range(2, ws.max_row + 1):
+            for cc in range(1, ws.max_column + 1):
+                ws.cell(rr, cc).value = None
+        wb.save(p2)
+    case('评审记录被清空', 'empty-review-sheet', clear_review)
+
+    # ── 项目名称一族 ───────────────────────────────────────────────────
+    def rename_body(root, old_frag, new_text, doc='技术总结报告'):
+        """把正文里的项目名改掉（只改正文，不动封面字段——封面是判据的基准）。"""
+        d = Document(_find(root, doc))
+        proj = os.path.basename(root)
+        hit = False
+        for para in d.paragraphs:
+            if proj in para.text:
+                for run in para.runs:
+                    if proj in run.text:
+                        run.text = run.text.replace(proj, new_text)
+                        hit = True
+                if hit:
+                    break
+        if not hit:                       # 正文找不到就追加一段，保证用例真的改到了
+            d.add_paragraph(new_text + '的研究成果如下。')
+        d.save(_find(root, doc))
+
+    def _proj_name(root):
+        """项目名从档案自身的封面读——**不能用目录名**：
+        反向用例的目录叫「r-项目名写错一个字」，拿它当项目名，变异出来的字符串
+        跟档案里的任何文字都不沾边，用例看着跑了其实一个字都没改到。"""
+        return (C.read_docx(_find(root, '技术总结报告'))['fields']
+                .get('项目名称', ''))
+
+    def typo_body(root):
+        proj = _proj_name(root)
+        # 改一个**归一化后还在**的字：「的」会被 name_key 删掉，改它等于没改
+        # 错字要打在名字**中段**：改「系统/平台」这两个字会让串不再匹配项目名正则，
+        # 提取阶段就没了，用例看着改了却一条都不报——那是量具失灵，不是判据对。
+        i = max(proj.find('系统'), proj.find('平台'))
+        bad = proj[:i - 1] + '盖' + proj[i:] if i > 2 else proj[:-1] + '云'
+        rename_body(root, None, bad)
+
+    case('项目名写错一个字', 'name-typo', typo_body)
+    case('签到表抬头是另一个项目', 'name-alien',
+         lambda r: _set_cover(_find(r, '立项评审会议签到表'), '项目名称',
+                              '基于信用模型算法的供应商管理系统研发'))
+    case('正文提到另一个项目', 'name-other',
+         lambda r: _append_para(_find(r, '工作总结报告'),
+                               '本项目参考了基于区块链的电子存证平台的研发的经验。'))
+    # ── 方框选择题一个都没勾 ─────────────────────────────────────────────
+    case('选择框一个都没勾', 'empty-box',
+         lambda r: _append_para(_find(r, '项目验收申请表'), '是否通过验收：□是   □否'))
+    # ── 模板字数上限 ─────────────────────────────────────────────────────
+    case('立项背景严重超字数', 'over-limit',
+         lambda r: _append_para(_find(r, '工作总结报告'), '背景补充。' * 400,
+                               after='项目立项背景'))
+
+    # ── 模板点名的必备要素 ───────────────────────────────────────────────
+    def wipe_basis(root):
+        """把「立项的依据和来源」正文换成一句不含文号/合同号/起止时间的话。"""
+        path = _find(root, '工作总结报告')
+        d = Document(path)
+        hit = False
+        for i, para in enumerate(d.paragraphs):
+            if para.text.strip() == '项目立项的依据和来源':
+                for nxt in d.paragraphs[i + 1:]:
+                    if nxt.style.name.startswith('Heading'):
+                        break
+                    if nxt.text.strip():
+                        nxt.text = '依据公司研发规划立项。'
+                        hit = True
+                break
+        if not hit:
+            d.add_paragraph('项目立项的依据和来源')
+            d.add_paragraph('依据公司研发规划立项。')
+        d.save(path)
+    case('立项依据缺文号与起止时间', 'missing-element', wipe_basis)
+
+    case('缺签批栏', 'missing-approval',
+         lambda r: _drop_heading(_find(r, '研发任务书'), '审批记录') and
+                   _strip_approval(_find(r, '研发任务书')))
+    return cases
+
+
+def _strip_approval(path):
+    """把签批栏那张 kv 表整个删掉（只删标题不够，字段仍在表里）。"""
+    d = Document(path)
+    hit = False
+    for tb in list(d.tables):
+        txt = ' '.join(c.text for row in tb.rows for c in row.cells)
+        if '技术负责人意见' in txt or '项目负责人意见' in txt:
+            tb._tbl.getparent().remove(tb._tbl)
+            hit = True
+    if hit:
+        d.save(path)
+    return hit
+
+
+# ── 反误报 ─────────────────────────────────────────────────────────────────
+def negative(workdir):
+    cases = []
+
+    def nocase(name, forbidden, mutate):
+        root = _fresh(workdir, 'n-' + re.sub(r'\W', '', name))
+        if mutate:
+            mutate(root)
+        got = _kinds(root)
+        bad = [k for k in forbidden if k in got]
+        cases.append((name, not bad, bad))
+
+    # 立项依据写全了文号、合同号、起止时间就不许报
+    def full_basis(root):
+        _append_para(_find(root, '工作总结报告'),
+                     '依据〔2025〕12号文件、合同号 HT-2025-007，研究起止时间 2025年1月至2025年12月。',
+                     after='项目立项的依据和来源')
+    nocase('立项依据要素齐全不报', ['missing-element'], full_basis)
+
+    # 签到表填了与会人就不许报
+    def fill_signin(root):
+        # **五张全填**：nocase 是对整套归档断言的，只填一张，另外四张照样报，
+        # 看着像判据误报，其实是用例只做了五分之一。
+        import glob as _g
+        for path in _g.glob(os.path.join(root, '**', '*签到表*.docx'), recursive=True):
+            d = Document(path)
+            for tb in d.tables:
+                done = False
+                for r, row in enumerate(tb.rows):
+                    if any('姓名' in c.text for c in row.cells):
+                        col = next(j for j, c in enumerate(row.cells) if '姓名' in c.text)
+                        if r + 1 < len(tb.rows):
+                            tb.rows[r + 1].cells[col].text = '陈波'
+                        done = True
+                        break
+                if done:
+                    d.save(path)
+                    break
+    nocase('签到表已填与会人不报', ['signin-empty'], fill_signin)
+
+    # 简称是正常的：真实归档里「…系统的研发」「…系统研发」「…系统」混用 144 次。
+    # 这三种写法**一个都不许报**——报了就会淹掉真正的错字（差一个字的那种）。
+    def abbrev(root):
+        proj = (C.read_docx(_find(root, '技术总结报告'))['fields']
+                .get('项目名称', ''))
+        short = re.sub(r'的?研发\d*$', '', proj)
+        _append_para(_find(root, '技术总结报告'),
+                     f'{short}系统已完成；{short}的研发工作已结束；{proj}通过验收。')
+    nocase('项目名简称/加减「的」不算异名', ['name-typo', 'name-alien', 'name-other'], abbrev)
+
+    # 勾了的方框不能再报「一个都没勾」
+    nocase('方框已勾选不报', ['empty-box'],
+           lambda r: _append_para(_find(r, '项目验收申请表'), '是否通过验收：■是   □否'))
+
+    # 字数在限内（含 1.5 倍宽限）不报
+    nocase('立项背景未超字数不报', ['over-limit'], None)
+
+    # 文件改名（真实项目会把「6-研发实施计划」写成「6-项目研发实施计划」）不得判成缺失
+    def rename(root):
+        p = _find(root, '项目研发实施计划')
+        os.rename(p, os.path.join(os.path.dirname(p), '6-研发实施计划（V2）.docx'))
+    nocase('文件改了名', ['missing-doc'], rename)
+
+    # 章节用了别名（「验收标准」而不是「验收标准和验收工作安排」）不得判成缺章节
+    def alias(root):
+        p = _find(root, '项目研发实施计划')
+        d = Document(p)
+        for para in d.paragraphs:
+            if '验收标准和验收工作安排' in para.text:
+                for r in para.runs:
+                    r.text = ''
+                para.runs[0].text = '七、验收标准' if para.runs else ''
+        d.save(p)
+    nocase('章节用了别名', ['missing-section'], alias)
+
+    # 条件性目录（变更/委外/测试）缺席不算缺陷
+    nocase('没有变更与委外文档', ['missing-doc'], lambda r: None)
+
+    # 刚生成的骨架正文还没填，12 期长得像是必然的——不能判成抄
+    nocase('空骨架不判雷同', ['periodic-duplicate', 'periodic-similar'], lambda r: None)
+
+    def vary_reports(root):
+        from docx import Document as _D
+        uniq = ['本月主攻需求澄清，与业务部门确认了权益核销的三种口径，形成争议纪要一份。',
+                '本月完成数据接入层重构，弃用轮询方案，改为基于变更日志的增量同步。',
+                '本月算法侧引入对比学习预训练，冷启动召回率由四成七提升到六成一。',
+                '本月处理线上事故一起，根因是分布式锁在主从切换时被提前释放，已加租约续期。',
+                '本月与法务完成数据合规评审，补充跨境传输三项限制并写入接口契约。',
+                '本月压测暴露连接池瓶颈，最大连接数由二百调到八百并按租户隔离。',
+                '本月完成灰度发布方案设计，按流量比例与用户标签双维度切分，支持一键回滚。',
+                '本月清理十九个已下线接口与四张僵尸表，释放存储三点二 TB。',
+                '本月与第三方厂商完成对接联调，就重试语义与幂等键达成一致并签技术附件。',
+                '本月组织内部技术分享两场，主题为特征平台设计与在线推理降级策略。',
+                '本月开展安全渗透测试，发现越权访问缺陷两处，均已修复并补回归用例。',
+                '本月完成验收材料预审，对照任务书逐条核对指标，识别两项证据缺口。']
+        d = os.path.join(root, '周期性文档', '研发进度报告')
+        for f, u in zip(sorted(os.listdir(d)), uniq):
+            p2 = os.path.join(d, f)
+            doc = _D(p2)
+            doc.add_paragraph(COPIED_REPORT[:300] + u * 5)
+            doc.save(p2)
+    nocase('各期有实质不同内容', ['periodic-duplicate'], vary_reports)
+
+    def real_notes(root):
+        from docx import Document as _D
+        p2 = os.path.join(root, '5-研发任务书.docx')
+        d2 = _D(p2)
+        for t in ('注：数据口径以合同附件三为准。', '注：金额单位为万元，含税。',
+                  '注：本表由财务部填报后归档。'):
+            d2.add_paragraph(t)
+        d2.save(p2)
+    nocase('正经注释不判模板批注', ['template-note'], real_notes)
+
+    def one_ticked(root):
+        from docx import Document as _D
+        p2 = os.path.join(root, '9-10验收', '项目验收报告.docx')
+        d2 = _D(p2)
+        d2.add_paragraph('1.全面完成（√） 2.完成70%及以上（  ） 3.完成70%以下（  ）')
+        d2.save(p2)
+    nocase('勾了一个就不算未勾', ['unchecked-choice'], one_ticked)
+
+    # 0.03 / 0.38 / 0.75 是正常的完成比例，不许判越界
+    def normal_ratio(root):
+        from openpyxl import load_workbook as _lw
+        import glob as _g
+        p2 = _g.glob(os.path.join(root, '7-进度表', '*实际-第2季度*.xlsx'))[0]
+        wb = _lw(p2); ws = wb[wb.sheetnames[0]]
+        hr = 1
+        for rr in range(1, 8):
+            if any(str(ws.cell(rr, cc).value).strip() == '进度'
+                   for cc in range(1, ws.max_column + 1)):
+                hr = rr
+                break
+        pc = next(cc for cc in range(1, ws.max_column + 1)
+                  if str(ws.cell(hr, cc).value).strip() == '进度')
+        for i, v in enumerate((0.03, 0.38, 0.75)):
+            ws.cell(hr + 1 + i, pc).value = v
+        wb.save(p2)
+    nocase('正常完成比例不判越界', ['progress-out-of-range'], normal_ratio)
+    return cases
+
+
+def invariants(workdir):
+    """不变量：不靠体检报不报，直接断言产物本身对不对。"""
+    out = []
+
+    def chk(name, fn):
+        try:
+            out.append((name, True, fn() or ''))
+        except Exception as e:
+            out.append((name, False, f'{type(e).__name__}: {str(e)[:120]}'))
+
+    def budget_name_mismatch():
+        """卡里写自造科目名 → 必须点名并给出正确科目表。
+
+        真跑抓到的：卡上预算 280 万、科目加总也 280 万（内部勾稽通过），
+        但科目名「人员费/设备费」对不上固定口径，`plan.get(name, 0)` 让它们静默变零，
+        生成出来的预算表整张全零而**没有任何提示**——最难查的一类失败。"""
+        c = random_card(random.Random(11))
+        c['预算科目'] = [['人员费', 1800000], ['设备费', 400000]]
+        c['预算'] = 2200000
+        root = os.path.join(workdir, 'inv-budgetname')
+        shutil.rmtree(root, ignore_errors=True)
+        _r, _m, warns = B.build(c, root)
+        hit = [w for w in warns if '预算科目' in w and '对不上' in w]
+        assert hit, '自造预算科目名没有被点名'
+        assert '人员费' in hit[0] and '设备费' in hit[0], '没说清是哪几项对不上'
+        assert '其中：人员工资' in hit[0], '没给出正确科目表，调用方无法自纠'
+        # 用正确科目名重来，表里必须真有钱
+        c['预算科目'] = [['其中：人员工资', 1800000], ['服务费', 400000]]
+        root2 = os.path.join(workdir, 'inv-budgetok')
+        shutil.rmtree(root2, ignore_errors=True)
+        _r2, _m2, w2 = B.build(c, root2)
+        assert not [w for w in w2 if '预算科目' in w and '对不上' in w], '正确科目名不该被点名'
+        import pandas as _pd
+        f = glob.glob(os.path.join(root2, '**', '*预算*'), recursive=True)[0]
+        df = _pd.read_excel(f, header=None, dtype=object)
+        nz = [v for row in df.itertuples(index=False, name=None) for v in row
+              if isinstance(v, (int, float)) and v and v > 1000]
+        assert nz and max(nz) == 1800000, f'预算表没落进金额：{nz[:5]}'
+        return f'点名 2 项 + 正确名下落进 {len(nz)} 处金额'
+
+    def unknown_section_lists_valid():
+        """章节名对不上 → 警告里必须列出该类文档的规范章节。
+
+        只说「写错了」不给对的名字，调用方只能一次次猜；真跑里模型自造的章节名
+        几乎没一个对得上，正文全被排到了文末，而表面看一切正常。"""
+        c = random_card(random.Random(12))
+        c['章节内容'] = {'项目建议书': {'项目建设背景与必要性': '正文一'}}
+        root = os.path.join(workdir, 'inv-section')
+        shutil.rmtree(root, ignore_errors=True)
+        _r, _m, warns = B.build(c, root)
+        hit = [w for w in warns if '规范章节' in w]
+        assert hit, '未知章节名没有被点名'
+        assert '项目建设背景与必要性' in hit[0], '没说是哪个章节名错了'
+        assert '规范章节是' in hit[0] and '文档介绍' in hit[0], '没列出规范章节，无法自纠'
+        return '点名 + 列出规范章节'
+
+    def unknown_kind_lists_all():
+        """未收录的文档类型：可用类型要**列全**，不能截断成「…」。"""
+        c = random_card(random.Random(13))
+        c['章节内容'] = {'项目工作总结报告': {'某节': '正文'}}
+        root = os.path.join(workdir, 'inv-kind')
+        shutil.rmtree(root, ignore_errors=True)
+        _r, _m, warns = B.build(c, root)
+        hit = [w for w in warns if '未收录的文档类型' in w]
+        assert hit, '未知文档类型没有被点名'
+        assert '…' not in hit[0], '可用类型被截断，调用方拿不到正确名字'
+        assert '工作总结报告' in hit[0], '正确类型名不在提示里'
+        return '未截断'
+
+    def figure_threshold():
+        """「该有图却没图」的门槛必须落在**空骨架与写实文档之间的空隙**里。
+
+        量出来的三档：空骨架 260~551 字 / 写实最短 1464 字 / 真实归档 5243 字起。
+        门槛原来是 1500，落进了写实区——一份 1464 字、写得很实的技术总结报告
+        差 36 字擦边漏过。门槛的作用是「别对空骨架挑刺」，不是「短就不算文档」。
+        """
+        c = random_card(random.Random(14))
+        root = os.path.join(workdir, 'inv-figskel')
+        shutil.rmtree(root, ignore_errors=True)
+        B.build(c, root)
+        skel = [i for i in C.inspect(root)['issues'] if i['kind'] == 'no-figure']
+        assert not skel, f'空骨架不该报缺图：{[i["where"] for i in skel]}'
+        # 写实但偏短（~1400 字）的技术总结报告必须报
+        c2 = random_card(random.Random(15))
+        para = '本系统采用湖仓一体架构，覆盖数据接入、特征计算与决策编排三层。' * 12
+        c2['章节内容'] = {'技术总结报告': {'项目简介': para, '主要研究的内容': para}}
+        root2 = os.path.join(workdir, 'inv-figreal')
+        shutil.rmtree(root2, ignore_errors=True)
+        B.build(c2, root2)
+        got = [i for i in C.inspect(root2)['issues'] if i['kind'] == 'no-figure']
+        assert got, '写实但没图的技术总结报告应当被报出来'
+        return '空骨架零误报 + 写实无图必报'
+
+    chk('缺图门槛落在空骨架与写实文档之间', figure_threshold)
+    chk('自造预算科目名被点名且给出正确科目表', budget_name_mismatch)
+    chk('未知章节名的警告列出规范章节', unknown_section_lists_valid)
+    chk('未知文档类型的可用列表不截断', unknown_kind_lists_all)
+
+    def long_name():
+        c = random_card(random.Random(3))
+        c['项目名称'] = '超长项目名称' * 50
+        root, made, _w = B.build(c, os.path.join(workdir, 'inv-long'))
+        bad = [p for p in made
+               for seg in os.path.relpath(p, os.path.dirname(root)).split(os.sep)
+               if len(seg.encode()) > 255]
+        assert not bad, f'{len(bad)} 个路径段超 255 字节'
+        return '路径段均合规'
+    chk('超长项目名不撑爆路径', long_name)
+
+    def inject_unknown():
+        c = random_card(random.Random(4))
+        c['章节内容'] = {'立项申请书': {'查无此节': '这段内容不该凭空消失。'}}
+        root, _m, w = B.build(c, os.path.join(workdir, 'inv-inj'), only=['立项申请书'])
+        p = os.path.join(root, '1-立项文档', '3-立项申请书.docx')
+        assert '这段内容不该凭空消失' in C.read_docx(p)['text'], '注入内容被静默丢弃'
+        assert any('查无此节' in x for x in w), '丢内容却没有任何提示'
+        return '内容保留 + 有提示'
+    chk('注入到不存在的章节不丢内容', inject_unknown)
+
+    def budget_sum():
+        from openpyxl import load_workbook
+        c = random_card(random.Random(5))
+        c['预算科目'] = [['其中：人员工资', 2600000], ['服务费', 400001]]
+        root, made, _w = B.build(c, os.path.join(workdir, 'inv-bud'))
+        p = [x for x in made if '预算表' in x][0]
+        ws = load_workbook(p).active
+        for row in ws.iter_rows(values_only=True):
+            if not row or not row[0] or '小计' in str(row[0]):
+                continue
+            months = [v for v in row[1:13] if isinstance(v, (int, float))]
+            tot = row[13] if len(row) > 13 and isinstance(row[13], (int, float)) else None
+            if tot and months:
+                assert abs(sum(months) - tot) < 0.005, f'{row[0]}：12 月合计 {sum(months)} ≠ 全年 {tot}'
+        return '横向加总处处相等'
+    chk('预算 12 个月之和 = 全年金额', budget_sum)
+
+    def cross_engine():
+        """归档产物逐份过**单文档/单表体检**——三套引擎的接缝就在这儿。
+
+        这条曾揪出最隐蔽的一个缺陷：没有任何标题的短文档（决议、通知、签到表）里，
+        封面大标题与文号被当成正文，19 份产物齐刷刷报「字号不统一/缩进忽有忽无」。
+        档案体检看不见它（那是单文档层面的事），单文档 battery 也看不见（它不生成归档件），
+        只有把两层接起来跑才现形。
+        """
+        import sys as _s, os as _o
+        here = _o.path.dirname(_o.path.abspath(__file__))
+        for d in ('docx-author', 'xlsx-analysis'):
+            q = _o.path.join(_o.path.dirname(_o.path.dirname(here)), 'skills', d, 'scripts')
+            q = q if _o.path.isdir(q) else _o.path.join(_o.path.dirname(_o.path.dirname(here)), d, 'scripts')
+            if q not in _s.path:
+                _s.path.insert(0, q)
+        import docx_check as _DC, xlsx_check as _XC
+        c = random_card(random.Random(6))
+        root, made, _w = B.build(c, os.path.join(workdir, 'inv-cross'))
+        bad = []
+        for p2 in made:
+            try:
+                if p2.endswith('.docx'):
+                    r = _DC.inspect(p2)
+                elif p2.endswith('.xlsx'):
+                    r = _XC.inspect(p2)
+                else:
+                    continue
+            except Exception as e:
+                bad.append((os.path.basename(p2), f'{type(e).__name__}'))
+                continue
+            e2 = [i for i in r['issues'] if i['level'] == 'error']
+            if e2:
+                bad.append((os.path.basename(p2), sorted({i['kind'] for i in e2})))
+        assert not bad, f'{len(bad)} 份产物在单文档/单表体检里有必修：{bad[:3]}'
+        return f'{len(made)} 份逐份过检全清'
+    chk('归档产物逐份过单文档与单表体检', cross_engine)
+
+    def deliverables():
+        """里程碑的交付物必须落进计划类文档——它是「任务书→实施计划→验收报告」勾稽链的起点，
+        只躺在档案卡里等于没有：验收时按什么逐条核对？"""
+        c = random_card(random.Random(8))
+        c['里程碑'] = [[f'阶段{i}', f'任务{i}', '张工', 40, f'2026-{i*3:02d}-01',
+                        f'2026-{i*3:02d}-28', f'交付物{i}'] for i in range(1, 5)]
+        root, _m, _w = B.build(c, os.path.join(workdir, 'inv-dlv'),
+                               only=['研发任务书', '项目研发实施计划'])
+        t = (C.read_docx(os.path.join(root, '5-研发任务书.docx'))['text']
+             + C.read_docx(os.path.join(root, '6-项目研发实施计划.docx'))['text'])
+        miss = [m[6] for m in c['里程碑'] if m[6] not in t]
+        assert not miss, f'交付物没进计划类文档：{miss}'
+        return f"{len(c['里程碑'])} 项交付物均落地"
+    chk('里程碑交付物进入计划类文档', deliverables)
+
+    def budget_reconcile():
+        """预算科目加总与档案卡总额不平必须当场说——同一个数要在立项书、预算表、
+        验收决算里各出现一次，卡上不平，生成出来就是三处互相打架。"""
+        c = random_card(random.Random(9))
+        c['预算'], c['预算科目'] = 5000000, [['其中：人员工资', 1234567]]
+        _r, _m, w = B.build(c, os.path.join(workdir, 'inv-bud2'), only=['年度研发支出预算表'])
+        assert any('预算科目加总' in x for x in w), f'不平却没提示：{w}'
+        c2 = random_card(random.Random(10))
+        c2['预算'], c2['预算科目'] = 3000000, [['其中：人员工资', 2000000], ['服务费', 1000000]]
+        _r2, _m2, w2 = B.build(c2, os.path.join(workdir, 'inv-bud3'), only=['年度研发支出预算表'])
+        assert not w2, f'对平了却仍在提示：{w2}'
+        return '不平会说、平了不吵'
+    chk('预算科目与总额勾稽', budget_reconcile)
+
+    def optional_periodic():
+        """规范里列为「选做」的周期性文档（周报 52 期、月度开发报告）不得默认生成——
+        默认全出会凭空多出六十多份没人要的文件；而且它们的规范产物不是 .docx，
+        用 docx 建版器写进 .xlsx 文件名会落成一个打不开的废文件。"""
+        c = random_card(random.Random(11))
+        root, made, w = B.build(c, os.path.join(workdir, 'inv-opt'))
+        names = [os.path.basename(p) for p in made]
+        assert not any('周报' in n for n in names), '默认生成了周报'
+        assert not any('月度开发报告' in n for n in names), '默认生成了月度开发报告'
+        from openpyxl import load_workbook as _lw
+        for p in made:
+            if p.endswith('.xlsx'):
+                _lw(p)          # 打不开会直接抛
+        assert len(made) < 80, f'产物 {len(made)} 份，疑似把选做件也生成了'
+        return f'{len(made)} 份（未含选做件）'
+    chk('选做周期性文档不默认生成', optional_periodic)
+
+    def cumulative():
+        """季度实际表必须是**累计**的：完成数逐季不减，且每个标记完成的行都得有实际起止与工时。
+        只填本季度会造出「进度标 1、实际日期空着」的自相矛盾——那正是进度表体检要报的必修。"""
+        import glob as _g
+        c = random_card(random.Random(12))
+        root, _m, _w = B.build(c, os.path.join(workdir, 'inv-cum'))
+        ns = []
+        for q in range(1, 5):
+            p2 = _g.glob(os.path.join(root, '7-进度表', f'*实际-第{q}季度*.xlsx'))[0]
+            df = C._read_sheet_df(p2)
+            done = df[df['进度'] >= 1]
+            ns.append(len(done))
+            assert done['实际结束'].notna().all(), f'第 {q} 季度有完成项缺实际结束'
+            assert (done['实际工时'].fillna(0) > 0).all(), f'第 {q} 季度有完成项工时为 0'
+        assert ns == sorted(ns), f'完成数不是逐季不减：{ns}'
+        return f'{ns}'
+    chk('季度实际表累计且自洽', cumulative)
+    return out
+
+
+def main(argv):
+    n = 8
+    for a in argv:
+        if a.isdigit():
+            n = int(a)
+    keep = '--keep' in argv
+    workdir = os.path.join(os.getcwd(), '_abattery') if keep else tempfile.mkdtemp(prefix='arcbat-')
+    os.makedirs(workdir, exist_ok=True)
+    print(f'压测目录：{workdir}')
+    fails = 0
+
+    print(f'\n[1/4] 正向：随机档案卡 × {n} 套，断言生成的整套归档零必修')
+    bad, worst = forward(n, workdir)
+    if bad:
+        fails += 1
+        print(f'  ✗ {bad}/{n} 套出现必修项：')
+        for name, why in worst[:6]:
+            print(f'      {name} → {why}')
+    else:
+        print(f'  ✓ {n} 套全部零必修（生成即合规，跨文档一致性天然为真）')
+
+    print('\n[2/4] 反向：每条规则配一个故意做坏的归档，断言体检真的会响')
+    cases = reverse(workdir)
+    miss = [c for c in cases if not c[2]]
+    for name, expect, hit, got in cases:
+        print(f"  {'✓' if hit else '✗'} {name:<18} 期望 {expect}"
+              + ('' if hit else f"　实际命中：{sorted(got)[:7]}"))
+    if miss:
+        fails += 1
+        print(f'  ✗ {len(miss)}/{len(cases)} 条规则是瞎的')
+    else:
+        print(f'  ✓ {len(cases)}/{len(cases)} 条规则全部命中')
+
+    print('\n[3/4] 不变量：产物本身必须对（不依赖体检报不报）')
+    invs = invariants(workdir)
+    for name, ok2, why in invs:
+        print(f"  {'✓' if ok2 else '✗'} {name:<22} {why}")
+    if any(not ok2 for _n, ok2, _w in invs):
+        fails += 1
+
+    print('\n[4/4] 反误报：合规做法不得被判成问题')
+    negs = negative(workdir)
+    for name, ok, bad2 in negs:
+        print(f"  {'✓' if ok else '✗'} {name:<18}" + ('' if ok else f'　被误报：{bad2}'))
+    if any(not ok for _n, ok, _b in negs):
+        fails += 1
+    else:
+        print(f'  ✓ {len(negs)}/{len(negs)} 项合规做法零误报')
+
+    if not keep:
+        shutil.rmtree(workdir, ignore_errors=True)
+    print('\n' + ('全部通过。' if not fails else f'有 {fails} 个环节未通过。'))
+    return 1 if fails else 0
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))