sino-bc-cli 1.0.0-beta.0

package/dist/skills/biz-line-strategy-generate/scripts/summarize.py

@@ -0,0 +1,932 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""按固定规则汇总分页临时文件，生成可直接校验及导出的 payload。
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+SCRIPTS = Path(__file__).resolve().parent
+if str(SCRIPTS) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS))
+
+from cli_json import BASE_METRICS, REPORT_METRICS, amount_change, evaluate_learning, metric_fields, metric_formula, learning_text
+from cli_json import (
+    bid_adjust_stats,
+    budget_abs_share,
+    cpm,
+    disp,
+    examples,
+    fmt_cpm,
+    metric_value,
+    optional_num,
+    core_rule,
+    rule_hit,
+    is_first_period,
+    is_ghost_enum,
+    load_json_file,
+    naming_patterns,
+    num,
+    short_label,
+    summarize_countries,
+    unwrap_page,
+)
+
+CH_LABEL = {"fb": "Meta", "gg": "Google", "tt": "TikTok"}
+# 第 1 层明细仍用消耗门槛；结论不再用 CPM≤5 当 KPI
+DETAIL_LIMIT = 8
+
+
+def iter_stem_rows(bl: Path, stem: str):
+    """按页 yield 行，不把全表拼成 list。可重复调用，每次重新读盘。"""
+    meta_path = bl / f"{stem}.pages.json"
+    if meta_path.exists():
+        meta = load_json_file(meta_path)
+        if not isinstance(meta, dict) or not isinstance(meta.get("counts"), list):
+            raise ValueError(f"拉数文件不完整：{stem}")
+        accumulated = 0
+        for index, expected in enumerate(meta["counts"], start=1):
+            env = load_json_file(bl / f"{stem}.p{index}.out.json")
+            page_rows, _ = unwrap_page(env or {})
+            if len(page_rows) != expected:
+                raise ValueError(f"拉数文件不完整：{stem}")
+            yield from page_rows
+            accumulated += len(page_rows)
+        if meta.get("total") != accumulated:
+            raise ValueError(f"拉数文件不完整：{stem}")
+        return
+    extras = [p for p in bl.glob(f"{stem}.p*.out.json") if p.name != f"{stem}.p1.out.json"]
+    if extras:
+        raise ValueError(f"拉数文件不完整：{stem}")
+    env = load_json_file(bl / f"{stem}.p1.out.json")
+    yield from unwrap_page(env or {})[0]
+
+
+def load_merged(bl: Path, stem: str) -> list:
+    """兼容测试与诊断：需要 list 时才物化。分析路径应走 iter_stem_rows。"""
+    return list(iter_stem_rows(bl, stem))
+
+
+def object_name_maps(rows, id_key, name_key) -> tuple[dict[str, str], dict[str, str]]:
+    """id → 明细展示名（空则回退 id），以及原始 display（空名不当作 id，避免分布在拆 ID）。"""
+    names: dict[str, str] = {}
+    raw: dict[str, str] = {}
+    for row in rows:
+        if row.get(id_key):
+            ident = str(row[id_key])
+            shown = disp(row, name_key)
+            raw[ident] = shown
+            names[ident] = shown or ident
+    return names, raw
+
+
+def labels_of(rows, key) -> set[str]:
+    return {disp(r, key) for r in rows if disp(r, key)}
+
+
+def share_map(rows, dim_key):
+    """一次扫描累加消耗占比，可接迭代器。"""
+    total = 0.0
+    acc = defaultdict(float)
+    for row in rows:
+        spend = num(row, "spend_usd")
+        total += spend
+        acc[disp(row, dim_key) or "未标注"] += spend
+    if total <= 0:
+        return {}, 0.0
+    return {k: v / total * 100 for k, v in acc.items()}, total
+
+
+def pct_pair(prev: float, curr: float) -> str:
+    return f"{prev:.1f}% → {curr:.1f}%"
+
+
+def fmt_share(curr: dict, prev: dict) -> str:
+    keys = [k for k in sorted(set(curr) | set(prev), key=lambda x: -curr.get(x, 0)) if k]
+    return "；".join(f"{k} {pct_pair(prev.get(k, 0), curr.get(k, 0))}" for k in keys[:8])
+
+
+def advice_of(verdict: str) -> str:
+    if verdict.startswith("待观察"):
+        return "建议：再观察一周"
+    if verdict == "有效":
+        return "建议：继续执行"
+    return "建议：复核策略"
+
+
+def share_moved(curr: dict, prev: dict) -> bool:
+    for lab in set(curr) | set(prev):
+        if abs(curr.get(lab, 0) - prev.get(lab, 0)) > 2:
+            return True
+    return False
+
+
+def bid_changes(rows, fields):
+    """逐个出价字段比较有效日快照，缺失值不补零；只保留日期与出价字段，可接迭代器。"""
+    by_ag = defaultdict(list)
+    names: dict[str, tuple[str, str]] = {}
+    strategies: dict[str, str] = {}
+    for row in rows:
+        ag = row.get("adgroup_id")
+        if not ag:
+            continue
+        ident = str(ag)
+        date_s = str(row.get("calendar_date") or "")
+        if ident not in names or date_s >= names[ident][0]:
+            names[ident] = (date_s, disp(row, "adgroup_name") or ident)
+            strategies[ident] = disp(row, "bid_strategy")
+        snap = {"calendar_date": str(row.get("calendar_date") or "")}
+        for field in fields:
+            snap[field] = optional_num(row, field)
+        by_ag[ident].append(snap)
+    result = []
+    for ag, records in by_ag.items():
+        records = sorted(records, key=lambda r: r["calendar_date"])
+        changes = []
+        changed_dates = set()
+        for field in fields:
+            valid = [(r["calendar_date"], r[field]) for r in records if r[field] is not None]
+            times = sum(a[1] != b[1] for a, b in zip(valid, valid[1:]))
+            changed_dates.update(b[0] for a, b in zip(valid, valid[1:]) if a[1] != b[1])
+            if times:
+                changes.append({"field": field, "from": valid[0][1], "to": valid[-1][1], "times": times})
+        if changes:
+            # 多字段变动以首个首末不同的字段展示方向，明细完整保留各字段。
+            primary = next((c for c in changes if c["from"] != c["to"]), changes[0])
+            result.append({"id": ag, "name": names[ag][1],
+                           **primary, "times": len(changed_dates), "fields": changes, "strategy": strategies[ag]})
+    return sorted(result, key=lambda r: (-r["times"], r["id"]))
+
+
+def new_items(curr_rows, prev_rows, key, id_key=None):
+    """按稳定 ID/维度值聚合基础指标，再识别新增的对象。只为新增对象保留行。"""
+    def identity(row):
+        return str(row.get(id_key) or "") if id_key else disp(row, key)
+    previous: dict[str, str] = {}
+    for row in prev_rows:
+        ident = identity(row)
+        if ident:
+            previous[ident] = disp(row, key) or ident
+    grouped = defaultdict(list)
+    current_ids: set[str] = set()
+    for row in curr_rows:
+        ident = identity(row)
+        if not ident:
+            continue
+        current_ids.add(ident)
+        if ident not in previous:
+            grouped[ident].append(row)
+    items = []
+    for ident, records in grouped.items():
+        items.append({"id": ident if id_key else "", "label": disp(records[0], key) or ident,
+                      "spend": sum(num(r, "spend_usd") for r in records), "rows": records,
+                      "cpi": metric_value(records), "cpm": metric_value(records, "CPM")})
+    stops = [label for ident, label in previous.items() if ident not in current_ids]
+    return items, stops
+
+
+def learning_sample_sufficient(spend):
+    """预算与新增枚举的 learning 样本仅要求本期消耗大于零。"""
+    return spend is not None and spend > 0
+
+
+def new_scope_learning(rule, rows, *, previous_total=None, has_previous=False):
+    """本期新增枚举对比上期业务线总体指标；样本门槛只取本期枚举自身。"""
+    spend = metric_value(rows, 'spend_usd')
+    sufficient = learning_sample_sufficient(spend)
+    return evaluate_learning(rule, metric_value(rows, rule.get('metric')), previous_total, has_previous, sufficient)
+
+
+def combine_scope_learning(rule, results):
+    """按新增维度合计消耗加权：有效占比严格超过70%；不跨维度去重。"""
+    if not rule.get('usable'):
+        return evaluate_learning(rule, None, None, False)
+    total = sum(spend for spend, _ in results if spend is not None)
+    if not results or any(spend is None or spend < 0 for spend, _ in results) or total <= 0:
+        return '待观察', learning_text('待观察')
+    # 十进制比较锁住70%边界，避免浮点累加让恰好70%被误判为超过。
+    from decimal import Decimal
+    total_d = sum((Decimal(str(spend)) for spend, _ in results), Decimal(0))
+    valid_d = sum((Decimal(str(spend)) for spend, result in results if result[0] == '有效'), Decimal(0))
+    if valid_d > total_d * Decimal('0.7'):
+        return '有效', learning_text('有效')
+    # 未达到有效占比且仍有不可判定枚举时，不把未知数据当成无效。
+    unsupported = next((result for _, result in results if '核心指标不支持' in result[1]), None)
+    if unsupported:
+        return unsupported
+    if any(result[0] == '待观察' for _, result in results):
+        return '待观察', learning_text('待观察')
+    return '无效', learning_text('无效')
+
+
+def learning_comparison(rule, current, previous, label):
+    """只展示标准化指标及计算值，不回显用户核心指标原文。"""
+    metric = rule.get('metric')
+    names = {'cost_per_complete_registration': '注册成本', 'cost_per_leads': '线索成本',
+             'cost_per_purchase': '购买成本', 'average_purchase_value': '客单价'}
+    report_names = {code: label for code, label, _is_percent in REPORT_METRICS}
+    name = names.get(metric, report_names.get(metric, BASE_METRICS.get(metric, (metric,))[0]))
+    formula = metric_formula(metric)
+    suffix = '%' if formula and formula[2] == 100 else ''
+    def value(number):
+        return '数据不足' if number is None else f'{number:.2f}{suffix}'
+    change = '不可计算' if current is None or previous in (None, 0) else f'{(current - previous) / previous * 100:+.2f}%'
+    return f'{label}{name} 本期 {value(current)}，上期总体 {value(previous)}，环比 {change}'
+
+
+def describe_learning(text, rule, comparisons):
+    """结论仍由原规则产出，说明补充维度合计、标准化阈值和行动建议。"""
+    verdict = text.split('\n', 1)[0].removeprefix('结论：')
+    advice = {'有效': '建议继续执行', '无效': '建议关停', '待观察': '建议再观察一周'}[verdict]
+    details = []
+    if rule.get('usable'):
+        details.extend(comparisons)
+        if rule.get('target') is not None:
+            formula = metric_formula(rule['metric'])
+            suffix = '%' if formula and formula[2] == 100 else ''
+            target = f"KPI目标 {rule['op']} {rule['target']:g}{suffix}"
+            if details:
+                details[-1] += '；' + target
+            else:
+                details.append(target)
+    # 每个维度的指标明细独占一行，目标和建议接在最后一行。
+    return text + ('\n' + '\n'.join(details) if details else '') + '；' + advice
+
+
+def dim_layer_text(title: str, items: list, stop_labs: list, rule=None):
+    """新增值自身先合计再算指标，不使用默认 CPM 目标或伪造达标占比。"""
+    rule = rule or core_rule("")
+    metric = rule["metric"]
+    if not items and not stop_labs:
+        return f"{title}\n本期无新增。", None, 0.0, 0.0
+    lines = [title]
+    # 零消耗项没有可判定成效；正消耗的新增项不设金额下限。
+    usable = [it for it in items if it["spend"] > 0]
+    for it in usable[:DETAIL_LIMIT]:
+        value = metric_value(it.get("rows", []), metric)
+        hit = rule_hit(value, rule)
+        verdict = "不可判定" if hit is None else ("达标" if hit else "未达标")
+        lines.append(f"· 新增「{short_label(it['label'])}」{metric or '核心指标'} {fmt_cpm(value)}，KPI {verdict}（${it['spend']:.0f}）")
+    if len(usable) > DETAIL_LIMIT:
+        lines.append(f"· 另有 {len(usable) - DETAIL_LIMIT} 个新增未展开，见明细")
+    if len(items) > len(usable):
+        lines.append(f"· 另有 {len(items) - len(usable)} 个零消耗新增未纳入成效汇总")
+    if stop_labs:
+        lines.append(f"· 暂停 {len(stop_labs)} 个：{examples(stop_labs)}")
+    records = [r for it in usable for r in it.get("rows", [])]
+    value = metric_value(records, metric)
+    hit = rule_hit(value, rule)
+    lines.append(f"· 合计（新增）{metric or '核心指标'} {fmt_cpm(value)}；仅观察同期表现，不推断动作因果")
+    return "\n".join(lines), hit, sum(it["spend"] for it in usable if rule_hit(metric_value(it.get("rows", []), metric), rule)), sum(it["spend"] for it in usable)
+
+
+def action_summary(action, names, *, distribution=False, total=None, raw_names=None):
+    """新增/暂停分别按五个边界展示完整名称；大批对象只展示名称分布。"""
+    names = list(names)
+    count = len(names)
+    text = f'{action} {count} 个'
+    if not count:
+        return ''
+    if (count if total is None else total) <= 5:
+        return text + '：' + '、'.join(names)
+    if distribution:
+        return text + '，分布在：' + naming_patterns(raw_names if raw_names is not None else names)
+    return text
+
+
+def setting_line(title, curr_set, prev_set, first_period=False, *, show_names=True) -> str:
+    """新增和暂停独立判断数量，小集合在策略中列名称，明细仍保留全量。"""
+    if first_period:
+        return f'{title}\n当期 {len(curr_set)} 个'
+    # 关键词通常是长文本，主表始终只给数量，完整内容由明细承载。
+    parts = []
+    for action, values in (('新增', curr_set - prev_set), ('暂停', prev_set - curr_set)):
+        if values:
+            parts.append(action_summary(action, sorted(values)) if show_names else f'{action} {len(values)} 个')
+    return title + '\n' + ('；'.join(parts) or '未出现变化')
+
+
+def ad_keywords(names, n=3):
+    skip = {"ios", "and", "android", "fb", "tt", "gg", "bid", "cap", "all"}
+    seen = []
+    for name in names:
+        for tok in name.replace("_", "-").split("-"):
+            tok = tok.strip()
+            if tok and not tok.isdigit() and len(tok) >= 2 and tok.lower() not in skip and tok not in seen:
+                seen.append(tok)
+            if len(seen) >= n:
+                return seen
+    return seen
+
+
+def detail_metric_text(rows, code, is_percent):
+    """先合计基础字段再求衍生指标；缺字段或零分母都显示缺值。"""
+    value = metric_value(rows, code)
+    if value is None:
+        return '-'
+    if is_percent:
+        return f'{value:,.2f}%'
+    if code in ('spend_usd', 'purchase_value') or metric_formula(code):
+        return f'{value:,.2f}'
+    return f'{value:,.0f}' if value.is_integer() else f'{value:,.2f}'
+
+
+def detail_metric_cells(current_rows, previous_rows, current_conflicts=(), previous_conflicts=()):
+    """本期数值在前；存在可计算的上期值时把上期数值放入同一单元格。"""
+    cells = {}
+    current_conflicts, previous_conflicts = set(current_conflicts), set(previous_conflicts)
+    for code, _label, is_percent in REPORT_METRICS:
+        required = metric_fields(code)
+        current = '-' if required & current_conflicts else detail_metric_text(current_rows, code, is_percent)
+        previous = '-' if required & previous_conflicts else detail_metric_text(previous_rows, code, is_percent)
+        cells[code] = current + (f'（上期：{previous}）' if previous != '-' else '')
+    return cells
+
+
+def detail_conflicts(bl: Path, stem: str):
+    """接口明确拒绝的基础字段在明细中视为缺值，避免把占位零误报成真实成效。"""
+    meta = load_json_file(bl / f'{stem}.pages.json') or {}
+    return set(meta.get('conflictField') or [])
+
+
+def add_detail_metric_row(total, row):
+    """分页行逐条累加 12 个基础字段；任一缺值保持缺失而非补零。"""
+    if not total:
+        total.update({field: optional_num(row, field) for field in BASE_METRICS})
+        return
+    for field in BASE_METRICS:
+        value = optional_num(row, field)
+        total[field] = total[field] + value if total[field] is not None and value is not None else None
+
+
+def build_dimension_details(bl: Path, active_channels, bids):
+    """明细只按真实维度值出行；同一渠道、维度、ID 的按日成效先聚合。"""
+    dimensions = [
+        ('广告目标', 'objective', ('fb', 'tt'), None),
+        ('广告系列类型', 'advertising_channel_type', ('gg',), None),
+        ('成效目标', 'optimization_goal', tuple(CH_LABEL), None),
+        ('出价方式', 'bid_strategy', tuple(CH_LABEL), None),
+        ('国家', 'country_code', tuple(CH_LABEL), None),
+        ('兴趣词包', 'targeting_interests', ('fb', 'tt'), None),
+        ('受众类型', 'audience_type', tuple(CH_LABEL), None),
+        ('关键词', 'keywords', ('gg',), None),
+        ('年龄', 'targeting_age', tuple(CH_LABEL), None),
+        ('性别', 'targeting_genders', tuple(CH_LABEL), None),
+        ('广告组', 'adgroup_id+adgroup_name', tuple(CH_LABEL), 'adgroup_id'),
+        ('广告', 'ad_id+ad_name', tuple(CH_LABEL), 'ad_id'),
+        ('创意类型', 'ad_format', tuple(CH_LABEL), None),
+    ]
+    details = []
+    # 预算按渠道列成效；渠道编码就是此枚举的稳定 ID。
+    for ch in active_channels:
+        totals = {'curr': {}, 'prev': {}}
+        conflicts = {}
+        for period in totals:
+            stem = f'met_{ch}_{period}_account_id'
+            conflicts[period] = detail_conflicts(bl, stem)
+            for row in iter_stem_rows(bl, stem):
+                add_detail_metric_row(totals[period], row)
+        details.append({'kind': '预算', 'action': '持续' if totals['prev'] else '新增',
+                        'channel': CH_LABEL[ch], 'id': ch, 'name': CH_LABEL[ch],
+                        **detail_metric_cells([totals['curr']] if totals['curr'] else [],
+                                              [totals['prev']] if totals['prev'] else [],
+                                              conflicts['curr'], conflicts['prev']), 'extra': ''})
+
+    for kind, stem, channels, id_key in dimensions:
+        key = stem.split('+')[-1] if id_key else stem
+        for ch in (channel for channel in channels if channel in active_channels):
+            names = {'curr': {}, 'prev': {}}
+            values = {'curr': defaultdict(dict), 'prev': defaultdict(dict)}
+            conflicts = {}
+            for period in ('curr', 'prev'):
+                # Meta 兴趣设置接口有三个字段，成效接口只按 targeting_interests 查询。
+                snapshot = ('targeting_interests+targeting_flexible_interests+targeting_exclusion_interests'
+                            if ch == 'fb' and kind == '兴趣词包' else stem)
+                fields = snapshot.split('+') if kind == '兴趣词包' and ch == 'fb' else [key]
+                for row in iter_stem_rows(bl, f'dim_{ch}_{period}_{snapshot}'):
+                    for field in fields:
+                        raw = row.get(id_key or field)
+                        ident = '' if raw is None else str(raw).strip()
+                        if ident:
+                            names[period][ident] = disp(row, 'adgroup_name' if kind == '广告组' else
+                                                        'ad_name' if kind == '广告' else field) or ident
+                metric_stem = f'met_{ch}_{period}_{stem}'
+                conflicts[period] = detail_conflicts(bl, metric_stem)
+                for row in iter_stem_rows(bl, metric_stem):
+                    raw = row.get(id_key or key)
+                    ident = '' if raw is None else str(raw).strip()
+                    if ident:
+                        add_detail_metric_row(values[period][ident], row)
+                        names[period].setdefault(ident, disp(row, key) or ident)
+            for ident in sorted(set(names['curr']) | set(names['prev'])):
+                action = ('持续' if ident in names['curr'] and ident in names['prev'] else
+                          '新增' if ident in names['curr'] else '暂停')
+                details.append({'kind': kind, 'action': action, 'channel': CH_LABEL[ch],
+                                'id': ident, 'name': names['curr'].get(ident) or names['prev'][ident],
+                                **detail_metric_cells([values['curr'][ident]] if values['curr'][ident] else [],
+                                                      [values['prev'][ident]] if values['prev'][ident] else [],
+                                                      conflicts['curr'], conflicts['prev']),
+                                'extra': ''})
+
+    # 出价沿用既有上调/下调/持平动作；金额取广告组同 ID 的成效，补充只列首末出价。
+    for ch in active_channels:
+        ids = {str(item['id']) for item in bids[ch]}
+        values = {'curr': defaultdict(dict), 'prev': defaultdict(dict)}
+        conflicts = {}
+        for period in ('curr', 'prev'):
+            metric_stem = f'met_{ch}_{period}_adgroup_id+adgroup_name'
+            conflicts[period] = detail_conflicts(bl, metric_stem)
+            for row in iter_stem_rows(bl, metric_stem):
+                raw = row.get('adgroup_id')
+                ident = '' if raw is None else str(raw)
+                if ident in ids:
+                    add_detail_metric_row(values[period][ident], row)
+        for item in bids[ch]:
+            ident = str(item['id'])
+            start, end = float(item.get('from') or 0), float(item.get('to') or 0)
+            action = item.get('action') or ('上调' if end > start else '下调' if end < start else '期内变化但首末持平')
+            changes = '；'.join(f"{field['field']} {field['from']:g} → {field['to']:g}"
+                               for field in item.get('fields', []))
+            details.append({'kind': '出价', 'action': action, 'channel': CH_LABEL[ch],
+                            'id': ident, 'name': item.get('name') or ident,
+                            **detail_metric_cells([values['curr'][ident]] if values['curr'][ident] else [],
+                                                  [values['prev'][ident]] if values['prev'][ident] else [],
+                                                  conflicts['curr'], conflicts['prev']),
+                            'extra': changes})
+    return details
+
+
+def summarize_request(req: Path):
+    """仅使用本次通过分页校验的文件，固定生成摘要和完整明细。"""
+    from strategy_output import effect_code
+    biz = load_json_file(req / "biz-line.json") or {}
+    detail = load_json_file(req / "biz-line-detail.out.json") or {}
+    detail_data = detail.get("data") if isinstance(detail.get("data"), dict) else {}
+    projects = load_json_file(req / "projects.json") or {}
+    # 渠道范围以本次解析后的账号为准（包含用户覆盖），不能按消耗是否为零判断。
+    active_channels = [ch for ch in CH_LABEL if projects.get("accounts", {}).get(ch)]
+    if not active_channels:
+        raise ValueError("缺少有效广告账号渠道，请通过统一入口重新拉取数据")
+    biz_id = biz.get("id") or detail_data.get("id")
+    bl = req / f"bl-{biz_id}"
+    manifest = load_json_file(req / 'fetch-manifest.json')
+    if manifest is not None:
+        for stem, count in manifest.items():
+            meta = load_json_file(bl / f"{stem}.pages.json")
+            if (
+                not isinstance(meta, dict)
+                or meta.get("total") != count
+                or not isinstance(meta.get("counts"), list)
+                or sum(meta["counts"]) != count
+            ):
+                raise ValueError(f"拉数文件不完整：{stem}")
+    group = detail_data.get("ssoTeamCodeName") or biz.get("ssoTeamCodeName") or ""
+    name = detail_data.get("name") or biz.get("name") or ""
+    project = "\n".join(projects.get("projectNames") or detail_data.get("projectNames") or [])
+    periods = load_json_file(req / "periods.json") or {}
+    curr = periods.get("curr") or []
+    prev = periods.get("prev") or []
+    if len(curr) == 2 and len(prev) == 2:
+        period = f"本期：{curr[0]}～{curr[1]}\n上期：{prev[0]}～{prev[1]}"
+    else:
+        # 缺少请求周期时不能以业务线周期冒充本次分析范围。
+        raise ValueError('缺少有效 periods.json，请通过统一入口重新拉取数据')
+
+    spend = {"curr": {}, "prev": {}}
+    imps = {"curr": {}, "prev": {}}
+    inst = {"curr": {}, "prev": {}}
+    days = {"curr": {}, "prev": {}}
+    coverage_dates = {"curr": {}, "prev": {}}
+    for ch in active_channels:
+        for per in ("curr", "prev"):
+            day_spend = day_imps = day_inst = 0.0
+            dates_all: set[str] = set()
+            dates_spend: set[str] = set()
+            for row in iter_stem_rows(bl, f"met_{ch}_{per}_calendar_date"):
+                day_spend += num(row, "spend_usd")
+                day_imps += num(row, "impressions")
+                day_inst += num(row, "installs")
+                raw = row.get("calendar_date")
+                if raw:
+                    dates_all.add(str(raw)[:10])
+                if num(row, "spend_usd") > 0:
+                    dates_spend.add(disp(row, "calendar_date") or str(raw or ""))
+            acc_spend = acc_imps = acc_inst = 0.0
+            has_acc = False
+            for row in iter_stem_rows(bl, f"met_{ch}_{per}_account_id"):
+                has_acc = True
+                acc_spend += num(row, "spend_usd")
+                acc_imps += num(row, "impressions")
+                acc_inst += num(row, "installs")
+            spend[per][ch] = acc_spend if has_acc else day_spend
+            imps[per][ch] = acc_imps if has_acc else day_imps
+            inst[per][ch] = acc_inst if has_acc else day_inst
+            days[per][ch] = len(dates_spend)
+            coverage_dates[per][ch] = dates_all
+
+    curr_total = sum(spend["curr"].values())
+    prev_total = sum(spend["prev"].values())
+    curr_inst = sum(inst["curr"].values())
+    prev_inst = sum(inst["prev"].values())
+    curr_share = {ch: (spend["curr"][ch] / curr_total * 100 if curr_total else 0) for ch in spend["curr"]}
+    prev_share = {ch: (spend["prev"][ch] / prev_total * 100 if prev_total else 0) for ch in spend["prev"]}
+    overall_c = cpm(curr_total, sum(imps["curr"].values()))
+    overall_p = cpm(prev_total, sum(imps["prev"].values()))
+    cpi_c = (curr_total / curr_inst) if curr_inst else None
+    cpi_p = (prev_total / prev_inst) if prev_inst else None
+    eff_days = max(days["curr"].values() or [0])
+    first_period = not (len(prev) == 2 and all(prev))
+    core_index = str(biz.get("coreIndex") or detail_data.get("coreIndex") or "").strip()
+    settings = load_json_file(req / 'analysis-settings.json') or {}
+    if settings.get('bizLineId') == biz_id and 'coreIndex' in settings:
+        core_index = str(settings['coreIndex']).strip()
+    rule = core_rule(core_index)
+    metric = rule["metric"]
+    # 任一请求渠道明确不支持所需字段时，不拿其余渠道局部数据代表整条业务线。
+    for ch in active_channels:
+        for per in ('curr', 'prev'):
+            meta = load_json_file(bl / f'met_{ch}_{per}_account_id.pages.json') or {}
+            if metric_fields(metric) & set(meta.get('conflictField', [])):
+                rule = {**rule, 'usable': False, 'reason': '核心指标不支持'}
+    def iter_account_rows(per: str):
+        for ch in active_channels:
+            yield from iter_stem_rows(bl, f"met_{ch}_{per}_account_id")
+
+    core_c, core_p = (metric_value(iter_account_rows(per), metric) for per in ("curr", "prev"))
+    cpi_c, cpi_p = (metric_value(iter_account_rows(per), "CPI") for per in ("curr", "prev"))
+    # 是否存在上期记录由实际回包决定，不以周期参数或消耗是否为零代替。
+    has_previous = any(True for _ in iter_account_rows('prev'))
+    # 核心指标可计算性单独判断；样本门槛只检查本期总体正消耗。
+    sample_sufficient = learning_sample_sufficient(curr_total)
+    spend_verdict, budget_learning = evaluate_learning(rule, core_c, core_p, has_previous, sample_sufficient)
+    budget_learning = describe_learning(budget_learning, rule, [learning_comparison(rule, core_c, core_p, '')])
+    coverage_notes = []
+    from datetime import date, timedelta
+    for per, bounds in (("curr", periods.get("curr")), ("prev", periods.get("prev"))):
+        if not bounds or not all(bounds):
+            continue
+        start, end = (date.fromisoformat(d) for d in bounds)
+        expected = {(start + timedelta(days=i)).isoformat() for i in range((end - start).days + 1)}
+        for ch, accounts in projects.get("accounts", {}).items():
+            if not accounts:
+                continue
+            dates = sorted(coverage_dates[per].get(ch) or set())
+            missing = expected - set(dates)
+            label = "本期" if per == "curr" else "上期"
+            coverage_notes.append(f"{CH_LABEL[ch]}{label}实际覆盖 {dates[0] if dates else '-'}～{dates[-1] if dates else '-'}，{len(dates)}天/{len(expected)}天" + ("（覆盖不完整）" if missing else ""))
+    period += "\n" + "\n".join(coverage_notes)
+    if any("覆盖不完整" in n for n in coverage_notes):
+        period += "\n周期覆盖不完整，消耗减少不能直接解释为主动减预算"
+
+
+    bid_fields = {
+        "fb": ["bid_amount"],
+        "gg": ["cpc_bid_amount", "cpm_bid_amount", "cpv_bid_amount"],
+        "tt": ["bid_amount", "conversion_bid", "deep_cpabid"],
+    }
+    bid_stems = {
+        "fb": "dim_fb_curr_calendar_date+adgroup_id+adgroup_name+bid_amount",
+        "gg": "dim_gg_curr_calendar_date+adgroup_id+adgroup_name+cpc_bid_amount",
+        "tt": "dim_tt_curr_calendar_date+adgroup_id+adgroup_name+bid_amount",
+    }
+    bids = {ch: bid_changes(iter_stem_rows(bl, bid_stems[ch]), bid_fields[ch]) for ch in active_channels}
+    bid_stats = {ch: bid_adjust_stats(bids[ch]) for ch in bids}
+
+    def bid_text(ch):
+        items = bids[ch]
+        stats = bid_stats[ch]
+        label = CH_LABEL[ch]
+        if not items:
+            return f"{label}：本期未发生明显出价调整"
+        # 正文只保留调价汇总，广告组名称及逐组调价值继续保留在明细。
+        parts = [f'{action} {stats[field]} 个广告组' for action, field in
+                 [('上调', 'raise_n'), ('下调', 'lower_n'), ('期内变化但首末持平', 'flat_n')] if stats[field]]
+        return label + '：' + '；'.join(parts) + f"；幅度中位数 {stats['median_abs']:.2f}"
+
+    budget_strategy = "\n".join(
+        [
+            "【调整出价】",
+            f"合计 {sum(len(items) for items in bids.values())} 个广告组调整出价",
+            *[bid_text(ch) for ch in active_channels],
+            "",
+            "【预算】",
+            f"消耗合计：本期 ${curr_total:,.0f} / 上期 ${prev_total:,.0f}；{amount_change(curr_total, prev_total)}",
+            *[budget_abs_share(
+                CH_LABEL[ch],
+                prev_abs=spend["prev"][ch], curr_abs=spend["curr"][ch],
+                prev_share=prev_share[ch], curr_share=curr_share[ch],
+            ) for ch in active_channels],
+        ]
+    )
+
+    share_notes = {}
+    def share_line(title, dim_key, stem, channels):
+        """占比同时展示对应消耗；主表汇总前三类，其余合并，明细保留全量。"""
+        segs, moved = [], False
+        for ch in (ch for ch in channels if ch in active_channels):
+            current, current_total = share_map(iter_stem_rows(bl, f'met_{ch}_curr_{stem}'), dim_key)
+            previous, previous_total = share_map(iter_stem_rows(bl, f'met_{ch}_prev_{stem}'), dim_key)
+            moved = moved or share_moved(current, previous)
+            keys = [key for key in sorted(set(current) | set(previous), key=lambda key: (-current.get(key, 0), key))
+                    if not is_ghost_enum(current.get(key, 0), previous.get(key, 0))]
+            def aggregate_line(label, members):
+                cp, pp = sum(current.get(k, 0) for k in members), sum(previous.get(k, 0) for k in members)
+                ca, pa = cp * current_total / 100, pp * previous_total / 100
+                share = '' if round(pp, 1) == round(cp, 1) == 100 else f'，占比 {pp:.1f}% → {cp:.1f}%'
+                return f'{label}：消耗 ${pa:,.0f} → ${ca:,.0f}；{amount_change(ca, pa)}{share}'
+            parts = [aggregate_line(key, [key]) for key in keys[:3]]
+            if len(keys) > 3:
+                parts.append(aggregate_line('其余类别合计', keys[3:]))
+            if parts:
+                # 占比分布维度同样补充新增/暂停名称；零占比残留不算发生动作。
+                current_labels = {key for key in keys if current.get(key, 0) > 0}
+                previous_labels = {key for key in keys if previous.get(key, 0) > 0}
+                if not first_period:
+                    changes = [action_summary('新增', sorted(current_labels - previous_labels)),
+                               action_summary('暂停', sorted(previous_labels - current_labels))]
+                    parts.insert(0, '；'.join(filter(None, changes)) or '未出现变化')
+                segs.append(CH_LABEL[ch] + '：\n' + '\n'.join(parts))
+                # 每类总结抓住实际占比变化最大的枚举，不凭空解释业务意图。
+                changed = sorted(keys, key=lambda k: -abs(current.get(k, 0) - previous.get(k, 0)))
+                if changed and abs(current.get(changed[0], 0) - previous.get(changed[0], 0)) > 0.2:
+                    k = changed[0]
+                    share_notes.setdefault(title, []).append(f'{CH_LABEL[ch]}{k}占比由{previous.get(k, 0):.1f}%变为{current.get(k, 0):.1f}%')
+        return ('\n'.join([title] + segs) if segs else ''), moved
+
+    p_obj, m1 = share_line("【广告目标】", "objective", "objective", ["fb", "tt"])
+    p_ch, m2 = share_line("【广告系列类型】", "advertising_channel_type", "advertising_channel_type", ["gg"])
+    p_opt, m3 = share_line("【成效目标】", "optimization_goal", "optimization_goal", ["fb", "gg", "tt"])
+    p_bid, m4 = share_line("【出价方式】", "bid_strategy", "bid_strategy", ["fb", "gg", "tt"])
+    product_strategy = "\n".join(x for x in [p_obj, p_ch, p_opt, p_bid] if x) or '本期无可识别的广告产品策略数据'
+    product_share_moved = any([m1, m2, m3, m4])
+
+    def dim_sets(stem, key, channels):
+        curr = set()
+        prev = set()
+        for ch in (ch for ch in channels if ch in active_channels):
+            # Meta 兴趣的三个配置字段来自同一组合请求，不能找不存在的单字段文件。
+            if ch == 'fb' and stem == 'targeting_interests':
+                combined = 'targeting_interests+targeting_flexible_interests+targeting_exclusion_interests'
+                fields = combined.split('+')
+                for target, per in ((curr, 'curr'), (prev, 'prev')):
+                    for row in iter_stem_rows(bl, f'dim_{ch}_{per}_{combined}'):
+                        for field in fields:
+                            lab = disp(row, field)
+                            if lab:
+                                target.add(lab)
+                continue
+            curr |= labels_of(iter_stem_rows(bl, f"dim_{ch}_curr_{stem}"), key)
+            prev |= labels_of(iter_stem_rows(bl, f"dim_{ch}_prev_{stem}"), key)
+        return curr, prev
+
+    country_curr, country_prev = dim_sets("country_code", "country_code", ["fb", "gg", "tt"])
+    interest_curr, interest_prev = dim_sets("targeting_interests", "targeting_interests", ["fb", "tt"])
+    kw_curr, kw_prev = dim_sets("keywords", "keywords", ["gg"])
+
+    object_notes = {}
+    def object_strategy(kind, id_key, name_key):
+        bits = []
+        total_new = total_absent = 0
+        action_amounts = {'新增': [], '暂停': []}
+        groups = []
+        for ch in active_channels:
+            stem = f"{id_key}+{name_key}"
+
+            def index_objects(period: str) -> tuple[dict[str, str], dict[str, str]]:
+                return object_name_maps(iter_stem_rows(bl, f"dim_{ch}_{period}_{stem}"), id_key, name_key)
+
+            c, c_raw = index_objects("curr")
+            p, _p_raw = index_objects("prev")
+            new, absent = sorted(c.keys() - p.keys()), sorted(p.keys() - c.keys())
+            total_new += len(new)
+            total_absent += len(absent)
+            groups.append((ch, c, c_raw, p, _p_raw, new, absent))
+        # 先算该维度跨渠道总数，避免超过五个仍因拆渠道而展开全部对象。
+        for ch, c, c_raw, p, _p_raw, new, absent in groups:
+            if not c and not p:
+                continue
+            parts = []
+            for action, ids, mapping, raw, total, per in (
+                    ('新增', new, c, c_raw, total_new, 'curr'), ('暂停', absent, p, _p_raw, total_absent, 'prev')):
+                if not ids:
+                    continue
+                part = action_summary(action, [mapping[i] for i in ids], distribution=True, total=total, raw_names=[raw[i] for i in ids])
+                if kind == '广告组':
+                    # 新增用本期、暂停用上期；分母为该渠道该期账户总消耗。
+                    selected = set(ids)
+                    records = (r for r in iter_stem_rows(bl, f'met_{ch}_{per}_{id_key}+{name_key}') if str(r.get(id_key)) in selected)
+                    amount = metric_value(records, 'spend_usd')
+                    action_amounts[action].append(amount)
+                    denominator = spend[per][ch]
+                    amount_s = '数据不足' if amount is None else f'${amount:,.2f}'
+                    share_s = f'{amount / denominator * 100:.1f}%' if amount is not None and denominator > 0 else '不可计算'
+                    part += f'；{"本期" if per == "curr" else "上期"}合计消耗 {amount_s}，占该渠道同期消耗 {share_s}'
+                parts.append(part)
+            bits.append(CH_LABEL[ch] + '：\n' + ('\n'.join(parts) or '未出现变化'))
+        totals = [f'{action} {count} 个{kind}' for action, count in [('新增', total_new), ('暂停', total_absent)] if count]
+        leaders = sorted(((len(new), CH_LABEL[ch]) for ch, _, _, _, _, new, _ in groups), reverse=True)
+        object_notes[kind] = ('、'.join(totals) or '未出现变化') + (f'，新增主要集中在{leaders[0][1]}' if leaders and leaders[0][0] else '')
+        if kind == '广告组':
+            # 跨渠道合计同时展示，暂停仍使用上期总体分母，不混用本期预算。
+            totals = []
+            for action, count, denominator, period_label in [('新增', total_new, curr_total, '本期'), ('暂停', total_absent, prev_total, '上期')]:
+                if count:
+                    amounts = action_amounts[action]
+                    amount = sum(amounts) if amounts and all(v is not None for v in amounts) else None
+                    amount_s = '数据不足' if amount is None else f'${amount:,.2f}'
+                    share_s = f'{amount / denominator * 100:.1f}%' if amount is not None and denominator > 0 else '不可计算'
+                    totals.append(f'{action} {count} 个广告组，{period_label}合计消耗 {amount_s}，占业务线同期消耗 {share_s}')
+        return ['合计：' + ('\n'.join(totals) or '未出现变化')] + bits
+
+    audience_type_text, audience_type_moved = share_line("【受众类型】", "audience_type", "audience_type", ["fb", "gg", "tt"])
+    ag_bits = object_strategy("广告组", "adgroup_id", "adgroup_name")
+    audience_strategy = "\n".join(
+        x
+        for x in [
+            setting_line("【国家】", country_curr, country_prev, first_period=first_period),
+            setting_line("【兴趣词包】", interest_curr, interest_prev, first_period=first_period),
+            audience_type_text,
+            setting_line("【关键词】", kw_curr, kw_prev, first_period=first_period, show_names=False),
+            setting_line("【年龄】", *dim_sets("targeting_age", "targeting_age", ["fb", "gg", "tt"]), first_period=first_period),
+            setting_line("【性别】", *dim_sets("targeting_genders", "targeting_genders", ["fb", "gg", "tt"]), first_period=first_period),
+            "【广告组】\n" + "\n".join(ag_bits),
+        ]
+        if x
+    )
+
+    ad_bits = object_strategy("广告", "ad_id", "ad_name")
+    creative_fmt = share_line("【创意类型】", "ad_format", "ad_format", ["fb", "gg", "tt"])[0] or ""
+    creative_strategy = "【广告】\n" + "\n".join(ad_bits) + (("\n\n" + creative_fmt) if creative_fmt else "")
+    # 参照样例四种总结结构，分别讲预算、目标结构、定向调整、广告与创意结构。
+    gains = [ch for ch in active_channels if curr_share[ch] - prev_share[ch] > 0.2]
+    leader = max(gains, key=lambda ch: curr_share[ch] - prev_share[ch]) if gains else None
+    bid_leader = max(bids, key=lambda ch: len(bids[ch]))
+    budget_summary = f'总结：本期整体消耗{amount_change(curr_total, prev_total)}，' + (f'预算占比向{CH_LABEL[leader]}集中' if leader else '预算分配未明显向单一渠道集中')
+    budget_summary += f'；出价操作主要发生在{CH_LABEL[bid_leader]}。' if bids[bid_leader] else '；未观察到出价调整。'
+    budget_strategy = budget_summary + '\n\n' + budget_strategy
+    product_summary = '总结：' + ('广告目标和系列类型整体保持稳定' if not (m1 or m2) else '广告目标或系列类型出现调整')
+    product_summary += '；' + '；'.join(share_notes.get('【成效目标】', []) + share_notes.get('【出价方式】', [])) if (m3 or m4) else '；成效目标与出价结构整体保持稳定'
+    product_strategy = product_summary + '。\n\n' + product_strategy
+    changes, stable = [], []
+    for label, pair in [('国家定向', (country_curr, country_prev)), ('兴趣词包', (interest_curr, interest_prev)),
+                        ('关键词', (kw_curr, kw_prev)), ('年龄定向', dim_sets('targeting_age', 'targeting_age', list(CH_LABEL))),
+                        ('性别定向', dim_sets('targeting_genders', 'targeting_genders', list(CH_LABEL)))]:
+        (changes if pair[0] != pair[1] else stable).append(label)
+    (changes if audience_type_moved else stable).append('受众类型')
+    audience_summary = '总结：' + ('本期定向调整涉及' + '、'.join(changes) if changes else '本期定向设置整体保持稳定')
+    audience_summary += '；广告组' + object_notes['广告组'] + ('；' + '、'.join(stable) + '未出现变化' if stable else '')
+    audience_strategy = audience_summary + '。\n\n' + audience_strategy
+    creative_summary = '总结：本期广告' + object_notes['广告'] + '；' + ('；'.join(share_notes.get('【创意类型】', [])) or '创意类型结构整体保持稳定')
+    creative_strategy = creative_summary + '。\n\n' + creative_strategy
+
+    # 文案和效果在同一判断点产出，不扫描 learning 文本反推状态。
+    learning_effects = {}
+    # 新增枚举的环比基准是上期全部请求渠道的账户总体，不能忽略其字段冲突。
+    previous_rule = core_rule(core_index)
+    if has_previous:
+        for ch in active_channels:
+            meta = load_json_file(bl / f'met_{ch}_prev_account_id.pages.json') or {}
+            if metric_fields(metric) & set(meta.get('conflictField', [])):
+                previous_rule = {**previous_rule, 'usable': False, 'reason': '核心指标不支持'}
+
+    def strategy_learning(dim_specs, strategy_key=''):
+        results = []
+        comparisons = []
+        for title, stem, key, channels, id_key in dim_specs:
+            dimension_rows = []
+            dimension_supported = True
+            for ch in (ch for ch in channels if ch in active_channels):
+                scoped_rule = dict(previous_rule)
+                curr_stem = f"met_{ch}_curr_{stem}"
+                prev_stem = f"met_{ch}_prev_{stem}"
+                items, _stops = new_items(iter_stem_rows(bl, curr_stem), iter_stem_rows(bl, prev_stem), key, id_key)
+                # 上期维度仅识别集合差，指标基准来自上期账户总体。
+                for source in (curr_stem,):
+                    meta = load_json_file(bl / f'{source}.pages.json') or {}
+                    if metric_fields(metric) & set(meta.get('conflictField', [])):
+                        scoped_rule = {**scoped_rule, 'usable': False, 'reason': '核心指标不支持'}
+                for item in items:
+                    dimension_rows.extend(item['rows'])
+                    dimension_supported = dimension_supported and scoped_rule.get('usable', False)
+            if dimension_rows:
+                # 同维度所有渠道与新增枚举先合计基础指标，再判定一次并按该维度消耗计权。
+                dimension_rule = dict(previous_rule)
+                if not dimension_supported:
+                    dimension_rule = {**dimension_rule, 'usable': False, 'reason': '核心指标不支持'}
+                results.append((metric_value(dimension_rows, 'spend_usd'), new_scope_learning(
+                    dimension_rule, dimension_rows, previous_total=core_p, has_previous=has_previous)))
+                comparisons.append(learning_comparison(core_rule(core_index),
+                    metric_value(dimension_rows, metric) if dimension_supported else None,
+                    core_p if previous_rule.get('usable') else None, f'{title}新增合计：'))
+        verdict, text = combine_scope_learning(core_rule(core_index), results)
+        learning_effects[strategy_key] = effect_code(verdict)
+        return describe_learning(text, core_rule(core_index), comparisons)
+
+
+    product_learning = strategy_learning(
+        [
+            ("广告目标", "objective", "objective", ["fb", "tt"], None),
+            ("广告系列类型", "advertising_channel_type", "advertising_channel_type", ["gg"], None),
+            ("成效目标", "optimization_goal", "optimization_goal", ["fb", "gg", "tt"], None),
+            ("出价方式", "bid_strategy", "bid_strategy", ["fb", "gg", "tt"], None),
+        ],
+        strategy_key='product',
+    )
+    audience_learning = strategy_learning(
+        [
+            ("国家", "country_code", "country_code", ["fb", "gg", "tt"], None),
+            ("兴趣词包", "targeting_interests", "targeting_interests", ["fb", "tt"], None),
+            ("受众类型", "audience_type", "audience_type", ["fb", "gg", "tt"], None),
+            ("关键词", "keywords", "keywords", ["gg"], None),
+            ("年龄", "targeting_age", "targeting_age", ["fb", "gg", "tt"], None),
+            ("性别", "targeting_genders", "targeting_genders", ["fb", "gg", "tt"], None),
+            ("广告组", "adgroup_id+adgroup_name", "adgroup_name", ["fb", "gg", "tt"], "adgroup_id"),
+        ], strategy_key='audience',
+    )
+    creative_learning = strategy_learning(
+        [
+            ("广告", "ad_id+ad_name", "ad_name", ["fb", "gg", "tt"], "ad_id"),
+            ("创意类型", "ad_format", "ad_format", ["fb", "gg", "tt"], None),
+        ], strategy_key='creative',
+    )
+
+    row = {
+        "group": group,
+        "bizLine": name,
+        "period": period,
+        "project": project,
+        # Excel 展示业务线全部账号；旧拉数文件兼容使用实际分析账号。
+        "adAccounts": "\n".join(
+            CH_LABEL[ch] + "：\n" + "\n".join(dict.fromkeys(str(account) for account in accounts))
+            for ch in CH_LABEL
+            if (accounts := projects.get("allAccounts", projects.get("accounts", {})).get(ch))
+        ),
+        "budgetStrategy": budget_strategy,
+        "budgetLearning": budget_learning,
+        "productStrategy": product_strategy,
+        "productLearning": product_learning,
+        "audienceStrategy": audience_strategy,
+        "audienceLearning": audience_learning,
+        "creativeStrategy": creative_strategy,
+        "creativeLearning": creative_learning,
+        "budgetEffect": effect_code(spend_verdict),
+        **{key + 'Effect': value for key, value in learning_effects.items()},
+    }
+    # 证据只来自实际快照或集合/占比变化；不把消耗下降推断为主动减预算。
+    evidence = {'budget': [], 'product': [], 'audience': []}
+    if any(bids.values()):
+        evidence['budget'].append('出价调整')
+    for field, action in [('raise_n', '上调出价'), ('lower_n', '下调出价')]:
+        if any(stats[field] for stats in bid_stats.values()):
+            evidence['budget'].append(action)
+    if not first_period:
+        for moved, label in zip((m1, m2, m3, m4), ('广告目标调整', '广告系列类型调整', '成效目标调整', '出价方式调整')):
+            if moved:
+                evidence['product'].append(label)
+        for current, previous, label in [(country_curr, country_prev, '国家调整'),
+                                          (interest_curr, interest_prev, '兴趣词调整'), (kw_curr, kw_prev, '关键词调整')]:
+            if current != previous:
+                evidence['audience'].append(label)
+        for stem, label in [('targeting_age', '年龄调整'), ('targeting_genders', '性别调整')]:
+            current, previous = dim_sets(stem, stem, ['fb', 'gg', 'tt'])
+            if current != previous:
+                evidence['audience'].append(label)
+        if audience_type_moved:
+            evidence['audience'].append('受众类型调整')
+    # 旧的覆盖、分布及逐枚举成效说明不再进入 Excel；明细统一按维度和指标重建。
+    details = build_dimension_details(bl, active_channels, bids)
+    payload = {"rows": [row], "details": details}
+    (req / "payload.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    summary = {
+        "bizLineId": biz_id,
+        "curr_total": curr_total,
+        "prev_total": prev_total,
+        "overall_cpi": [cpi_c, cpi_p],
+        "overall_cpm": [overall_c, overall_p],
+        "eff_days": eff_days,
+        "first_period": first_period,
+        "spend_verdict": spend_verdict,
+        "bid_counts": {ch: len(bids[ch]) for ch in bids},
+        "detail_count": len(details),
+        "tag_evidence": evidence,
+        "request_dir": str(req),
+    }
+    (req / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+    return payload, summary
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--request-dir", required=True)
+    args = parser.parse_args()
+    _, summary = summarize_request(Path(args.request_dir))
+    print(json.dumps(summary, ensure_ascii=False), flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())