"""7 维项目级审计评分卡（纯函数、标准库 only）。 定位：这是一个评分卡，不是门禁、不是审计、不是自动循环。 它不重写 metrics、arch_conformance、ledger、audit_loop 的逻辑， 只接受调用方显式传入的结构化证据，算出 7 维各自的分数。 计分规则（钉死，不可改为平均分达标）： - 每维分数 0-10，保留一位小数；>=9 通过，<9 不通过。 - 总体结论：7 维全部 >=9 才算达标（overall="pass"）。 任一维 <9，总体就不达标（overall="not_pass"）。 - 平均分只作参考信息（average_score），绝不能作为达标依据。 代码里把“平均分达标”写成明确的不通过路径并加测试钉住： 例如 6 维 10 分、1 维 4 分，平均 9.1 分，总体仍是不达标。 - 未知处理：任何一维的数据源缺失、未知、未验证， 该维分数记为 None（未知），不记 0、不记 10、不估算， 总体直接不达标，并列出缺失项（missing_items）。 “没数据”既不算通过，也不算 0 分去拉低平均分后又用平均分糊弄。 - 未实测处理：调用方传入“夹具模拟”“视口替代”“未编译端代码评审” 这类证据时，该项记为“未实测”（untested_items），而不是“通过”。 若某维的关键证据全部是未实测，该维记为 None。 - 阈值：DEFAULT_THRESHOLDS 全部标注 source="test_default_unapproved" （测试默认值、未拍板）。生产阈值须用户拍板后，由调用方显式 传入 thresholds（含 source="user_approved"）才能替换默认值。 本模块绝不把测试初值写成生产值。 - 与已定语义的关系（本模块不改它们）： #238 evaluate_feedback 的 auto_apply 保持 False； #247 纠正为 pass 本身不解封； #244 CONDITIONAL 先映射为 fail 再记（本模块只接受已映射的结论， 若调用方传入 verdict="conditional"，记为未实测/无效证据，不算通过）。 - 基线漂移门禁（v7 机制第 5 项，本模块新增）： build_scorecard(..., baseline_head=None) 的 baseline_head 是机器字段， 只能由调用方显式传入当前 main 头；本模块绝不在生产代码里探测 版本控制状态、绝不读版本控制目录、绝不编造一个头。 不传入（或传入空串）时 baseline_head 为 None，并在 missing_items 里记 baseline_head_missing，不把缺失读成“与当前一致”。 check_baseline_stale(scorecard, current_main_head) 是唯一的漂移判定： current_main_head != baseline_head 时 stale=True，且该旧分整体结论 不得再作 pass 依据（返回里以 usable_as_pass_basis=False 明示， 调用方凭此字段判断）。stale 是附加字段：本项绝不改写 build_scorecard 的 overall / overall_pass 旧语义，旧值保留以便追溯， 测试断言 stale 字段而非改写旧 overall。 冻结版的服务端存储见 cloud/scorecard_baseline_store.py（只追加、 不提供改删旧冻结行的方法）；阈值仍一律标 test_default_unapproved， 除非调用方显式传入 user_approved。 7 维定义（不要擅自增维、减维、改名换义）： 1. delivery_quality 交付质量 2. gate_audit 门禁与审计有效性 3. arch_contract 架构与契约一致性 4. test_coverage 测试与验证覆盖 5. security_ledger 安全与账本可信 6. cost_quota 成本与配额可观测 7. ops_scale 生产运维与规模 10 维到 7 维的合并映射（写进文档，也写在这里）： - 流程完整性并入门禁与审计有效性（G0-G8 最终靠门禁和重审证明）； - 自动化程度并入门禁与审计有效性 + 生产运维与规模 （自动化的证据就是自动循环是否真实跑通、真实 App 是否安装）； - 文档与技能并入架构与契约一致性 （技能文本、附录溯源、移植规则最终都是契约一致性的一部分）。 输入格式：build_scorecard(evidence, thresholds=None, rubric_version=None, baseline_head=None, evidence_rows=None, user_side_items=None, product_evidence=None) rubric_version 只是卡片上的版本锚点（版本化持久存储见 cloud/scorecard_rubric.py：标尺改动写新版本行、旧行只读， 本函数不查库、不改旧分）。 输入格式：build_scorecard(evidence, thresholds=None, user_side_items=None) evidence: dict，键为上面 7 个维 id，值为该维的证据 dict。 每个维的证据字段见各 _score_* 函数的 docstring。 调用方必须带来源、时间、检查名；本模块不自动从测试文件、 摘要文档、PR 描述里拼凑分数。 三张表拆分（v7 机制第 2 项，见 _SCORERS 后的注释）： build_code_scorecard：代码证据 4 维，不含生产项； build_production_scorecard：生产证据 3 维，缺项不拉低代码表， 可选 user_side_items 占位证据（pending 即挡住生产表 overall）； build_product_scorecard：全部 7 维 + 真实产品轮门禁，无真实 产品轮证据时恒 not_pass；这只是评分卡输入结构拆分， 不代表任何产品功能已落地。build_scorecard 的返回 dict 同时带 code/production/product 三个子对象，GET /audit-scorecard 端点返回的示例卡因此也带这三个子对象（端点已接线）。 v7 机制第 7 项 user_side_items（本模块内实现，不依赖第 2 项的三张表函数）： - evidence 可带可选键 "user_side_items"，或由 build_scorecard 的 user_side_items 关键字参数显式传入（关键字参数优先于 evidence 键）。 每项至少含 id、status（pending/done/blocked）、blocked_by （pending/blocked 时必填，例如 user/host_env/contract_decision）。 - 非法项绝不静默丢弃、绝不编造状态：记入 user_side_items["invalid_items"]（含下标与原因），不进 items。 - 输出增加 user_side_items 字段：原样透传有效项（多余字段保留）， 并附汇总 pending_ids、done_ids、blocked_ids、blocked_by_summary。 - 三表规则见 apply_user_side_three_table_rule()：代码表结论 （code_overall）绝不因用户侧 pending 被拉低；用户侧有未完成项 （pending/blocked）或非法项时，生产表结论强制为 not_pass， 原因字段明确指向用户侧（如 "user_side_pending: B1,B2,..."）； user_side_items 为空/缺失时，输出 user_side_unknown=True， 生产表原因写 user_side_unknown，绝不把“无用户侧项”写成 “用户侧已完成”。 - 本项不做 B/C 拍板、不改阈值：阈值仍为 test_default_unapproved； B/C 清单只是 id 与标题常量（见 USER_SIDE_ITEM_IDS），未知 id 不因此判非法（清单可能扩展），非法只按缺字段/未知状态/缺 blocked_by/重复 id 判定。""" from __future__ import annotations import hashlib import json PASS_SCORE = 9.0 DIMENSIONS = [ ("delivery_quality", "交付质量"), ("gate_audit", "门禁与审计有效性"), ("arch_contract", "架构与契约一致性"), ("test_coverage", "测试与验证覆盖"), ("security_ledger", "安全与账本可信"), ("cost_quota", "成本与配额可观测"), ("ops_scale", "生产运维与规模"), ] DIMENSION_IDS = [d[0] for d in DIMENSIONS] # 阈值表：每一项都带 source，默认值一律是测试初值、未拍板。 # “9 分线”是达到 9 分的下限，“10 分线”是达到 10 分的下限， # “floor”是低于该值后分数进入 0-5 区间的参考点（不是达标线）。 # 这些数值本身不是生产标准；生产阈值须用户拍板后显式传入。 DEFAULT_THRESHOLDS = { "defect_rate_nine": {"value": 0.05, "source": "test_default_unapproved"}, "defect_rate_ten": {"value": 0.02, "source": "test_default_unapproved"}, "defect_rate_floor": {"value": 0.20, "source": "test_default_unapproved"}, "first_pass_nine": {"value": 0.90, "source": "test_default_unapproved"}, "first_pass_ten": {"value": 0.95, "source": "test_default_unapproved"}, "first_pass_floor": {"value": 0.50, "source": "test_default_unapproved"}, "rework_rate_nine": {"value": 0.10, "source": "test_default_unapproved"}, "rework_rate_ten": {"value": 0.05, "source": "test_default_unapproved"}, "rework_rate_floor": {"value": 0.50, "source": "test_default_unapproved"}, "overturn_rate_floor": {"value": 0.30, "source": "test_default_unapproved"}, "coverage_nine": {"value": 0.85, "source": "test_default_unapproved"}, "coverage_ten": {"value": 0.90, "source": "test_default_unapproved"}, "coverage_floor": {"value": 0.75, "source": "test_default_unapproved"}, "sampling_normal": {"value": 0.10, "source": "test_default_unapproved"}, "sampling_critical": {"value": 0.50, "source": "test_default_unapproved"}, "parallel_scale_target": {"value": 40, "source": "test_default_unapproved"}, } UNTESTED_KINDS = {"fixture", "viewport_substitute", "code_review_only", "fixture_simulated", "dry_run", "estimated"} # v7 审计 B/C 用户侧清单（id 与标题；仅作常量与测试证据，不作拍板）。 USER_SIDE_ITEM_IDS = [ "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", "C1", "C2", "C3", "C4", ] USER_SIDE_ITEM_TITLES = { "B1": "分支保护", "B2": "合并部署窗口", "B3": "阈值拍板", "B4": "金任务人工审定", "B5": "真实 PG 环境", "B6": "真实 App 安装", "B7": "第二台主机与账单", "B8": "v1.1 确认", "B9": "回滚演练窗口", "C1": "证据绑定强制化与签名", "C2": "live 验证接线", "C3": "锚点策略", "C4": "actual-only 语义", } VALID_USER_SIDE_STATUSES = {"pending", "done", "blocked"} def normalize_user_side_items(raw): """归一化用户侧项：有效项原样透传，非法项记入 invalid_items。 返回 dict，键：items、pending_ids、done_ids、blocked_ids、 unfinished_ids、blocked_by_summary、invalid_items、count、 all_pending、all_done、user_side_unknown。 user_side_unknown 仅在 raw 为 None 或空列表时为 True； 非列表、非法项等情形不算 unknown，而是 invalid（生产表 同样不能因此通过，原因指向 invalid，见三表规则）。 本函数不修改调用方传入的原始项（逐项浅拷贝）。 """ summary = { "items": [], "pending_ids": [], "done_ids": [], "blocked_ids": [], "unfinished_ids": [], "blocked_by_summary": {}, "invalid_items": [], "count": 0, "all_pending": False, "all_done": False, "user_side_unknown": False, } if raw is None: summary["user_side_unknown"] = True return summary if isinstance(raw, (str, bytes)) or not isinstance(raw, (list, tuple)): summary["invalid_items"].append({ "index": None, "reason": "user_side_items_not_a_list", "raw_type": type(raw).__name__, }) return summary if len(raw) == 0: summary["user_side_unknown"] = True return summary seen_ids = set() for index, item in enumerate(raw): if not isinstance(item, dict): summary["invalid_items"].append({ "index": index, "reason": "item_not_a_dict", "raw_type": type(item).__name__, }) continue item_id = item.get("id") if not isinstance(item_id, str) or not item_id: summary["invalid_items"].append({ "index": index, "reason": "id_missing", }) continue if item_id in seen_ids: summary["invalid_items"].append({ "index": index, "id": item_id, "reason": "duplicate_id", }) continue status = item.get("status") if status not in VALID_USER_SIDE_STATUSES: summary["invalid_items"].append({ "index": index, "id": item_id, "reason": "status_missing_or_unknown", "status": status, }) continue blocked_by = item.get("blocked_by") if status in ("pending", "blocked"): if not isinstance(blocked_by, str) or not blocked_by: summary["invalid_items"].append({ "index": index, "id": item_id, "reason": "blocked_by_missing", }) continue seen_ids.add(item_id) copied = dict(item) summary["items"].append(copied) if status == "pending": summary["pending_ids"].append(item_id) summary["unfinished_ids"].append(item_id) elif status == "blocked": summary["blocked_ids"].append(item_id) summary["unfinished_ids"].append(item_id) else: summary["done_ids"].append(item_id) if isinstance(blocked_by, str) and blocked_by: summary["blocked_by_summary"].setdefault(blocked_by, []).append(item_id) summary["count"] = len(summary["items"]) if summary["items"]: summary["all_pending"] = all( it["status"] == "pending" for it in summary["items"]) summary["all_done"] = all( it["status"] == "done" for it in summary["items"]) return summary def _extract_overall(value): """从字符串或评分卡 dict 里取出 overall（字符串原样返回）。""" if isinstance(value, dict): for key in ("overall", "code_overall", "production_overall"): if isinstance(value.get(key), str): return value[key] return None if isinstance(value, str): return value return None def apply_user_side_three_table_rule(code_overall, production_overall, user_side_items): """三表规则（v7 机制第 7 项；位置：本模块）。 输入：代码表结论、生产表结论（各为 "pass"/"not_pass" 字符串， 或含 overall 键的评分卡 dict）、user_side_items 原始列表。 输出：代码表结论原样不动；生产表结论在用户侧未完成/非法/ 未知时强制为 not_pass，原因明确指向用户侧；用户侧全部 done 且无非法项时，生产表结论跟随其自身输入结论，不被本规则改写。 本函数是纯函数，不读库、不改阈值、不做 B/C 拍板。 """ normalized = normalize_user_side_items(user_side_items) code = _extract_overall(code_overall) production = _extract_overall(production_overall) forced = False reason = None if normalized["user_side_unknown"]: production = "not_pass" reason = ("user_side_unknown: no user_side_items supplied; " "not equivalent to user_side_done") forced = True elif normalized["invalid_items"]: production = "not_pass" reasons = "; ".join( "%s(%s)" % (inv.get("reason", "invalid"), inv.get("id", inv.get("index"))) for inv in normalized["invalid_items"]) reason = "user_side_invalid: %s" % reasons if normalized["unfinished_ids"]: reason += "; user_side_pending: %s" % ",".join( normalized["unfinished_ids"]) forced = True elif normalized["unfinished_ids"]: production = "not_pass" reason = "user_side_pending: %s" % ",".join( normalized["unfinished_ids"]) forced = True return { "code_overall": code, "production_overall": production, "production_reason": reason, "user_side_forced_production_not_pass": forced, "code_unchanged_by_user_side": True, "user_side_unknown": normalized["user_side_unknown"], "user_side_items": normalized, } def thresholds_source(thresholds): """阈值来源：只有调用方显式传入 user_approved 才算已拍板。""" if not thresholds: return "test_default_unapproved" sources = set() for entry in thresholds.values(): if isinstance(entry, dict): sources.add(entry.get("source", "test_default_unapproved")) else: sources.add("test_default_unapproved") if sources == {"user_approved"}: return "user_approved" return "test_default_unapproved" # 旧私有名的兼容别名（v2cov 评分卡测试仍从这里导入它）。 _thresholds_source = thresholds_source def _effective_thresholds(thresholds): """实际用于计分的阈值表：默认值 + 调用方显式覆盖，逐项归一化。 未被覆盖的键仍取 DEFAULT_THRESHOLDS（与 _t 的逐键回落一致）， 因此卡片上报告的 thresholds 就是真正算分的表，不再是“恒为 默认值”的旧写法。数值本身仍一律标来源，未拍板的不冒充生产值。 """ effective = {k: dict(v) for k, v in DEFAULT_THRESHOLDS.items()} for key, entry in (thresholds or {}).items(): if isinstance(entry, dict): merged = {"value": entry["value"]} merged["source"] = entry.get("source", "test_default_unapproved") effective[key] = merged else: effective[key] = {"value": entry, "source": "test_default_unapproved"} return effective def _t(thresholds, key): if thresholds and key in thresholds: entry = thresholds[key] if isinstance(entry, dict): return entry["value"] return entry return DEFAULT_THRESHOLDS[key]["value"] def _round1(value): return round(float(value) + 1e-9, 1) def _score_higher(value, nine, ten, floor): """越高越好：floor->5 分，nine->9 分，ten->10 分，分段线性，低于 floor 按比例。""" if value is None: return None v = float(value) if v >= ten: return 10.0 if v >= nine: return 9.0 + (v - nine) / (ten - nine) if ten > nine else 10.0 if v >= floor: return 5.0 + 4.0 * (v - floor) / (nine - floor) if nine > floor else 5.0 if floor > 0: return max(0.0, 5.0 * v / floor) return 0.0 def _score_lower(value, ten, nine, floor): """越低越好：ten->10 分，nine->9 分，floor->5 分，低于 ten 满分，高于 floor 递减。""" if value is None: return None v = float(value) if v <= ten: return 10.0 if v <= nine: return 9.0 + (nine - v) / (nine - ten) if nine > ten else 10.0 if v <= floor: return 5.0 + 4.0 * (floor - v) / (floor - nine) if floor > nine else 5.0 return max(0.0, 5.0 * floor / v) if v > 0 else 0.0 def _result(dim_id, score, basis, missing, untested): if score is None: status = "unknown" elif score >= PASS_SCORE: status = "pass" else: status = "fail" return { "id": dim_id, "score": _round1(score) if score is not None else None, "status": status, "basis": basis, "missing_items": missing, "untested_items": untested, } def _score_delivery(ev, th): """证据：first_pass_rate, defect_rate, rework_rate, first_pass_known, defect_known, rework_known, attempts_present, evidence_kind（"real" 以外若为 estimated/fixture 则记未实测）。""" missing, untested, basis = [], [], [] for key in ("first_pass_rate", "defect_rate", "rework_rate"): if ev.get(key) is None: missing.append(key) for key in ("first_pass_known", "defect_known", "rework_known"): if not ev.get(key): missing.append(key + "_not_known") if not ev.get("attempts_present"): missing.append("attempts_present_false_or_missing") kind = ev.get("evidence_kind") if kind in UNTESTED_KINDS: untested.append("metrics_evidence_kind=%s" % kind) if missing or untested: return _result("delivery_quality", None, basis, missing, untested) subs = [ ("first_pass_rate", _score_higher(ev["first_pass_rate"], _t(th, "first_pass_nine"), _t(th, "first_pass_ten"), _t(th, "first_pass_floor"))), ("defect_rate", _score_lower(ev["defect_rate"], _t(th, "defect_rate_ten"), _t(th, "defect_rate_nine"), _t(th, "defect_rate_floor"))), ("rework_rate", _score_lower(ev["rework_rate"], _t(th, "rework_rate_ten"), _t(th, "rework_rate_nine"), _t(th, "rework_rate_floor"))), ] for name, sub in subs: basis.append("%s=%s -> %.1f" % (name, ev[name], sub)) return _result("delivery_quality", min(s for _, s in subs), basis, missing, untested) def _score_gate(ev, th): """证据：hard_gate_enforced（bool/None）、gate_items_passed、 gate_items_total、merge_blocked_verified、loop_end_to_end_verified、 sampling_misjudgment_rate（None 表示未抽查/未知）、 audit_verdict（"conditional" 记无效证据，不算通过）。""" missing, untested, basis = [], [], [] if ev.get("hard_gate_enforced") is None: missing.append("hard_gate_enforced_unknown") if ev.get("gate_items_passed") is None or ev.get("gate_items_total") is None: missing.append("gate_items_passed_or_total_missing") if ev.get("audit_verdict") == "conditional": untested.append("audit_verdict=conditional_not_a_pass") if ev.get("evidence_kind") in UNTESTED_KINDS: untested.append("gate_evidence_kind=%s" % ev["evidence_kind"]) if missing or untested: return _result("gate_audit", None, basis, missing, untested) if not ev.get("hard_gate_enforced"): basis.append("hard_gate_enforced=False（record 模式）：已知未强制，分数封顶 4.0") return _result("gate_audit", 4.0, basis, missing, untested) total = ev["gate_items_total"] passed = ev["gate_items_passed"] rate = passed / total if total else 0.0 sub_gate = _score_higher(rate, 0.99, 1.0, 0.80) basis.append("gate_items %s/%s=%.3f -> %.1f" % (passed, total, rate, sub_gate)) subs = [sub_gate] if not ev.get("merge_blocked_verified"): basis.append("merge_blocked_verified=False：合并阻塞未真实验证，分数封顶 4.0") return _result("gate_audit", 4.0, basis, missing, untested) if not ev.get("loop_end_to_end_verified"): basis.append("loop_end_to_end_verified=False：自动循环端到端未真实验证，分数封顶 4.0") return _result("gate_audit", 4.0, basis, missing, untested) mis = ev.get("sampling_misjudgment_rate") if mis is None: missing.append("sampling_misjudgment_rate_unknown") return _result("gate_audit", None, basis, missing, untested) sub_mis = _score_lower(mis, 0.0, 0.02, _t(th, "overturn_rate_floor")) basis.append("sampling_misjudgment_rate=%s -> %.1f" % (mis, sub_mis)) subs.append(sub_mis) return _result("gate_audit", min(subs), basis, missing, untested) def _score_arch(ev, th): """证据：contract_frozen、arch_violations、directory_violations、 import_violations、stack_changed_without_approval（bool/None）。""" missing, untested, basis = [], [], [] for key in ("arch_violations", "directory_violations", "import_violations"): if ev.get(key) is None: missing.append(key + "_unknown") if ev.get("contract_frozen") is None: missing.append("contract_frozen_unknown") if missing: return _result("arch_contract", None, basis, missing, untested) total_violations = (ev["arch_violations"] + ev["directory_violations"] + ev["import_violations"]) basis.append("violations total=%s (arch=%s dir=%s import=%s)" % (total_violations, ev["arch_violations"], ev["directory_violations"], ev["import_violations"])) if not ev.get("contract_frozen"): basis.append("contract_frozen=False：已知未冻结，分数封顶 4.0") return _result("arch_contract", 4.0, basis, missing, untested) if ev.get("stack_changed_without_approval"): basis.append("stack_changed_without_approval=True：分数封顶 4.0") return _result("arch_contract", 4.0, basis, missing, untested) if total_violations > 0: basis.append("violations>0：分数封顶 5.0") return _result("arch_contract", 5.0, basis, missing, untested) return _result("arch_contract", 10.0, basis, missing, untested) def _score_test(ev, th): """证据：prd_coverage_rate、agent_six_complete、cross_matrix_coverage_rate、 coverage_pct、lint_items、mypy_items、bandit_high、 cross_matrix_kind（"real" 以外记未实测）、real_pg（bool）、 real_service（bool）。""" missing, untested, basis = [], [], [] for key in ("prd_coverage_rate", "cross_matrix_coverage_rate", "coverage_pct"): if ev.get(key) is None: missing.append(key + "_missing") kind = ev.get("cross_matrix_kind") if kind in UNTESTED_KINDS or kind in ("viewport_substitute", "code_review_only"): untested.append("cross_matrix_kind=%s" % kind) if kind is not None and kind != "real": untested.append("cross_matrix_not_real") if not ev.get("real_pg"): untested.append("real_pg_not_verified") if not ev.get("real_service"): untested.append("real_service_not_verified") if missing or untested: return _result("test_coverage", None, basis, missing, untested) if not ev.get("agent_six_complete"): basis.append("agent_six_complete=False：agent 专属六项缺项，分数封顶 4.0") return _result("test_coverage", 4.0, basis, missing, untested) subs = [ ("prd_coverage_rate", _score_higher(ev["prd_coverage_rate"], 0.99, 1.0, 0.80)), ("cross_matrix_coverage_rate", _score_higher(ev["cross_matrix_coverage_rate"], 0.99, 1.0, 0.80)), ("coverage_pct", _score_higher(ev["coverage_pct"], _t(th, "coverage_nine"), _t(th, "coverage_ten"), _t(th, "coverage_floor"))), ] for name, sub in subs: basis.append("%s=%s -> %.1f" % (name, ev[name], sub)) # 静态检查：数值缺失记缺失，不估算；有值时，>0 即封顶（9 分线要求接近清零）。 for key in ("lint_items", "mypy_items", "bandit_high"): if ev.get(key) is None: missing.append(key + "_missing") if missing: return _result("test_coverage", None, basis, missing, untested) static_total = ev["lint_items"] + ev["mypy_items"] + ev["bandit_high"] basis.append("static total lint=%s mypy=%s bandit_high=%s" % (ev["lint_items"], ev["mypy_items"], ev["bandit_high"])) if static_total > 0: basis.append("static_total>0：分数封顶 8.0（静态检查未接近清零）") return _result("test_coverage", min(8.0, min(s for _, s in subs)), basis, missing, untested) return _result("test_coverage", min(s for _, s in subs), basis, missing, untested) def _score_security(ev, th): """证据：ledger_verify_ok（bool/None）、ledger_coverage_rate、 shell_whitelist_pass_rate、branch_protection （"protected"/"unprotected"/"unknown"/None）、anchor_check_recent。""" missing, untested, basis = [], [], [] if ev.get("ledger_verify_ok") is None: missing.append("ledger_verify_ok_unknown") if ev.get("ledger_coverage_rate") is None: missing.append("ledger_coverage_rate_missing") bp = ev.get("branch_protection") if bp is None or bp == "unknown": missing.append("branch_protection_unknown") if missing: return _result("security_ledger", None, basis, missing, untested) if bp == "unprotected": basis.append("branch_protection=unprotected：已知未保护，分数封顶 4.0") return _result("security_ledger", 4.0, basis, missing, untested) if not ev.get("ledger_verify_ok"): basis.append("ledger_verify_ok=False：账本校验未通过，分数封顶 4.0") return _result("security_ledger", 4.0, basis, missing, untested) subs = [_score_higher(ev["ledger_coverage_rate"], 0.99, 1.0, 0.80)] basis.append("ledger_coverage_rate=%s -> %.1f" % (ev["ledger_coverage_rate"], subs[0])) rate = ev.get("shell_whitelist_pass_rate") if rate is not None: sub = _score_higher(rate, 0.99, 1.0, 0.80) subs.append(sub) basis.append("shell_whitelist_pass_rate=%s -> %.1f" % (rate, sub)) if not ev.get("anchor_check_recent"): basis.append("anchor_check_recent=False：锚点定期校验未落地，分数封顶 8.0") return _result("security_ledger", min(8.0, min(subs)), basis, missing, untested) return _result("security_ledger", min(subs), basis, missing, untested) def _score_cost(ev, th): """证据：cost_records_complete（bool）、unpriced_as_zero（bool， True 即违规）、per_creator_present、quota_cutoff_verified、 thresholds_approved（bool，仅影响阈值来源标注，不封顶分数）。""" missing, untested, basis = [], [], [] if not ev.get("cost_records_complete"): missing.append("cost_records_complete_false_or_missing" "（turns/llm_requests/usd_micros 缺失）") if ev.get("unpriced_as_zero") is None: missing.append("unpriced_as_zero_unknown") if missing: return _result("cost_quota", None, basis, missing, untested) if ev.get("unpriced_as_zero"): basis.append("unpriced_as_zero=True：无价记成 0/免费，分数封顶 0.0") return _result("cost_quota", 0.0, basis, missing, untested) if not ev.get("quota_cutoff_verified"): basis.append("quota_cutoff_verified=False：配额硬切断未真实验证，分数封顶 4.0") return _result("cost_quota", 4.0, basis, missing, untested) if not ev.get("per_creator_present"): basis.append("per_creator_present=False：按创建者成本未落地，分数封顶 8.0") return _result("cost_quota", 8.0, basis, missing, untested) basis.append("cost_records_complete=True, quota_cutoff_verified=True, " "per_creator_present=True, unpriced_as_zero=False") return _result("cost_quota", 10.0, basis, missing, untested) def _score_ops(ev, th): """证据：ci_green_rate（None 表示 CI 未绿/未知）、deploy_success_rate、 rollback_drill_done、ha_status （"second_host"/"single_host_accepted"/"single_host_unaccepted"/None）、 parallel_scale_proven（int/None）、parallel_scale_accepted_alternative（bool）。""" missing, untested, basis = [], [], [] if ev.get("ci_green_rate") is None: missing.append("ci_green_rate_unknown（CI 未绿或未统计）") if ev.get("rollback_drill_done") is None: missing.append("rollback_drill_done_unknown") ha = ev.get("ha_status") if ha is None: missing.append("ha_status_unknown") if missing: return _result("ops_scale", None, basis, missing, untested) if not ev.get("rollback_drill_done"): basis.append("rollback_drill_done=False：回滚演练未真实跑过，分数封顶 4.0") return _result("ops_scale", 4.0, basis, missing, untested) subs = [_score_higher(ev["ci_green_rate"], 0.99, 1.0, 0.80)] basis.append("ci_green_rate=%s -> %.1f" % (ev["ci_green_rate"], subs[0])) if ev.get("deploy_success_rate") is not None: sub = _score_higher(ev["deploy_success_rate"], 0.99, 1.0, 0.80) subs.append(sub) basis.append("deploy_success_rate=%s -> %.1f" % (ev["deploy_success_rate"], sub)) if ha == "single_host_unaccepted": basis.append("ha_status=single_host_unaccepted：分数封顶 5.0") return _result("ops_scale", 5.0, basis, missing, untested) proven = ev.get("parallel_scale_proven") target = _t(th, "parallel_scale_target") if proven is None and not ev.get("parallel_scale_accepted_alternative"): missing.append("parallel_scale_proven_unknown") return _result("ops_scale", None, basis, missing, untested) if proven is not None: sub = _score_higher(min(proven, target) / target if target else 0, 0.99, 1.0, 0.5) # 规模是离散证据：40 人满分，18 人约 4.5 分，上面线性公式在 # 0.5-1.0 区间给出 5-10 分，与“18 人约 4.5”不一致，故直接用比例*10。 sub = _round1(10.0 * min(proven, target) / target) if target else 0.0 subs.append(sub) basis.append("parallel_scale_proven=%s target=%s -> %.1f" % (proven, target, sub)) return _result("ops_scale", min(subs), basis, missing, untested) _SCORERS = { "delivery_quality": _score_delivery, "gate_audit": _score_gate, "arch_contract": _score_arch, "test_coverage": _score_test, "security_ledger": _score_security, "cost_quota": _score_cost, "ops_scale": _score_ops, } # ---- v7 机制第 4 项：分数证据绑定与签名（只做这一项） ---- # 诚实边界（先写清，再写代码）： # - 本节是纯函数：只算哈希与验签结果，不写库、不写账本、 # 不移动 cloud/ledger.py 的链头、不改变总体达标规则。 # evidence_ledger_head 是调用方传入的证据行即时算出的链头， # 不是已持久化/已外部锚定的头；持久化与外部锚定是调用方 # 与运营方的事，本模块绝不谎称已上链入库。 # - 防重盖戳靠签名，不靠本节的哈希：哈希只能证明“这份证据体 # 就是算分时那份”（改动即哈希变），不能证明“这份证据体是 # 新取的”。没有有效签名的证据，调用方仍可重盖戳再交—— # 与 cloud/evidence_binding.py 的说明同款局限，本节不冒充解决。 # - 生产签名密钥供给仍是待定的运营方事项：本模块不含任何 # 生产密钥、不读生产 env、不新增密钥落盘路径、不默认信任。 # 机制只是代码就绪，不是生产已激活；真实 PG 上的链验证未做， # 本项测试只用纯函数内存计算（连 SQLite 账本集成都没接）。 # - 签名验证是 fail-closed：无验证器、签名缺失、验证器拒绝、 # 验证器抛异常，一律 verified=False，绝不默认 verified=True。 # 验签结果不改变 build_scorecard 的 overall：总体达标仍只看 # 7 维分数，签名是调用方在传证据行之前自行核验的附加层， # 把验签接入门禁/达标是另一次契约决定，不在本项悄悄做。 EVIDENCE_CHAIN_GENESIS = hashlib.sha256( b"scorecard-evidence-genesis-v1").hexdigest() def canonical_evidence_bytes(evidence_row): """证据体全文的规范字节：dict 按 sort_keys 紧凑 JSON 编码。 全文即整个 dict，不只取其中某个字段；字段增减、值改动、 键顺序之外的任何内容变化都会改变字节，从而改变哈希。 非 JSON 可序列化内容抛 ValueError，不静默丢字段。 """ if isinstance(evidence_row, bytes): return evidence_row if isinstance(evidence_row, str): return evidence_row.encode("utf-8") try: return json.dumps(evidence_row, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8") except (TypeError, ValueError) as exc: raise ValueError( "evidence row must be JSON-serializable: %s" % (exc,)) def hash_evidence_body(evidence_row): """证据体全文哈希：规范字节的 SHA-256 hex。""" return hashlib.sha256( canonical_evidence_bytes(evidence_row)).hexdigest() def compute_evidence_ledger(evidence_rows): """对调用方传入的证据行算链头与行 id 列表（纯函数）。 链式构造（仿 cloud/ledger.py 的头推进，不写库）： head_0 = EVIDENCE_CHAIN_GENESIS head_{i+1} = sha256((head_i + body_hash_i).encode()) 因此任一证据体改动、行顺序变化都会改变最终头哈希； 只改一行 id 而不动其余内容时，该行体哈希随之变，头也变。 返回 {"head": str|None, "row_ids": [...], "body_hashes": [...]}。 - evidence_rows 为 None 或空：head=None、row_ids=[]、 body_hashes=[]，绝不编造一个头或 id。 - 行 id 只取行 dict 里现成的 "id"（且不为 None）；没有 id 的行仍参与头计算，但不为其发明 id（row_ids 长度可小于 行数，调用方要可审计映射须每行自带 id）。 - 非 dict 行抛 ValueError：不静默跳过、不猜 id。 """ if evidence_rows is None: return {"head": None, "row_ids": [], "body_hashes": []} rows = list(evidence_rows) if not rows: return {"head": None, "row_ids": [], "body_hashes": []} row_ids, body_hashes = [], [] head = EVIDENCE_CHAIN_GENESIS for row in rows: if not isinstance(row, dict): raise ValueError("evidence row must be a dict") body_hash = hash_evidence_body(row) body_hashes.append(body_hash) head = hashlib.sha256( (head + body_hash).encode("utf-8")).hexdigest() if row.get("id") is not None: row_ids.append(row["id"]) return {"head": head, "row_ids": row_ids, "body_hashes": body_hashes} def verify_signature(evidence_bytes, signature, verifier=None): """签名验证器：可注入接口，fail-closed。 参数： - evidence_bytes: bytes（或 str，按 UTF-8 编码）；其它类型 抛 TypeError（这是调用方编程错误，不是“验签失败”）。 - signature: 调用方出示的签名（bytes/str 或其它验证器能 接受的形式）；为 None 或空 bytes/str 即缺失。 - verifier: 调用方注入的可调用对象，签名 verifier(evidence_bytes: bytes, signature) -> bool。 生产验证器由运营方在密钥供给到位后注入，本模块不提供、 不默认、不从 env/文件读任何验证器或密钥。 返回 {"verified": bool, "reason": str}，reason 取值： "verified"（验证器返回真）、"verifier_rejected"（返回假）、 "no_verifier"（未注入验证器）、"missing_signature" （签名缺失）、"verifier_error"（验证器抛异常，fail-closed）。 默认无验证器时 verified=False，绝不默认 True。 """ if not isinstance(evidence_bytes, (bytes, str)): raise TypeError("evidence_bytes must be bytes or str") if verifier is None: return {"verified": False, "reason": "no_verifier"} if not callable(verifier): raise TypeError("verifier must be callable or None") if signature is None: return {"verified": False, "reason": "missing_signature"} if isinstance(signature, (bytes, str)) and len(signature) == 0: return {"verified": False, "reason": "missing_signature"} payload = (evidence_bytes if isinstance(evidence_bytes, bytes) else evidence_bytes.encode("utf-8")) try: result = verifier(payload, signature) except Exception: return {"verified": False, "reason": "verifier_error"} if result: return {"verified": True, "reason": "verified"} return {"verified": False, "reason": "verifier_rejected"} # --------------------------------------------------------------------------- # 三张表拆分（v7 机制第 2 项；仅评分卡输入结构拆分，不代表产品功能落地） # # 维分配（写死，不按调用方喜好重分；理由见各表注释）： # - 代码表 CODE_DIMENSION_IDS：delivery_quality、gate_audit、 # arch_contract、test_coverage。证据全部来自代码侧：交付指标、 # 门禁/审计、架构契约、测试覆盖——本地/代码审计即可验证， # 不需要生产部署、真实 App、第二主机或用户侧拍板。 # - 生产表 PRODUCTION_DIMENSION_IDS：security_ledger、cost_quota、 # ops_scale。证据只在生产侧存在：分支保护与账本可信、 # 成本/配额真实记录与硬切断、CI/部署/回滚/HA/规模。 # 生产证据缺失时该表维记 None、总体 not_pass，绝不拉低代码表。 # - 产品表 PRODUCT_DIMENSION_IDS：沿用全部 7 维，但加一道真实 # 产品轮门禁（见 build_product_scorecard）。产品不是第 8 维， # 也不是新指标：产品表 = “在真实产品轮里复测同一 7 维”。 # 没有真实产品轮证据时，产品表全部维记 None、总体 not_pass， # 绝不把代码表/生产表的分数冒充成产品分数，也绝不声称 # 产品功能已落地。 # # 独立性规则（与 build_scorecard 的旧规则一致，各表各自独立）： # - 每张表各自 overall 独立：本表全部维 >=9 才 pass，任一维 # <9 或 None 即 not_pass；average_score 只作参考，绝不作达标依据。 # - 代码表不含生产项：生产证据缺失、B/C 用户侧项 pending， # 都不影响代码表的 overall（生产表才被挡住）。 # - 生产表与第 7 项 user_side_items 的配合是可选参数，不依赖 # 第 7 项的代码：调用方不传 user_side_items 时只按生产证据计分； # 传了且其中有 pending 项时，生产表 overall 被强制 not_pass # （维分数照常展示，不篡改），并在 missing_items 里逐项列出。 # - 阈值：三张表共用 DEFAULT_THRESHOLDS，默认值一律 # source="test_default_unapproved"，未拍板；生产阈值须用户 # 拍板后由调用方显式传入 user_approved 阈值。 # --------------------------------------------------------------------------- CODE_DIMENSION_IDS = [ "delivery_quality", "gate_audit", "arch_contract", "test_coverage", ] PRODUCTION_DIMENSION_IDS = [ "security_ledger", "cost_quota", "ops_scale", ] PRODUCT_DIMENSION_IDS = list(DIMENSION_IDS) USER_SIDE_DONE_STATUSES = { "done", "approved", "complete", "resolved", "user_approved", } PRODUCT_ROUND_REQUIRED_FIELDS = ( "real_product_round", "real_app_installed", "real_user_flow_verified", "product_round_as_of", ) def _build_table(dim_ids, evidence, th): """按给定维子集算一张表（纯函数；overall 与平均分规则同旧卡）。""" evidence = evidence or {} dimensions = [] missing_all, untested_all = [], [] for dim_id in dim_ids: result = _SCORERS[dim_id](evidence.get(dim_id) or {}, th) dimensions.append(result) missing_all.extend("%s: %s" % (dim_id, m) for m in result["missing_items"]) untested_all.extend("%s: %s" % (dim_id, u) for u in result["untested_items"]) scores = [d["score"] for d in dimensions if d["score"] is not None] average = _round1(sum(scores) / len(scores)) if scores else None # 钉死：平均分绝不能作为达标依据（各表各自独立判断）。 overall_pass = all(d["score"] is not None and d["score"] >= PASS_SCORE for d in dimensions) overall = "pass" if overall_pass else "not_pass" return { "dimensions": dimensions, "average_score": average, "average_is_not_pass_criterion": True, "overall": overall, "overall_pass": overall_pass, "pass_score": PASS_SCORE, "missing_items": missing_all, "untested_items": untested_all, "thresholds_source": thresholds_source(th), "thresholds": _effective_thresholds(th), } def check_baseline_stale(scorecard, current_main_head): """判定一张旧评分卡是否因 main 推进而失效（基线漂移门禁）。 参数全部由调用方传入：scorecard 是 build_scorecard 的输出 dict， current_main_head 是调用方当前确认的 main 头。本函数不在生产 代码里探测版本控制状态，也不读版本控制目录。 返回 dict（调用方凭 stale / usable_as_pass_basis 判断，绝不能 只看旧卡的 overall / overall_pass）： - stale=True 时：旧分不得再作 pass 依据 （usable_as_pass_basis=False、overall_usable_as_pass_basis=False、 overall_must_not_be_used_as_pass_basis=True），即使旧卡的 overall 本身仍是 "pass"——旧值保留只为追溯，不代表现分有效。 - stale 的三种情形：baseline_head 缺失（无法证明新鲜，失败关闭， 不编造为一致）；current_main_head 缺失（无法核对，失败关闭）； 两者均有值但不相等（main 已推进，旧分过期）。 - 仅当两者均有值且相等时 stale=False，旧分仍可按原 overall 读。 """ scorecard = scorecard or {} baseline = scorecard.get("baseline_head") if baseline is not None and baseline == "": baseline = None if current_main_head is not None and current_main_head == "": current_main_head = None if baseline is None: reason = ("baseline_head_missing: scorecard carries no frozen " "baseline_head, freshness cannot be proven") stale = True elif current_main_head is None: reason = ("current_main_head_missing: caller supplied no current " "main head, drift cannot be checked") stale = True elif current_main_head != baseline: reason = ("baseline_head_drifted: baseline_head=%s " "current_main_head=%s" % (baseline, current_main_head)) stale = True else: reason = "baseline_head_matches_current_main_head" stale = False return { "stale": stale, "baseline_head": baseline, "current_main_head": current_main_head, "reason": reason, "usable_as_pass_basis": not stale, "overall_usable_as_pass_basis": not stale, "overall_must_not_be_used_as_pass_basis": stale, } def build_code_scorecard(evidence, thresholds=None): """代码表：仅 delivery_quality、gate_audit、arch_contract、test_coverage。 不含任何生产项；生产证据缺失、用户侧 B/C 项 pending 都不影响 本表 overall。本表全部 4 维 >=9 才 pass。 """ return _build_table(CODE_DIMENSION_IDS, evidence, thresholds or {}) def _normalize_user_side_items(user_side_items): """把 user_side_items 占位证据归一化为 [{"id":..., "status":...}]。 接受：None（= 未提供，不臆断 pending）、dict{id: status}、 list[dict{id, status}]、list[str]（字符串只有 id、无状态， 按 pending 计——状态未知绝不算 done）。 """ if user_side_items is None: return [] if isinstance(user_side_items, dict): return [{"id": k, "status": v} for k, v in user_side_items.items()] normalized = [] for item in user_side_items: if isinstance(item, dict): normalized.append({"id": item.get("id"), "status": item.get("status")}) else: normalized.append({"id": item, "status": "pending"}) return normalized def build_production_scorecard(evidence, thresholds=None, user_side_items=None): """生产表：仅 security_ledger、cost_quota、ops_scale。 user_side_items 为可选占位证据（不依赖第 7 项的代码）： 不传时只按生产证据计分；传了且有 pending 项时，维分数照常 展示，但 overall 被强制 not_pass，并在 missing_items 里逐项 列出 pending 项。生产证据缺失本身已使本表 not_pass。 """ table = _build_table(PRODUCTION_DIMENSION_IDS, evidence, thresholds or {}) items = _normalize_user_side_items(user_side_items) pending = [it for it in items if it.get("status") not in USER_SIDE_DONE_STATUSES] table["user_side_items"] = items table["user_side_pending"] = pending table["user_side_blocked"] = bool(pending) if pending: table["missing_items"] = list(table["missing_items"]) + [ "user_side_items_pending: %s" % it.get("id") for it in pending] table["overall"] = "not_pass" table["overall_pass"] = False return table def build_product_scorecard(evidence, thresholds=None, product_evidence=None): """产品表：全部 7 维，但须先过真实产品轮门禁。 product_evidence 须同时满足：real_product_round、real_app_installed、 real_user_flow_verified 均为真，且 product_round_as_of 非空。 门禁不过时，全部维记 None（unknown）、总体 not_pass，绝不把 代码表/生产表分数冒充成产品分数；本函数不声称任何产品功能已落地。 门禁通过时，7 维按与 build_scorecard 相同的 scorer 计分。 """ product_evidence = product_evidence or {} missing_fields = [f for f in PRODUCT_ROUND_REQUIRED_FIELDS if not product_evidence.get(f)] if missing_fields: dimensions = [] missing_all = [] for dim_id in PRODUCT_DIMENSION_IDS: missing = ["product_round_evidence_missing: %s" % f for f in missing_fields] dimensions.append(_result(dim_id, None, [], missing, [])) missing_all.extend("%s: %s" % (dim_id, m) for m in missing) return { "dimensions": dimensions, "average_score": None, "average_is_not_pass_criterion": True, "overall": "not_pass", "overall_pass": False, "pass_score": PASS_SCORE, "missing_items": missing_all, "untested_items": [], "thresholds_source": _thresholds_source(thresholds or {}), "product_gate_passed": False, "product_round_missing_fields": missing_fields, } table = _build_table(PRODUCT_DIMENSION_IDS, evidence, thresholds or {}) table["product_gate_passed"] = True table["product_round"] = { "real_product_round": True, "real_app_installed": True, "real_user_flow_verified": True, "product_round_as_of": product_evidence.get("product_round_as_of"), } return table def build_scorecard(evidence, thresholds=None, rubric_version=None, baseline_head=None, evidence_rows=None, user_side_items=None, product_evidence=None): """算出 7 维评分卡。evidence 缺键按空证据处理（该维记 None）。 兼容：旧返回字段（dimensions/average_score/overall 等）语义不变， 仅新增 code/production/product 三个子对象（见三张表拆分注释）： code=build_code_scorecard，production=build_production_scorecard （user_side_items 可选占位），product=build_product_scorecard （无真实产品轮证据时恒为 not_pass）。新增键不改变旧字段的值。 另新增 rubric_version（见 cloud/scorecard_rubric.py）、 baseline_head（机器字段，见 check_baseline_stale）、 evidence_ledger_head 与 evidence_row_ids（见 compute_evidence_ledger）三个机制字段；无证据行时头为 None。 """ evidence = evidence or {} th = thresholds or {} if baseline_head is not None and baseline_head == "": baseline_head = None ledger = compute_evidence_ledger(evidence_rows) report = _build_table(DIMENSION_IDS, evidence, th) if baseline_head is None: report["missing_items"] = list(report["missing_items"]) + [ "baseline_head_missing"] report["baseline_head"] = baseline_head report["rubric_version"] = rubric_version report["evidence_ledger_head"] = ledger["head"] report["evidence_row_ids"] = ledger["row_ids"] report["thresholds"] = _effective_thresholds(th) report["code"] = build_code_scorecard(evidence, thresholds) raw_user_side = (user_side_items if user_side_items is not None else evidence.get("user_side_items")) report["production"] = build_production_scorecard( evidence, thresholds, raw_user_side) report["product"] = build_product_scorecard( evidence, thresholds, product_evidence) # v7 机制第 7 项三表规则（合一接线）：代码表结论绝不因用户侧 # pending 被拉低；用户侧未完成/非法/未知时顶层 # production_overall 强制 not_pass 且原因指向用户侧。注意： # 顶层 production_overall 是规则结论，report["production"] # 子对象仍是第 2 项的证据表（维分数照常展示），两者分工不同， # 顶层字段不回写子对象 overall，以免第 2 项的证据表语义被改。 rule = apply_user_side_three_table_rule( report["code"]["overall"], report["production"]["overall"], raw_user_side) report["user_side_items"] = rule["user_side_items"] report["code_overall"] = rule["code_overall"] report["production_overall"] = rule["production_overall"] report["production_reason"] = rule["production_reason"] report["user_side_unknown"] = rule["user_side_unknown"] report["code_unchanged_by_user_side"] = True report["user_side_forced_production_not_pass"] = ( rule["user_side_forced_production_not_pass"]) return report def example_scorecard_as_of_2026_10_31(): """2026-10-31 快照示例卡（历史示例，不是当前系统得分）。 证据是本函数 2026-10-31 落笔时记录的快照值（生产 v0.2、 main aebc623、覆盖率 0.7787 等），此后未重新实测；调用方 绝不能把它读成当前系统得分。要当前分数，须显式把新证据 传给 build_scorecard()。凡是只到 PR、未合并部署、未真实 验证的，在这里都记为未知或已知未强制，不估算、不写成 判断分。阈值仍为测试默认值 （source="test_default_unapproved"），未拍板。 总体结论必然是不达标。 本示例无冻结基线：build_scorecard 未传 baseline_head，故 baseline_head=None 且 missing_items 含 baseline_head_missing， 绝不编造一个头把它写成现分。 """ evidence = { "delivery_quality": { "first_pass_rate": None, "defect_rate": None, "rework_rate": None, "first_pass_known": False, "defect_known": False, "rework_known": False, "attempts_present": False, }, "gate_audit": { "hard_gate_enforced": False, "gate_items_passed": 0, "gate_items_total": 5, "merge_blocked_verified": False, "loop_end_to_end_verified": False, "sampling_misjudgment_rate": None, }, "arch_contract": { "contract_frozen": None, "arch_violations": None, "directory_violations": None, "import_violations": None, }, "test_coverage": { "prd_coverage_rate": None, "cross_matrix_coverage_rate": None, "coverage_pct": 0.7787, "cross_matrix_kind": "viewport_substitute", "real_pg": False, "real_service": False, "agent_six_complete": True, "lint_items": 109, "mypy_items": 0, "bandit_high": 4, }, "security_ledger": { "ledger_verify_ok": None, "ledger_coverage_rate": None, "branch_protection": "unknown", }, "cost_quota": { "cost_records_complete": False, "unpriced_as_zero": False, "per_creator_present": False, "quota_cutoff_verified": False, }, "ops_scale": { "ci_green_rate": None, "rollback_drill_done": False, "ha_status": "single_host_unaccepted", "parallel_scale_proven": 18, }, } report = build_scorecard(evidence) report["evidence_as_of"] = "2026-10-31" report["evidence_kind"] = "historical_example_snapshot" report["not_current_system_score"] = True return report