用 WorkBuddy 做调研：把链接清单变成有证据的决策简报

演示资料包：以下产品、页面、沟通与评分均为虚构教学材料，
无真实品牌，无产品实测。
研究问题：成人社区活动团队选择报名工具，下月开始试用；
预计每月约300条报名，峰值600条；不需要收款功能。
硬约束：年费总额不超过1200元；每月至少600条报名额度；
能导出含报名ID、创建时间和状态的CSV。
S01｜甲厂商套餐说明（演示），材料日期2026-10-01：
标准版900元/年，含2名管理员，每月600条报名，支持CSV导出，
字段含报名ID、创建时间、状态；本例无其他必须费用。
S02｜乙厂商套餐说明（演示），材料日期2026-10-01：
基础版600元/年，每月200条报名，支持CSV导出；
材料未提供其他套餐。
S03｜丙厂商报价（演示），材料日期2026-10-02：1100元/年，
含2名管理员，每月600条报名，支持“批量管理”；
未说明CSV导出与导出字段；本例未显示其他必须费用。
S04｜丙销售沟通摘录（演示），材料日期2026-10-03：
“应该可以导出你们需要的数据，我再确认。”未给具体格式或字段。
S05｜教学评分表：只有硬约束通过才使用。成本：
总额<=900元给8分，900元<总额<=1100元给6分，
1100元<总额<=1200元给4分；超过预算淘汰。
配置便利性和日常操作均按10分制，练习给定甲7/8、丙9/9；
这些分数是练习输入，不是实测。
权重成本40%、配置便利性35%、日常操作25%。
S06｜未来验证任务：
用20条虚构报名记录检查创建、修改、删除与导出；
逐项比对字段、行数和权限。此任务尚未执行。

虚构补充资料包；仅用于练习，不是真实厂商资料或实测记录。
范围：丙 / 标准版 / CSV含报名ID、创建时间、状态。
所有材料日期、root与scope标注均为题设输入。root表示共同原材料，不证明机构独立性。
S03｜演示报价，2026-10-02，第1段，根R3：支持“批量管理”，未说明CSV与字段。未知。
S07｜演示导出说明，2026-10-04，第2段，根R7：标准版CSV含报名ID、创建时间、状态。支持。
reprint-0至reprint-4｜演示转载，2026-10-04，各第1段：均逐字引用S07第2段，共用根R7。
S08｜演示导出说明，2026-10-05，第3段，根R8：标准版CSV不含状态字段。否定。
premium｜演示套餐说明，2026-10-05，第1段，根RP：高级版CSV含上述三个字段。范围不符。
S09｜演示勘误，2026-10-06，第1段：
“本次标准版说明S08中‘不包含状态字段’为误写。请撤回该句；S07列出的标准版三个导出字段保持有效。”
分阶段发放：第一轮不提供S09；第二轮提供S09，但尚未提供复核记录；第三轮再提供下面的教学前提。
教学复核记录：假设核查者已核对S09的发布方、原文位置与适用范围，同意本例撤回R8。
此记录是注入输入，不是程序或WorkBuddy核验了真伪。现实核查人、核查时间均未提供。
R8在本资料包只有一个受撤回断言，因此可整根撤回；真实一份文档含多个断言时必须拆卡，不能由一句勘误撤回整份文档。

"""Synthetic research exercise. No web, model, credentials, or product calls."""
from dataclasses import dataclass, replace
import unittest

SCOPE = ('丙', '标准版', 'CSV含报名ID/创建时间/状态')

@dataclass(frozen=True)
class Card:
    id: str
    root: str       # 人工核对后的共同原始材料编号，不等于独立机构
    scope: tuple
    value: object  # True / False / None；None 表示材料没有明确证明


def gate(cards, withdrawn=()):
    """Return (status, active_root_count, ignored_card_ids)."""
    ids = [c.id for c in cards]
    if len(ids) != len(set(ids)):
        raise ValueError('duplicate card id')
    withdrawn = set(withdrawn)
    known_roots = {c.root for c in cards if c.root}
    if not withdrawn <= known_roots:
        raise ValueError('unknown withdrawn root')
    roots, ignored = {}, []
    for c in cards:
        if not c.root or not (c.value is None or type(c.value) is bool):
            raise ValueError('invalid evidence card')
        if c.scope != SCOPE or c.root in withdrawn:
            ignored.append(c.id)
            continue
        roots.setdefault(c.root, set()).add(c.value)
    values = {v for group in roots.values() for v in group if v is not None}
    if values == {True, False}:
        status = 'CONFLICT'
    elif values == {False}:
        status = 'FAIL'
    elif values == {True}:
        status = 'DOCUMENTED'
    else:
        status = 'PENDING'
    return status, len(roots), tuple(sorted(ignored))


# 以下全部是假材料；T、F、U分别代表明确支持、明确否定、未明确说明。
T = Card('S07', 'R7', SCOPE, True)
F = Card('S08', 'R8', SCOPE, False)
U = Card('S03', 'R3', SCOPE, None)
COPIES = [replace(T, id=f'reprint-{i}') for i in range(5)]
WRONG = replace(T, id='premium', root='RP',
                scope=('丙', '高级版', SCOPE[2]))


def unsafe_majority(cards):
    # 故意错误：把转载篇数当票数，忽略范围和冲突。
    return sum(c.value is True for c in cards) > sum(c.value is False for c in cards)


class GateTests(unittest.TestCase):
    def test_fixed_oracles(self):
        # 预期元组人工写死，不调用gate产生答案，也不只检查“两次输出一致”。
        cases = [
            ('empty', [], (), ('PENDING', 0, ())),
            ('unknown', [U], (), ('PENDING', 1, ())),
            ('document', [T], (), ('DOCUMENTED', 1, ())),
            ('negative', [F], (), ('FAIL', 1, ())),
            ('copies', [T] + COPIES, (), ('DOCUMENTED', 1, ())),
            ('wrong-plan', [U, WRONG], (), ('PENDING', 1, ('premium',))),
            ('conflict', [T, F], (), ('CONFLICT', 2, ())),
            ('copy-flood', [T, F] + COPIES, (), ('CONFLICT', 2, ())),
            ('same-root-conflict', [T, replace(F, root='R7')], (),
             ('CONFLICT', 1, ())),
            ('withdraw-entire-family', [T, F] + COPIES, ('R7',),
             ('FAIL', 1, ('S07', 'reprint-0', 'reprint-1', 'reprint-2',
                          'reprint-3', 'reprint-4'))),
            ('confirmed-correction', [T, F] + COPIES, ('R8',),
             ('DOCUMENTED', 1, ('S08',))),
        ]
        for name, cards, withdrawn, expected in cases:
            with self.subTest(name=name):
                self.assertEqual(gate(cards, withdrawn), expected)

    def test_reject_bad_input(self):
        for cards, withdrawn in [([T, T], ()), ([T], ('TYPO',)),
                                 ([replace(T, root='')], ()),
                                 ([replace(T, value='yes')], ())]:
            with self.subTest(cards=cards, withdrawn=withdrawn):
                with self.assertRaises(ValueError):
                    gate(cards, withdrawn)

    def test_deliberately_wrong_algorithm_is_caught(self):
        self.assertTrue(unsafe_majority([T, F] + COPIES))
        self.assertEqual(gate([T, F] + COPIES), ('CONFLICT', 2, ()))
        self.assertTrue(unsafe_majority([WRONG]))
        self.assertEqual(gate([WRONG]), ('PENDING', 0, ('premium',)))


if __name__ == '__main__':
    unittest.main(verbosity=2)

{
  "decision_id": "D09",
  "source": "S09",
  "source_location": "evidence-pack.txt / S09 / 第1段",
  "withdrawn_root": "R8",
  "withdrawn_claim": "S08：标准版CSV不含状态字段",
  "scope": [
    "丙",
    "标准版",
    "CSV含报名ID/创建时间/状态"
  ],
  "reviewed": true,
  "review_basis": "教学输入：假设发布方、原文位置和适用范围均已由人工核对",
  "reviewer": null,
  "reviewed_at": null,
  "boundary": "reviewed不是程序核验结果；真实使用前须由人工提供完整复核记录"
}

"""Synthetic correction trace; reviewed is a supplied premise, not authentication."""
import json
from pathlib import Path
from evidence_gate import U, T, F, COPIES, gate, unsafe_majority

def withdrawal(decision):
    # Only accepts this exercise's supplied decision. Does not verify a source.
    if decision.get('reviewed') is not True:
        return ()
    if (decision.get('decision_id'), decision.get('source'),
        decision.get('withdrawn_root'), decision.get('scope')) != (
        'D09', 'S09', 'R8', list(T.scope)):
        raise ValueError('correction does not match exercise scope')
    return ('R8',)

def main():
    decision = json.loads(Path(__file__).with_name('correction.json').read_text())
    cards = [U, T, F] + COPIES
    print('initial', gate([U]))
    print('new-document', gate([U, T]))
    print('conflicting-note-and-five-copies', gate(cards))
    print('correction-not-reviewed', gate(cards, withdrawal(dict(decision, reviewed=False))))
    print('S09-reviewed-premise-withdraw-R8', gate(cards, withdrawal(decision)))
    print('negative-control-withdraw-R7', gate(cards, ('R7',)))
    print('unsafe-majority', unsafe_majority([T, F] + COPIES))

if __name__ == '__main__':
    main()

initial ('PENDING', 1, ())
new-document ('DOCUMENTED', 2, ())
conflicting-note-and-five-copies ('CONFLICT', 3, ())
correction-not-reviewed ('CONFLICT', 3, ())
S09-reviewed-premise-withdraw-R8 ('DOCUMENTED', 2, ('S08',))
negative-control-withdraw-R7 ('FAIL', 2, ('S07', 'reprint-0', 'reprint-1', 'reprint-2', 'reprint-3', 'reprint-4'))
unsafe-majority True

"""Run fixed oracles and ensure two intentionally broken gates fail them."""
import io
import json
from pathlib import Path
import subprocess
import sys
import unittest
from dataclasses import replace
import evidence_gate as eg
from scenario import withdrawal

def run_suite():
    stream = io.StringIO()
    result = unittest.TextTestRunner(stream=stream, verbosity=2).run(
        unittest.defaultTestLoader.loadTestsFromTestCase(eg.GateTests))
    return result, stream.getvalue()

def main():
    result, log = run_suite()
    print(log, end='')
    if not result.wasSuccessful():
        raise SystemExit('source tests failed')
    original = eg.gate
    def majority(cards, withdrawn=()):
        status, roots, ignored = original(cards, withdrawn)
        active = [c for c in cards if c.id not in ignored]
        if any(c.value is not None for c in active):
            status = 'DOCUMENTED' if eg.unsafe_majority(active) else 'FAIL'
        return status, roots, ignored
    def ignore_plan(cards, withdrawn=()):
        return original([replace(c, scope=eg.SCOPE) for c in cards], withdrawn)
    for name, broken in [('majority', majority), ('ignore-plan', ignore_plan)]:
        eg.gate = broken
        try:
            result, log = run_suite()
        finally:
            eg.gate = original
        if result.wasSuccessful() or result.errors or not result.failures:
            raise SystemExit(name + ': mutation was not caught by assertion failures')
        print('REJECTED', name, 'assertion failures:', len(result.failures))
    decision = json.loads(Path('correction.json').read_text())
    if withdrawal(dict(decision, reviewed=False)) != ():
        raise SystemExit('unreviewed correction wrongly applied')
    if withdrawal(decision) != ('R8',):
        raise SystemExit('reviewed premise not applied')
    for field, value in [('source', 'S10'), ('withdrawn_root', 'R7'), ('scope', ['丙', '高级版'])]:
        try:
            withdrawal(dict(decision, **{field: value}))
        except ValueError:
            pass
        else:
            raise SystemExit('mismatched correction accepted: ' + field)
    command = [sys.executable] + (['-O'] if sys.flags.optimize else []) + ['scenario.py']
    actual = subprocess.check_output(command, text=True)
    if actual != Path('expected-output.txt').read_text():
        raise SystemExit('scenario differs from fixed oracle')
    print('PASS correction guards and seven-line scenario oracle')

if __name__ == '__main__':
    main()