sino-bc-cli 1.0.0-beta.0

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

@@ -0,0 +1,1233 @@
+"""离线回归：指标口径、分页、并发、最终文件和清理边界，不请求业务网关。"""
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import unittest
+import zipfile
+from pathlib import Path
+from unittest.mock import patch
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from cli_json import run_cli
+from fetch_data import fetch_paged
+from summarize import bid_changes, dim_layer_text
+from cli_json import core_rule, metric_value, qoq_axis, cli_context, exec_cli_to_file, shim_entry
+from cleanup import OwnedDirectory
+from build_report import write_xlsx, validate_xlsx, prepare_layout, COLUMNS, DETAIL_COLUMNS
+from run_workflow import run_batch, execute_business, publish, workflow_parser
+from argparse import Namespace
+from datetime import date
+
+
+def arguments(output, ids=None):
+    """测试批次沿用真实入口参数，不访问业务接口。"""
+    return Namespace(id=ids or [1], name='', concurrency=3, output_dir=str(output), output_mode='excel', curr_start='', curr_end='', prev_start='', prev_end='', account_fb=[], account_gg=[], account_tt=[])
+
+
+def small_payload():
+    """只包含匿名样本的完整 16 列数据。"""
+    return {'rows': [{key: ('示例' if key == 'bizLine' else ('结论：待观察\n说明：数据不足，暂无法判断' if key.endswith('Learning') else label)) for key, label in COLUMNS}],
+            'details': [{'kind': '出价', 'action': '上调', 'channel': 'Meta', 'id': '1',
+                         'name': '同名', 'extra': 'bid_amount 1 → 2'}]}
+
+
+class DataRules(unittest.TestCase):
+    """防止缺失值和失败回包被当作有效业务数据。"""
+
+    def test_indicator_sheet_columns_and_derived_values(self):
+        """29 个指标按源表顺序导出；比率先合计基础字段再计算。"""
+        from cli_json import REPORT_METRICS
+        from summarize import detail_metric_cells
+        self.assertEqual(len(REPORT_METRICS), 29)
+        self.assertEqual(len({code for code, _label, _percent in REPORT_METRICS}), 29)
+        for code, label, _percent in REPORT_METRICS:
+            self.assertTrue(core_rule(code)['usable'], code)
+            self.assertTrue(core_rule(label)['usable'], label)
+        self.assertFalse(core_rule('结账成本')['usable'])
+        self.assertFalse(core_rule('线索量/点击量')['usable'])
+        self.assertEqual([label for _key, label in DETAIL_COLUMNS[:5]],
+                         ['明细数据', '动作', '渠道', 'id', '名称'])
+        self.assertEqual([label for _key, label in DETAIL_COLUMNS[5:-1]],
+                         [label for _code, label, _percent in REPORT_METRICS])
+        self.assertEqual(DETAIL_COLUMNS[-1], ('extra', '补充'))
+        current = [{'spend_usd': 30, 'impressions': 300, 'clicks': 10,
+                    'installs': 2, 'complete_registration': 1},
+                   {'spend_usd': 20, 'impressions': 200, 'clicks': 10,
+                    'installs': 3, 'complete_registration': 1}]
+        previous = [{'spend_usd': 40, 'impressions': 400, 'clicks': 20,
+                     'installs': 4, 'complete_registration': 2}]
+        cells = detail_metric_cells(current, previous)
+        self.assertEqual(cells['spend_usd'], '50.00（上期：40.00）')
+        self.assertEqual(cells['cpi'], '10.00（上期：10.00）')
+        self.assertEqual(cells['ctr'], '4.00%（上期：5.00%）')
+        self.assertEqual(cells['cpr'], '25.00（上期：20.00）')
+        self.assertEqual(cells['roas'], '-')
+        conflicted = detail_metric_cells(current, previous, {'installs'}, {'clicks'})
+        self.assertEqual(conflicted['cpi'], '-（上期：10.00）')
+        self.assertEqual(conflicted['ctr'], '4.00%')
+        self.assertEqual(conflicted['installs'], '-（上期：4）')
+
+    def test_indicator_sheet_api_field_aliases(self):
+        """指标表原始驼峰 API 字段名也能识别，但表外公式仍不支持。"""
+        for alias, expected in {
+            'spendUsdUsd': 'spend_usd', 'spendUsd': 'spend_usd',
+            'videoViews': 'video_views', 'addsToCart': 'add_to_cart',
+            'checkoutsInitiated': 'checkouts', 'purchases': 'purchase',
+            'purchasesValue': 'purchase_value', 'appInstalls': 'installs',
+            'registrationsCompleted': 'complete_registration',
+            'engagements': 'engagement',
+        }.items():
+            self.assertEqual(core_rule(alias)['metric'], expected, alias)
+        self.assertFalse(core_rule('spendUsdUsd/checkoutsInitiated')['usable'])
+
+    def test_dimension_details_align_periods_by_id(self):
+        """连续、新增、暂停按原始 ID 配对；暂停项本期为缺值。"""
+        from summarize import build_dimension_details
+        fixture = {
+            'dim_fb_curr_country_code': [{'country_code': 'US'}, {'country_code': '0'}],
+            'dim_fb_prev_country_code': [{'country_code': 'US'}, {'country_code': 'CA'}],
+            'met_fb_curr_country_code': [
+                {'country_code': 'US', 'spend_usd': 10, 'clicks': 2},
+                {'country_code': '0', 'spend_usd': 4, 'clicks': 1}],
+            'met_fb_prev_country_code': [
+                {'country_code': 'US', 'spend_usd': 8, 'clicks': 2},
+                {'country_code': 'CA', 'spend_usd': 6, 'clicks': 1}],
+        }
+        with patch('summarize.iter_stem_rows', side_effect=lambda _bl, stem: iter(fixture.get(stem, []))):
+            rows = build_dimension_details(Path('.'), ['fb'], {'fb': []})
+        country = {row['id']: row for row in rows if row['kind'] == '国家'}
+        self.assertEqual({ident: row['action'] for ident, row in country.items()},
+                         {'0': '新增', 'CA': '暂停', 'US': '持续'})
+        self.assertEqual(country['US']['spend_usd'], '10.00（上期：8.00）')
+        self.assertEqual(country['CA']['spend_usd'], '-（上期：6.00）')
+        self.assertEqual(country['0']['spend_usd'], '4.00')
+        self.assertTrue(all(row['extra'] == '' for row in country.values()))
+
+    def test_account_column_grouping_and_rich_text(self):
+        """账号列紧跟项目，渠道原生加粗，长名单不截断且完整回读。"""
+        from build_report import build_shared_strings
+        from xml.etree import ElementTree as ET
+        text = 'Meta：\n' + '\n'.join(f'act_{i}' for i in range(30)) + '\nGoogle：\n123-456-7890'
+        records, details = prepare_layout([{'bizLine': '样本', 'adAccounts': text}], [])
+        self.assertEqual(records[0]['adAccounts'], text)
+        self.assertEqual(len(records), 1)
+        self.assertEqual(COLUMNS[3:5], [('project', '项目名称'), ('adAccounts', '广告账号')])
+        self.assertEqual(len(COLUMNS), 16)
+        xml, _, indices, _, _, _ = build_shared_strings(records)
+        ns = {'s': 'http://schemas.openxmlformats.org/spreadsheetml/2006/main'}
+        cell = list(ET.fromstring(xml))[indices[0][4]]
+        bold = [''.join(run.itertext()) for run in cell.findall('s:r', ns) if run.find('s:rPr/s:b', ns) is not None]
+        self.assertEqual(bold, ['Meta', 'Google'])
+        self.assertEqual(''.join(cell.itertext()), text)
+        with tempfile.TemporaryDirectory() as tmp:
+            output = str(Path(tmp) / 'accounts.xlsx')
+            write_xlsx(records, output, details)
+            validate_xlsx(output, records, details)
+
+    def test_excel_strips_invalid_xml_controls_before_validation(self):
+        """广告名称含垂直制表符等控制字符时，导出与回读保持同一清洗口径。"""
+        from xml.etree import ElementTree as ET
+
+        payload = small_payload()
+        payload['rows'][0]['budgetStrategy'] = '【广告】\nMeta：正常\x0b名称\t换行\n保留\r文本'
+        payload['details'][0]['name'] = '广告\x00\x1f\x7f\x9f\ufffe名称'
+        with tempfile.TemporaryDirectory() as tmp:
+            output = str(Path(tmp) / 'controls.xlsx')
+            write_xlsx(payload['rows'], output, payload['details'])
+            self.assertEqual(validate_xlsx(output, payload['rows'], payload['details'])['details'], 1)
+            with zipfile.ZipFile(output) as archive:
+                strings = ''.join(ET.fromstring(archive.read('xl/sharedStrings.xml')).itertext())
+            self.assertIn('正常名称\t换行\n保留\r文本', strings)
+            self.assertIn('广告名称', strings)
+            self.assertNotIn('\x0b', strings)
+            self.assertNotIn('\x7f', strings)
+
+    def test_strategy_native_bold_and_zero_changes(self):
+        """维度/渠道原生加粗，普通单元格不串格式；零动作和100%占比不制造噪声。"""
+        from build_report import build_shared_strings
+        from summarize import setting_line
+        from cli_json import budget_abs_share
+        from xml.etree import ElementTree as ET
+        self.assertEqual(setting_line('【国家】', {'US'}, {'US'}), '【国家】\n未出现变化')
+        self.assertEqual(setting_line('【国家】', {'US'}, set()), '【国家】\n新增 1 个：US')
+        text = '总结：消耗变化。\n【预算】\nMeta：$100 → $120；环比 +20.00%'
+        xml, _, rows, _, _, _ = build_shared_strings([{'budgetStrategy': text, 'budgetLearning': text}])
+        ns = {'s': 'http://schemas.openxmlformats.org/spreadsheetml/2006/main'}
+        items = list(ET.fromstring(xml))
+        indices = {key: i for i, (key, _) in enumerate(COLUMNS)}
+        strategy = items[rows[0][indices['budgetStrategy']]]
+        bold = [''.join(run.itertext()) for run in strategy.findall('s:r', ns) if run.find('s:rPr/s:b', ns) is not None]
+        self.assertEqual(bold, ['【预算】', 'Meta'])
+        self.assertEqual(''.join(strategy.itertext()), text)
+        self.assertIsNone(items[rows[0][indices['budgetLearning']]].find('s:r', ns))
+        value = budget_abs_share('Meta', prev_abs=100, curr_abs=120, prev_share=100, curr_share=100)
+        self.assertNotIn('占比', value)
+        self.assertIn('环比 +20.00%', value)
+
+    def test_learning_explanation_and_override_parser(self):
+        """规范化展示绝对值、相对变化和阈值，覆盖参数保留比较符并绑定ID。"""
+        from summarize import learning_comparison, describe_learning
+        from fetch_data import argument_parser
+        parsed = argument_parser(batch=True).parse_args(['--id', '1', '--id', '2',
+                 '--core-index', '1=CPI <= 6.5', '--core-index', '2=注册成本 >= 3'])
+        self.assertEqual(parsed.core_index, [(1, 'CPI <= 6.5'), (2, '注册成本 >= 3')])
+        with tempfile.TemporaryDirectory() as tmp:
+            args = arguments(Path(tmp), [1])
+            for overrides in ([(2, 'CPI')], [(1, 'CPI'), (1, 'CTR')]):
+                args.core_index = overrides
+                with self.assertRaises(ValueError):
+                    run_batch(args, temp_parent=tmp)
+            self.assertEqual(list(Path(tmp).iterdir()), [])
+        rule = core_rule('CPI <= 10')
+        comparison = learning_comparison(rule, 12, 15, '')
+        self.assertIn('本期 12.00，上期总体 15.00，环比 -20.00%', comparison)
+        text = describe_learning('结论：有效\n说明：策略有效', rule, [comparison])
+        self.assertIn('KPI目标 <= 10', text)
+        self.assertTrue(text.endswith('建议继续执行'))
+        multiple = describe_learning('结论：有效\n说明：策略有效', rule,
+                                     ['国家新增合计：CPI 本期 8.00', '广告组新增合计：CPI 本期 7.00'])
+        self.assertIn('国家新增合计：CPI 本期 8.00\n广告组新增合计：CPI 本期 7.00', multiple)
+        from cli_json import budget_abs_share
+        share_text = budget_abs_share('Meta', prev_abs=608, curr_abs=591, prev_share=60.8, curr_share=59.1)
+        self.assertIn('（-1.7%）', share_text)
+        self.assertNotIn('个百分点', share_text)
+        self.assertEqual(text.count('\n'), 2)
+        self.assertIn('说明：策略有效\n', text)
+        self.assertIn('环比 不可计算', learning_comparison(rule, 1, 0, '国家新增合计：'))
+
+    def test_new_enum_compares_previous_business_total(self):
+        """新增枚举没有上期同值仍可比总体；有总体记录时禁止回退到阈值。"""
+        from summarize import new_scope_learning
+        rows = [{'calendar_date': f'2026-09-{day}', 'spend_usd': 32.666666666666664, 'installs': 10}
+                for day in (10, 11, 12)]
+        current = metric_value(rows, 'CPI')
+        # 即使阈值不达标，相比上期总体改善2%仍然有效。
+        rule = core_rule('CPI <= 1')
+        self.assertEqual(new_scope_learning(rule, rows, previous_total=current / .98, has_previous=True)[0], '有效')
+        self.assertEqual(new_scope_learning(core_rule('CPI <= 100'), rows,
+                                           previous_total=current, has_previous=True)[0], '无效')
+        for previous in (None, 0):
+            self.assertEqual(new_scope_learning(core_rule('CPI <= 100'), rows,
+                                               previous_total=previous, has_previous=True)[0], '待观察')
+        self.assertEqual(new_scope_learning(rule, rows, has_previous=False)[0], '无效')
+        self.assertEqual(new_scope_learning(rule, rows[:2], previous_total=100, has_previous=True)[0], '有效')
+
+    def test_new_scope_sample_and_dimension_combination(self):
+        """正消耗样本不受投放天数限制；仍按新增枚举消耗占比汇总。"""
+        from summarize import new_scope_learning, combine_scope_learning
+        rule = core_rule('注册成本 <= 3')
+        rows = [{'calendar_date': f'2026-09-{day}', 'spend_usd': 20, 'complete_registration': 10}
+                for day in (10, 11, 12)]
+        valid = new_scope_learning(rule, rows)
+        self.assertEqual(valid, ('有效', '结论：有效\n说明：核心指标达标'))
+        invalid = new_scope_learning(core_rule('注册成本 <= 1'), rows)
+        self.assertEqual(invalid[0], '无效')
+        # 低于50美元仍可按真实核心指标判断。
+        low_spend = [{**r, 'spend_usd': 10} for r in rows]
+        self.assertEqual(new_scope_learning(rule, low_spend), ('有效', '结论：有效\n说明：核心指标达标'))
+        zero_spend = [{**r, 'spend_usd': 0} for r in rows]
+        self.assertEqual(new_scope_learning(rule, zero_spend)[0], '待观察')
+        self.assertEqual(new_scope_learning(rule, rows[:2])[0], '有效')
+        self.assertEqual(new_scope_learning(rule, [{**r, 'calendar_date': '2026-09-10'} for r in rows])[0], '有效')
+        self.assertEqual(new_scope_learning(rule, [])[0], '待观察')
+        # CPI 只需安装量足以算出指标，1次安装也可按阈值判定。
+        self.assertEqual(new_scope_learning(core_rule('CPI <= 5'),
+                         [{'calendar_date': '2026-09-10', 'spend_usd': 2, 'installs': 1}])[0], '有效')
+        self.assertEqual(new_scope_learning(core_rule('注册成本'), rows)[0], '待观察')
+        self.assertEqual(combine_scope_learning(rule, [(71, valid), (29, invalid)])[0], '有效')
+        self.assertEqual(combine_scope_learning(rule, [(70, valid), (30, invalid)])[0], '无效')
+        self.assertEqual(combine_scope_learning(rule, [(69, valid), (31, invalid)])[0], '无效')
+        unknown = ('待观察', '结论：待观察\n说明：数据不足，暂无法判断')
+        self.assertEqual(combine_scope_learning(rule, [(70, valid), (30, unknown)])[0], '待观察')
+        self.assertEqual(combine_scope_learning(rule, [(71, valid), (29, unknown)])[0], '有效')
+        self.assertEqual(combine_scope_learning(rule, [(0, valid)])[0], '待观察')
+        self.assertEqual(combine_scope_learning(rule, [(None, unknown), (71, valid)])[0], '待观察')
+        self.assertEqual(combine_scope_learning(rule, [])[0], '待观察')
+
+    def test_budget_sample_only_requires_positive_spend(self):
+        """预算样本只需正消耗，零消耗及缺消耗仍待观察。"""
+        from summarize import learning_sample_sufficient
+        from cli_json import evaluate_learning
+        rule = core_rule('CPI <= 5')
+        self.assertTrue(learning_sample_sufficient(0.01))
+        self.assertEqual(evaluate_learning(rule, 3, None, False,
+                         learning_sample_sufficient(0.01))[0], '有效')
+        self.assertFalse(learning_sample_sufficient(0))
+        self.assertFalse(learning_sample_sufficient(None))
+
+    def test_derived_event_cost_and_explicit_formula(self):
+        """事件成本及明确的基础指标比值参与 learning，先汇总再相除。"""
+        from cli_json import metric_fields, metric_formula, evaluate_learning, rule_hit
+        rule = core_rule('注册成本 USD <= 25')
+        self.assertTrue(rule['usable'])
+        self.assertFalse(rule['higher_is_better'])
+        self.assertEqual(metric_fields(rule['metric']), {'spend_usd', 'complete_registration'})
+        rows = [{'spend_usd': 10, 'complete_registration': 1},
+                {'spend_usd': 90, 'complete_registration': 3}]
+        self.assertEqual(metric_value(rows, rule['metric']), 25)
+        self.assertTrue(rule_hit(25, rule))
+        self.assertEqual(evaluate_learning(rule, 24.5, 25, True)[0], '有效')
+        self.assertEqual(evaluate_learning(rule, 25, None, False)[0], '有效')
+        for rows in ([{'spend_usd': 100}], [{'spend_usd': 100, 'complete_registration': 0}]):
+            value = metric_value(rows, rule['metric'])
+            self.assertIsNone(value)
+            self.assertEqual(evaluate_learning(rule, value, 25, True)[1], '结论：待观察\n说明：数据不足，暂无法判断')
+        for name in ('线索成本', '购买成本', '加购成本', '视频观看成本', '互动成本', '客单价'):
+            self.assertTrue(core_rule(name)['usable'], name)
+        self.assertFalse(core_rule('结账成本')['usable'])
+        for text in ('注册量/点击量*100 >= 2%', '完成注册量 ÷ 点击量 × 100 >= 2%'):
+            rate = core_rule(text)
+            self.assertTrue(rate['usable'], text)
+            self.assertEqual(metric_value([{'complete_registration': 4, 'clicks': 100}], rate['metric']), 4)
+        for name in ('单次安装量成本', 'spend_usd/installs'):
+            self.assertEqual(metric_formula(core_rule(name)['metric']), ('spend_usd', 'installs', 1))
+        explicit = core_rule('spend_usd/complete_registration <= 25')
+        self.assertTrue(explicit['usable'])
+        self.assertFalse(explicit['higher_is_better'])
+        self.assertFalse(core_rule('次日留存成本')['usable'])
+
+    def test_keywords_always_show_counts_without_names(self):
+        """关键词无论少于五个、恰好五个或更多，都不在策略中展开长文本。"""
+        from summarize import setting_line
+        for count in (0, 1, 5, 6):
+            current = {f'完整新增关键词-{i}' for i in range(count)}
+            previous = {'完整暂停关键词'}
+            text = setting_line('【关键词】', current, previous, show_names=False)
+            self.assertEqual(text, '【关键词】\n' + (f'新增 {count} 个；' if count else '') + '暂停 1 个')
+        self.assertEqual(setting_line('【关键词】', {'很长的关键词'}, set(), True, show_names=False),
+                         '【关键词】\n当期 1 个')
+
+    def test_small_changes_show_names_and_large_objects_show_distribution(self):
+        """新增/暂停独立计数，五个完整列出，六个收起；同名对象不能去重。"""
+        from summarize import setting_line, action_summary
+        current = {f'新增国家{i}' for i in range(5)}
+        previous = {'暂停国家甲', '暂停国家乙'}
+        text = setting_line('国家', current, previous)
+        for name in current | previous:
+            self.assertIn(name, text)
+        text = setting_line('国家', current | {'第六个国家'}, previous)
+        self.assertIn('新增 6 个', text)
+        self.assertNotIn('新增国家0', text)
+        self.assertIn('暂停国家甲', text)
+        for count in (1, 5):
+            names = [f'EN-广告{i}' for i in range(count)]
+            text = action_summary('新增', names, distribution=True)
+            self.assertNotIn('分布在', text)
+            for name in names:
+                self.assertIn(name, text)
+        text = action_summary('新增', [f'EN-广告{i}' for i in range(6)], distribution=True)
+        self.assertIn('分布在：EN（6个）', text)
+        self.assertNotIn('EN-广告0', text)
+        self.assertEqual(action_summary('暂停', [], distribution=True), '')
+        self.assertEqual(action_summary('新增', ['同名', '同名']), '新增 2 个：同名、同名')
+        self.assertIn('分布在', action_summary('新增', ['EN-广告1'], distribution=True, total=6))
+
+    def test_all_api_metrics_and_aliases_with_optional_thresholds(self):
+        """十二项接口指标全部可识别、求和；衍生值维持先求和后计算。"""
+        from cli_json import BASE_METRICS, rule_hit
+        from fetch_data import INDICATORS
+        self.assertEqual(set(INDICATORS), set(BASE_METRICS))
+        for code, aliases in BASE_METRICS.items():
+            self.assertEqual(core_rule(code)['metric'], code)
+            self.assertTrue(core_rule(code)['usable'])
+            self.assertEqual(core_rule(aliases[0])['metric'], code)
+            rule = core_rule(code + ' >= 100')
+            self.assertTrue(rule_hit(100, rule))
+            self.assertFalse(rule_hit(99, rule))
+            self.assertEqual(metric_value(iter([{code: 30}, {code: 70}]), code), 100)
+            self.assertIsNone(metric_value([{code: 30}, {}], code))
+            self.assertEqual(metric_value([{code: 0}], code), 0)
+        self.assertEqual(core_rule('完成注册量不低于100次')['target'], 100)
+        self.assertTrue(core_rule('CPI')['usable'])
+        self.assertTrue(core_rule('CPI USD')['usable'])
+        self.assertTrue(core_rule('CTR >= 2%')['usable'])
+        self.assertEqual(core_rule('次日留存率 >= 20%')['reason'], '核心指标不支持')
+        self.assertEqual(core_rule('CPI 人民币 <= 30')['reason'], '核心指标无法识别')
+        self.assertEqual(core_rule('点击率 >= 2')['reason'], '核心指标无法识别')
+
+    def test_learning_trend_before_threshold_and_no_previous_fallback(self):
+        """2%包含边界；有上期不看达标，无上期才看阈值；缺值与零不冒充无上期。"""
+        from cli_json import evaluate_learning
+        for metric, current, previous in [('CPI <= 1', 1.96, 2), ('安装量 >= 1000', 102, 100)]:
+            self.assertEqual(evaluate_learning(core_rule(metric), current, previous, True)[0], '有效')
+        for current in (98.001, 99, 100, 102):
+            self.assertEqual(evaluate_learning(core_rule('CPI <= 200'), current, 100, True)[0], '无效')
+        for previous in (None, 0):
+            self.assertEqual(evaluate_learning(core_rule('安装量 >= 100'), 200, previous, True)[0], '待观察')
+        self.assertEqual(evaluate_learning(core_rule('安装量 >= 100'), 100, None, False),
+                         ('有效', '结论：有效\n说明：核心指标达标'))
+        self.assertEqual(evaluate_learning(core_rule('安装量 >= 100'), 99, None, False),
+                         ('无效', '结论：无效\n说明：核心指标未达标'))
+        self.assertEqual(evaluate_learning(core_rule('安装量'), 200, None, False)[0], '待观察')
+        self.assertEqual(evaluate_learning(core_rule('CPI'), 1, 2, True, False)[0], '待观察')
+        self.assertEqual(evaluate_learning(core_rule('CPI <= 3'), 1, None, False, False)[0], '待观察')
+
+    def test_api_conflict_fields_preserved_for_analysis(self):
+        """服务端静默忽略指标时保留证据，不能算成零或部分渠道的有效值。"""
+        with tempfile.TemporaryDirectory() as tmp, patch('fetch_data.run_cli', return_value={
+            'ok': True, 'data': {'data': [{'spend_usd': 30}], 'total': 1, 'conflictField': ['leads']}
+        }):
+            fetch_paged('+facebook-metrics', {}, 'fixture', Path(tmp))
+            meta = json.loads((Path(tmp) / 'fixture.pages.json').read_text(encoding='utf-8'))
+            self.assertEqual(meta['conflictField'], ['leads'])
+
+    def test_conflict_fields_missing_null_and_empty_are_accepted(self):
+        """维度和成效分页均兼容缺失、null、空数组，不能将正常空值判为失败。"""
+        for shortcut in ('+facebook-dimension', '+facebook-metrics', '+google-dimension',
+                         '+google-metrics', '+tiktok-dimension', '+tiktok-metrics'):
+            for fields in ({}, {'conflictField': None}, {'conflictField': []}):
+                with self.subTest(shortcut=shortcut, fields=fields), tempfile.TemporaryDirectory() as tmp:
+                    env = {'ok': True, 'data': {'data': [{'id': 1}], 'total': 1, **fields}}
+                    with patch('fetch_data.run_cli', return_value=env):
+                        self.assertEqual(fetch_paged(shortcut, {}, 'fixture', Path(tmp)), 1)
+                    meta = json.loads((Path(tmp) / 'fixture.pages.json').read_text(encoding='utf-8'))
+                    self.assertNotIn('conflictField', meta)
+
+    def test_conflict_fields_invalid_types_still_fail(self):
+        """不能通过 truthy/falsy 兜底把非法回包吞成无冲突；失败不发布分页索引。"""
+        for value in ('', 'leads', 0, False, {}, [None], [1]):
+            with self.subTest(value=value), tempfile.TemporaryDirectory() as tmp:
+                env = {'ok': True, 'data': {'data': [], 'total': 0, 'conflictField': value}}
+                with patch('fetch_data.run_cli', return_value=env):
+                    with self.assertRaisesRegex(RuntimeError, 'conflictField 格式无效'):
+                        fetch_paged('+facebook-dimension', {}, 'fixture', Path(tmp))
+                self.assertFalse((Path(tmp) / 'fixture.pages.json').exists())
+
+    def test_learning_distinguishes_empty_unrecognized_and_missing_data(self):
+        """指标配置问题优先说明原因；指标有效但数据缺失保留原待观察文案。"""
+        from cli_json import learning_text
+        for raw in (None, '', '  '):
+            self.assertEqual(learning_text('待观察', core_rule(raw)), '结论：待观察\n说明：核心指标为空')
+        for raw in ('留存提升', 'CPA 人民币 <= 30'):
+            self.assertEqual(learning_text('待观察', core_rule(raw)), '结论：待观察\n说明：核心指标不支持')
+        self.assertEqual(learning_text('待观察', core_rule('CPI USD <= 3')),
+                         '结论：待观察\n说明：数据不足，暂无法判断')
+
+    def test_distribution_counts_objects_and_two_percent_boundary(self):
+        """分布一对象同词只计一次；不足2%稳定，达到2%即改变趋势。"""
+        from cli_json import naming_patterns, period_verdict
+        text = naming_patterns(['EN-EN-US-1001', 'EN-UK-1002'])
+        self.assertIn('EN（2个）', text)
+        self.assertNotIn('1001', text)
+        self.assertEqual(qoq_axis(101, 100)[0], '稳定')
+        self.assertEqual(qoq_axis(102, 100)[0], '变差')
+        self.assertEqual(qoq_axis(98, 100)[0], '变好')
+        self.assertEqual(period_verdict(first_period=False, qoq_label='稳定', kpi_usable=True, kpi_hit=False), '无效')
+
+    def test_no_default_cpm_kpi(self):
+        text, hit, _, _ = dim_layer_text("广告", [{"label": "A", "spend": 80, "imps": 10000, "cpm": 8}], [])
+        self.assertNotIn("未达标", text)
+        self.assertIsNone(hit)
+
+    def test_missing_bid_not_zero(self):
+        self.assertEqual(bid_changes([
+            {"adgroup_id": "1", "calendar_date": "2026-09-01", "bid_amount": None},
+            {"adgroup_id": "1", "calendar_date": "2026-09-02", "bid_amount": 2},
+        ], ["bid_amount"]), [])
+
+    def test_failed_page_never_writes_merged(self):
+        with tempfile.TemporaryDirectory() as tmp, patch("fetch_data.run_cli", return_value={"ok": False, "error": "失败"}):
+            with self.assertRaises(RuntimeError):
+                fetch_paged("+facebook-metrics", {}, "fixture", Path(tmp))
+            self.assertFalse((Path(tmp) / "fixture.merged.json").exists())
+            self.assertFalse((Path(tmp) / "fixture.pages.json").exists())
+
+    def test_paged_success_writes_page_files_not_merged(self):
+        """拉数只把各页回包落到临时文件，不在内存拼全表、不写 merged.json。"""
+        pages = [
+            {"ok": True, "data": {"data": [{"id": 1}, {"id": 2}], "total": 3}},
+            {"ok": True, "data": {"data": [{"id": 3}], "total": 3}},
+        ]
+
+        def api(_command, body, out):
+            env = pages[body["page"] - 1]
+            out.parent.mkdir(parents=True, exist_ok=True)
+            out.write_text(json.dumps(env, ensure_ascii=False), encoding="utf-8")
+            return env
+
+        with tempfile.TemporaryDirectory() as tmp, patch("fetch_data.run_cli", api):
+            root = Path(tmp)
+            total = fetch_paged("+facebook-metrics", {}, "fixture", root)
+            self.assertEqual(total, 3)
+            self.assertFalse((root / "fixture.merged.json").exists())
+            self.assertEqual(
+                json.loads((root / "fixture.pages.json").read_text(encoding="utf-8")),
+                {"total": 3, "pages": 2, "counts": [2, 1]},
+            )
+            self.assertTrue((root / "fixture.p1.out.json").exists())
+            self.assertTrue((root / "fixture.p2.out.json").exists())
+            from summarize import load_merged
+            self.assertEqual(load_merged(root, "fixture"), [{"id": 1}, {"id": 2}, {"id": 3}])
+            from summarize import iter_stem_rows, share_map
+            self.assertEqual(list(iter_stem_rows(root, "fixture")), [{"id": 1}, {"id": 2}, {"id": 3}])
+            self.assertEqual(list(iter_stem_rows(root, "fixture")), [{"id": 1}, {"id": 2}, {"id": 3}])
+
+    def test_share_map_and_metric_value_accept_iterators(self):
+        from summarize import share_map
+        shares, total = share_map(
+            iter([
+                {"spend_usd": 10, "audience_type": "A"},
+                {"spend_usd": 30, "audience_type": "B"},
+            ]),
+            "audience_type",
+        )
+        self.assertEqual(total, 40)
+        self.assertEqual(shares["A"], 25)
+        self.assertEqual(shares["B"], 75)
+        self.assertEqual(
+            metric_value(iter([{"spend_usd": 10, "installs": 1}, {"spend_usd": 90, "installs": 49}])),
+            2,
+        )
+        self.assertIsNone(metric_value(iter([{"spend_usd": 10, "installs": 0}])))
+
+    def test_bid_changes_accepts_iterator_without_full_row_list(self):
+        rows = iter([
+            {"adgroup_id": "1", "adgroup_name": "同名", "calendar_date": "2026-09-01", "bid_amount": 1},
+            {"adgroup_id": "1", "adgroup_name": "同名", "calendar_date": "2026-09-02", "bid_amount": 2},
+            {"adgroup_id": "1", "adgroup_name": "同名", "calendar_date": "2026-09-03", "bid_amount": 1},
+        ])
+        changes = bid_changes(rows, ["bid_amount"])
+        self.assertEqual(changes[0]["times"], 2)
+        self.assertEqual(changes[0]["from"], changes[0]["to"])
+        self.assertEqual(changes[0]["name"], "同名")
+
+    def test_new_items_only_materializes_new_rows(self):
+        from summarize import new_items
+        items, stops = new_items(
+            iter([
+                {"ad_id": "keep", "ad_name": "新", "spend_usd": 10, "installs": 1, "impressions": 1000},
+                {"ad_id": "old", "ad_name": "旧", "spend_usd": 99, "installs": 1, "impressions": 1000},
+            ]),
+            iter([{"ad_id": "old", "ad_name": "旧"}]),
+            "ad_name",
+            "ad_id",
+        )
+        self.assertEqual(len(items), 1)
+        self.assertEqual(items[0]["id"], "keep")
+        self.assertEqual(len(items[0]["rows"]), 1)
+        self.assertEqual(stops, [])
+
+    def test_iter_stem_rows_rejects_extra_pages_without_index(self):
+        from summarize import iter_stem_rows
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            page = {"ok": True, "data": {"data": [{"id": 1}], "total": 2}}
+            (root / "fixture.p1.out.json").write_text(json.dumps(page), encoding="utf-8")
+            (root / "fixture.p2.out.json").write_text(json.dumps(page), encoding="utf-8")
+            with self.assertRaises(ValueError):
+                list(iter_stem_rows(root, "fixture"))
+
+    def test_failed_retry_unlinks_stale_pages_index(self):
+        with tempfile.TemporaryDirectory() as tmp, patch("fetch_data.run_cli", return_value={"ok": False, "error": "失败"}):
+            root = Path(tmp)
+            (root / "fixture.pages.json").write_text(
+                json.dumps({"total": 3, "pages": 2, "counts": [2, 1]}), encoding="utf-8"
+            )
+            with self.assertRaises(RuntimeError):
+                fetch_paged("+facebook-metrics", {}, "fixture", root)
+            self.assertFalse((root / "fixture.pages.json").exists())
+
+    def test_empty_ad_name_stays_out_of_naming_patterns(self):
+        from summarize import object_name_maps
+        from cli_json import naming_patterns
+        names, raw = object_name_maps(
+            iter([{"ad_id": "camp_summer_01", "ad_name": ""}]),
+            "ad_id",
+            "ad_name",
+        )
+        self.assertEqual(names["camp_summer_01"], "camp_summer_01")
+        self.assertEqual(raw["camp_summer_01"], "")
+        self.assertEqual(naming_patterns([raw["camp_summer_01"]]), "未识别分类")
+        self.assertIn("camp", naming_patterns([names["camp_summer_01"]]))
+
+    def test_short_page_still_fetches_total(self):
+        pages = [{"ok": True, "data": {"data": [{"id": 1}], "total": 2}}, {"ok": True, "data": {"data": [], "total": 2}}]
+        with tempfile.TemporaryDirectory() as tmp, patch("fetch_data.run_cli", side_effect=pages):
+            with self.assertRaises(RuntimeError):
+                fetch_paged("+facebook-metrics", {}, "fixture", Path(tmp))
+
+    def test_stderr_and_nonzero_override_success(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            # 替身使用真实子进程证明退出码和 stderr 不被吞掉。
+            command = [sys.executable, "-c", 'import sys; print(\'{"ok": true}\'); sys.stderr.write("fixture denied"); sys.exit(2)']
+            with patch("cli_json.resolve_cli", return_value=command):
+                result = run_cli([], None, Path(tmp) / "response.out.json")
+            self.assertFalse(result["ok"])
+            self.assertIn("fixture denied", str(result))
+
+    def test_metric_units_denominator_and_direction(self):
+        self.assertFalse(core_rule('人民币 CPA≤30，次留>20%')['usable'])
+        rule = core_rule('CPI USD <= 3')
+        self.assertTrue(rule['usable'])
+        self.assertEqual(metric_value([{'spend_usd': 10, 'installs': 1}, {'spend_usd': 90, 'installs': 49}]), 2)
+        self.assertIsNone(metric_value([{'spend_usd': 10, 'installs': 0}]))
+        self.assertIsNone(metric_value([{'spend_usd': 10, 'installs': 10}, {'spend_usd': 50}]))
+        self.assertEqual(qoq_axis(2, 1, True)[0], '变好')
+
+    def test_page_cap_is_failure(self):
+        page = {'ok': True, 'data': {'data': [{'id': 1}], 'total': 2}}
+        with tempfile.TemporaryDirectory() as tmp, patch('fetch_data.PAGE_CAP', 1), patch('fetch_data.run_cli', return_value=page):
+            with self.assertRaises(RuntimeError):
+                fetch_paged('+facebook-metrics', {}, 'fixture', Path(tmp))
+
+    def test_page_cap_allows_more_than_eighty_pages(self):
+        """101982 条级别的分页不能在第 80 页主动截断；测试只用 81 条轻量数据。"""
+        from fetch_data import PAGE_CAP
+
+        self.assertGreaterEqual(PAGE_CAP, 200)
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+
+            def api(_command, body, out):
+                env = {'ok': True, 'data': {'data': [{'id': body['page']}], 'total': 81}}
+                out.write_text(json.dumps(env), encoding='utf-8')
+                return env
+
+            with patch('fetch_data.run_cli', side_effect=api), patch('fetch_data.report_progress'):
+                self.assertEqual(fetch_paged('+facebook-metrics', {}, 'large', root), 81)
+            meta = json.loads((root / 'large.pages.json').read_text(encoding='utf-8'))
+            self.assertEqual(meta['pages'], 81)
+            self.assertEqual(sum(meta['counts']), 81)
+
+    def test_zero_total_with_nonempty_rows_is_invalid(self):
+        with tempfile.TemporaryDirectory() as tmp, patch('fetch_data.run_cli', return_value={'ok': True, 'data': {'data': [{'id': 1}], 'total': 0}}):
+            with self.assertRaises(RuntimeError):
+                fetch_paged('+facebook-metrics', {}, 'fixture', Path(tmp))
+
+    def test_pnpm_shim_path(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            entry = root / 'global/5/node_modules/sino-bc-cli/dist/index.js'
+            entry.parent.mkdir(parents=True)
+            entry.write_text('// fixture')
+            shim = root / 'sino-bc-cli.cmd'
+            shim.write_text('@node "%~dp0global/5/node_modules/sino-bc-cli/dist/index.js" %*')
+            self.assertEqual(shim_entry(shim), entry.resolve())
+            self.assertTrue(core_rule('CPI <= 2 usd')['usable'])
+
+    def test_multiple_bid_fields_count_changed_days_once(self):
+        changes = bid_changes([
+            {'adgroup_id': '1', 'calendar_date': '2026-09-01', 'cpc': 1, 'cpm': 5},
+            {'adgroup_id': '1', 'calendar_date': '2026-09-02', 'cpc': 2, 'cpm': 6},
+            {'adgroup_id': '1', 'calendar_date': '2026-09-03', 'cpc': 1, 'cpm': 5},
+        ], ['cpc', 'cpm'])
+        self.assertEqual(changes[0]['times'], 2)
+        self.assertEqual(changes[0]['from'], changes[0]['to'])
+
+    def test_complete_fetch_analysis_and_id_details(self):
+        from fetch_data import fetch_business
+        from summarize import summarize_request
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            args = arguments(root / 'output')
+            args.id, args.request_dir = 1, str(root)
+            args.core_index = [(1, 'CPI <= 1'), (2, '安装量 >= 999')]
+            # 显式分析周期优先，接口周期故意不同，防止重新引入隐式回退。
+            args.curr_start, args.curr_end = '2026-09-08', '2026-09-14'
+            args.prev_start, args.prev_end = '2026-09-01', '2026-09-07'
+            biz = {'id': 1, 'name': '匿名样本', 'adCategoryIndustryIds': [11], 'periodStart': '2026-08-18', 'periodEnd': '2026-08-24', 'prevPeriodStart': '2026-09-01', 'prevPeriodEnd': '2026-09-07', 'coreIndex': 'CPI USD <= 3'}
+            def api(command, body, out):
+                # 替身核对生产 shortcut/请求体，并像 CLI 一样落盘基础回包。
+                self.assertEqual(command[0], 'biz-line-metrics' if command[1] in ('+facebook-dimension', '+facebook-metrics') else 'biz-line')
+                if command[1] == '+list':
+                    self.assertEqual(body['idList'], [1])
+                    env = {'ok': True, 'data': {'result': [biz], 'total': 1}}
+                elif command[1] == '+detail':
+                    env = {'ok': True, 'data': biz}
+                elif command[1] == '+project-list':
+                    env = {'ok': True, 'data': [{'projectName': '样本项目', 'adAccounts': [{'adAccountId': 'fixture', 'channelName': 'Facebook'}]}]}
+                else:
+                    self.assertIn(command[1], ('+facebook-dimension', '+facebook-metrics'))
+                    self.assertEqual(body['dimensionValues'], {'account_id': ['fixture']})
+                    self.assertEqual(body['size'], 1000)
+                    current = body['startDate'] == args.curr_start
+                    self.assertIn((body['startDate'], body['endDate']), [(args.curr_start, args.curr_end), (args.prev_start, args.prev_end)])
+                    dim = body['dimensions']
+                    daily_scope = command[1] == '+facebook-metrics' and len(dim) > 1 and dim[-1] == 'calendar_date'
+                    if command[1] == '+facebook-metrics' and dim not in (['account_id'], ['calendar_date']):
+                        self.assertTrue(daily_scope)
+                        dim = dim[:-1]
+                    metrics = {'spend_usd': 100, 'installs': 50 if current else 25, 'impressions': 10000, 'clicks': 500, 'purchase': 10, 'purchase_value': 300}
+                    rows = []
+                    if dim == ['account_id']:
+                        rows = [metrics]
+                    elif dim == ['calendar_date']:
+                        first, count = (8, 6) if current else (1, 7)
+                        rows = [{**metrics, 'calendar_date': f'2026-09-{d:02d}'} for d in range(first, first + count)]
+                    elif dim == ['ad_id', 'ad_name'] or dim == ['adgroup_id', 'adgroup_name']:
+                        rows = [{**metrics, dim[0]: str(i), dim[1]: '同名'} for i in (1, 2)] if current else []
+                    elif dim == ['objective']:
+                        rows = [{**metrics, 'objective': '应用推广'}]
+                    elif dim == ['country_code']:
+                        rows = [{**metrics, 'country_code': 'US'}]
+                    elif dim[0] == 'calendar_date':
+                        rows = [{'adgroup_id': '1', 'adgroup_name': '同名', 'calendar_date': f'2026-09-{d:02d}', 'bid_amount': bid} for d, bid in ((8, 1), (9, 2), (10, 1))]
+                    if daily_scope:
+                        # 按日拆分保留范围合计，证明真实请求携带日期且样本日来自新增行。
+                        rows = [{**row, **{key: row[key] / 3 for key in metrics},
+                                 'calendar_date': f'2026-09-{day:02d}'}
+                                for row in rows for day in ((8, 9, 10) if current else (1, 2, 3))]
+                    env = {'ok': True, 'data': {'data': rows, 'total': len(rows)}}
+                out.parent.mkdir(parents=True, exist_ok=True)
+                out.write_text(json.dumps(env, ensure_ascii=False), encoding='utf-8')
+                return env
+            with patch('fetch_data.run_cli', api), cli_context(threading.Event(), lambda _: None):
+                fetch_business(args)
+            payload, summary = summarize_request(root)
+            self.assertEqual(summary['overall_cpi'], [2, 4])
+            self.assertEqual(payload['rows'][0]['adAccounts'], 'Meta：\nfixture')
+            self.assertEqual(summary['spend_verdict'], '有效')
+            budget_detail = next(item for item in payload['details'] if item['kind'] == '预算')
+            self.assertEqual((budget_detail['action'], budget_detail['id'], budget_detail['name']),
+                             ('持续', 'fb', 'Meta'))
+            self.assertEqual(budget_detail['cpi'], '2.00（上期：4.00）')
+            ad_detail = next(item for item in payload['details'] if item['kind'] == '广告' and item['id'] == '1')
+            self.assertEqual((ad_detail['action'], ad_detail['name'], ad_detail['cpi']),
+                             ('新增', '同名', '2.00'))
+            self.assertEqual(ad_detail['extra'], '')
+            # 有账号但无消耗仍展示；账号覆盖结果是渠道范围的唯一依据。
+            project_path = root / 'projects.json'
+            saved_projects = project_path.read_text(encoding='utf-8')
+            project_data = json.loads(saved_projects)
+            project_data['accounts']['tt'] = ['zero-spend-fixture']
+            project_path.write_text(json.dumps(project_data), encoding='utf-8')
+            zero_payload, _ = summarize_request(root)
+            self.assertIn('TikTok：$0 → $0', zero_payload['rows'][0]['budgetStrategy'])
+            # 分析账号覆盖不改变业务线的全量账号展示。
+            self.assertEqual(zero_payload['rows'][0]['adAccounts'], 'Meta：\nfixture')
+            project_path.write_text(saved_projects, encoding='utf-8')
+
+            row = payload['rows'][0]
+            for strategy in ('budget', 'product', 'audience', 'creative'):
+                self.assertTrue(row[strategy + 'Strategy'].startswith('总结：'))
+                self.assertNotIn('TikTok', row[strategy + 'Strategy'])
+                self.assertNotIn('Google', row[strategy + 'Strategy'])
+                self.assertNotIn('暂停 0 个', row[strategy + 'Strategy'])
+                self.assertNotIn('新增 0 个', row[strategy + 'Strategy'])
+            self.assertIn('预算分配', row['budgetStrategy'].split('\n')[0])
+            self.assertIn('广告目标', row['productStrategy'].split('\n')[0])
+            self.assertIn('定向', row['audienceStrategy'].split('\n')[0])
+            self.assertIn('创意', row['creativeStrategy'].split('\n')[0])
+            self.assertIn('本期合计消耗 $200.00，占该渠道同期消耗 200.0%', row['audienceStrategy'])
+            self.assertNotIn('100.0% → 100.0%', row['productStrategy'])
+            self.assertIn('Meta：\n', row['productStrategy'])
+            self.assertIn('KPI目标 <= 1', row['budgetLearning'])
+            self.assertIn('本期 2.00，上期总体 4.00，环比 -50.00%', row['budgetLearning'])
+            self.assertIn('广告组新增合计：CPI 本期 2.00', row['audienceLearning'])
+            self.assertIn('广告新增合计：CPI 本期 2.00', row['creativeLearning'])
+            self.assertNotIn('999', row['budgetLearning'])
+            # 覆盖配置只作用于相同ID；无匹配覆盖时退回业务线字段。
+            (root / 'analysis-settings.json').write_text(json.dumps({'bizLineId': 2, 'coreIndex': 'CPI <= 999'}), encoding='utf-8')
+            default_payload, _ = summarize_request(root)
+            self.assertIn('KPI目标 <= 3', default_payload['rows'][0]['budgetLearning'])
+            self.assertNotIn(biz['coreIndex'], json.dumps(payload, ensure_ascii=False))
+            for key in ('budget', 'product', 'audience', 'creative'):
+                expected = {'budget': '结论：有效\n说明：策略有效',
+                            'product': '结论：待观察\n说明：数据不足，暂无法判断'}
+                self.assertTrue(row[key + 'Learning'].startswith(expected.get(key, '结论：有效\n说明：策略有效')))
+                self.assertEqual(row[key + 'Effect'], 3 if key == 'product' else 1)
+                for forbidden in ('本期新出现', '本期未出现', '命名规律', '跳过。', '完整内容见'):
+                    self.assertNotIn(forbidden, row[key + 'Strategy'])
+            self.assertIn('环比', row['budgetStrategy'])
+            self.assertNotIn('同名', row['budgetStrategy'])
+            budget_block = row['budgetStrategy'].split('【预算】\n', 1)[1]
+            self.assertTrue(budget_block.startswith('消耗合计：'))
+            self.assertLess(budget_block.index('消耗合计：'), budget_block.index('Meta：'))
+            self.assertIn('新增 2 个：同名、同名', row['audienceStrategy'])
+            self.assertIn('新增 2 个：同名、同名', row['creativeStrategy'])
+            self.assertNotIn('分布在', row['creativeStrategy'])
+            # 集成验证：新增广告/广告组没有上期同值且阈值不达标，仍对比上期总体CPI=4。
+            (root / 'biz-line.json').write_text(json.dumps({**biz, 'coreIndex': 'CPI <= 1'}), encoding='utf-8')
+            benchmark_payload, _ = summarize_request(root)
+            for key in ('budget', 'audience', 'creative'):
+                self.assertEqual(benchmark_payload['rows'][0][key + 'Effect'], 1)
+            (root / 'biz-line.json').write_text(json.dumps(biz), encoding='utf-8')
+            # 总体改善不能覆盖新增素材的较差成效；仅修改素材范围保持其他范围原样。
+            ad_path = root / 'bl-1/met_fb_curr_ad_id+ad_name.p1.out.json'
+            original_ad = ad_path.read_text(encoding='utf-8')
+            ad_envelope = json.loads(original_ad)
+            for record in ad_envelope['data']['data']:
+                record['installs'] = 4
+            ad_path.write_text(json.dumps(ad_envelope), encoding='utf-8')
+            separate_payload, _ = summarize_request(root)
+            separate = separate_payload['rows'][0]
+            self.assertEqual(separate['budgetEffect'], 1)
+            self.assertEqual(separate['audienceEffect'], 1)
+            self.assertEqual(separate['creativeEffect'], 2)
+            self.assertTrue(separate['creativeLearning'].startswith('结论：无效\n说明：需关停'))
+            ad_path.write_text(original_ad, encoding='utf-8')
+            # 同一广告维度一半枚举单独不达标，合计基础值后 CPI 仍改善：按维度判有效。
+            mixed_ad = json.loads(original_ad)
+            for record in mixed_ad['data']['data']:
+                record['installs'] = (20 if record['ad_id'] == '1' else 100) / 3
+            ad_path.write_text(json.dumps(mixed_ad), encoding='utf-8')
+            mixed_payload, _ = summarize_request(root)
+            self.assertEqual(mixed_payload['rows'][0]['creativeEffect'], 1)
+            self.assertIn('广告新增合计：CPI 本期 1.67', mixed_payload['rows'][0]['creativeLearning'])
+            ad_path.write_text(original_ad, encoding='utf-8')
+            self.assertIn('消耗 $', row['productStrategy'])
+            self.assertTrue(any(item['kind'] == '广告组' for item in payload['details']))
+            self.assertTrue(all('/分布' not in item['kind'] and '新增成效' not in item['kind']
+                                for item in payload['details']))
+            self.assertTrue(all(item['action'] in ('新增', '暂停', '持续')
+                                for item in payload['details'] if item['kind'] != '出价'))
+
+            # 真实分析入口保证四类 learning 均使用配置失败原因，效果统一待观察。
+            for core, note in [('', '核心指标为空'), ('留存与激活组合目标', '核心指标不支持')]:
+                changed_biz = {**biz, 'coreIndex': core}
+                (root / 'biz-line.json').write_text(json.dumps(changed_biz), encoding='utf-8')
+                (root / 'biz-line-detail.out.json').write_text(json.dumps({'data': changed_biz}), encoding='utf-8')
+                changed_payload, _ = summarize_request(root)
+                for key in ('budget', 'product', 'audience', 'creative'):
+                    self.assertTrue(changed_payload['rows'][0][key + 'Learning'].startswith(f'结论：待观察\n说明：{note}'))
+                    self.assertEqual(changed_payload['rows'][0][key + 'Effect'], 3)
+
+            # 上期请求日期仍存在，但实际记录为空时四类均应使用本期阈值。
+            prev_stem = 'met_fb_prev_account_id'
+            (root / 'bl-1' / (prev_stem + '.p1.out.json')).write_text(
+                json.dumps({'ok': True, 'data': {'data': [], 'total': 0}}), encoding='utf-8')
+            (root / 'bl-1' / (prev_stem + '.pages.json')).write_text(
+                json.dumps({'total': 0, 'pages': 1, 'counts': [0]}), encoding='utf-8')
+            manifest_path = root / 'fetch-manifest.json'
+            manifest = json.loads(manifest_path.read_text(encoding='utf-8'))
+            manifest[prev_stem] = 0
+            manifest_path.write_text(json.dumps(manifest), encoding='utf-8')
+            for core, verdict, note, effect in [('安装量 >= 50', '有效', '核心指标达标', 1),
+                                                 ('安装量 >= 51', '无效', '核心指标未达标', 2),
+                                                 ('安装量', '待观察', '数据不足，暂无法判断', 3)]:
+                changed_biz = {**biz, 'coreIndex': core}
+                (root / 'biz-line.json').write_text(json.dumps(changed_biz), encoding='utf-8')
+                changed_payload, _ = summarize_request(root)
+                for key in ('budget',):
+                    self.assertTrue(changed_payload['rows'][0][key + 'Learning'].startswith(f'结论：{verdict}\n说明：{note}'))
+                    self.assertEqual(changed_payload['rows'][0][key + 'Effect'], effect)
+
+            self.assertIn('覆盖不完整', payload['rows'][0]['period'])
+            for kind in ('广告', '广告组'):
+                objects = [r for r in payload['details'] if r['kind'] == kind]
+                self.assertEqual(len(objects), 2)
+                self.assertEqual(objects[0]['id'], '1')
+                self.assertEqual(objects[1]['id'], '2')
+                self.assertTrue(all(not item['extra'] for item in objects))
+            bid = next(r for r in payload['details'] if r['kind'] == '出价')
+            self.assertNotEqual(bid['action'], '下调')
+            self.assertEqual(bid['id'], '1')
+            self.assertIn('bid_amount 1 → 1', bid['extra'])
+            # 汇总前损坏已完成的分页索引必须失败，不能重新退回第一页继续。
+            (root / "bl-1/met_fb_curr_account_id.pages.json").write_text(
+                json.dumps({"total": 0, "pages": 0, "counts": []}), encoding="utf-8"
+            )
+            with self.assertRaises(ValueError):
+                summarize_request(root)
+
+
+class CleanupAndExport(unittest.TestCase):
+    """真实文件验证不同扩展名、链接目标、锁失败和最终 Excel 保护。"""
+
+    def test_all_types_and_final_protected(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            owned = OwnedDirectory.create(root, 'owned-')
+            final = root / 'final.xlsx'
+            final.write_text('final')
+            history = root / 'history.json'
+            history.write_text('history')
+            for name in ('raw.json', 'preview.png', 'temp.xlsx', 'run.py', 'log.txt', 'no-extension'):
+                (owned.path / name).write_text('temp')
+            (owned.path / 'cache').mkdir()
+            (owned.path / 'cache/a.pyc').write_bytes(b'cache')
+            self.assertTrue(owned.cleanup(final)['ok'])
+            self.assertFalse(owned.path.exists())
+            self.assertTrue(final.exists() and history.exists())
+
+    def test_final_inside_and_forged_owner_refused(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            owned = OwnedDirectory.create(Path(tmp), 'owned-')
+            self.assertFalse(owned.cleanup(owned.path / 'final.xlsx')['ok'])
+            fake = OwnedDirectory(owned.path, owned.parent, 'wrong')
+            self.assertFalse(fake.cleanup()['ok'])
+            self.assertTrue(owned.cleanup()['ok'])
+
+    def test_external_junction_or_symlink_target_survives(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            outside = root / 'external'
+            outside.mkdir()
+            (outside / 'keep').write_text('keep')
+            owned = OwnedDirectory.create(root, 'owned-')
+            link = owned.path / 'link'
+            if os.name == 'nt':
+                # 仅建立受控测试路径的 junction，不通过 shell 执行任何删除。
+                subprocess.run(['cmd', '/c', 'mklink', '/J', str(link), str(outside)], check=True, stdout=subprocess.DEVNULL)
+            else:
+                link.symlink_to(outside, target_is_directory=True)
+            self.assertTrue(owned.cleanup()['ok'])
+            self.assertEqual((outside / 'keep').read_text(), 'keep')
+
+    def test_delete_error_reported(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            owned = OwnedDirectory.create(Path(tmp), 'owned-')
+            (owned.path / 'locked').write_text('locked')
+            real_unlink = Path.unlink
+            def locked(path, *args, **kwargs):
+                if path.name == 'locked':
+                    raise PermissionError('file in use')
+                return real_unlink(path, *args, **kwargs)
+            with patch.object(Path, 'unlink', locked):
+                result = owned.cleanup()
+            self.assertFalse(result['ok'])
+            self.assertIn('locked', str(result['residual']))
+            self.assertTrue(owned.cleanup()['ok'])
+
+    def test_long_text_full_export_and_no_overwrite(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            payload = small_payload()
+            long_text = '完整说明与特殊字符 <&>\n' * 500
+            payload['details'][0]['extra'] = long_text
+            payload['rows'][0]['budgetStrategy'] = long_text
+            path = Path(tmp) / 'out.xlsx'
+            # 汇总不能静默截断；超长逐条信息必须放入明细。
+            prepared_long, _ = prepare_layout(payload['rows'], payload['details'])
+            self.assertEqual(''.join(r.get('budgetStrategy', '') for r in prepared_long), long_text)
+            self.assertEqual(len(prepared_long), 1)
+            # 超过可见行高仍只有一条业务线，保存值完整；不生成策略续行。
+            payload['rows'][0]['budgetStrategy'] = '枚举及消耗环比\n' * 60
+            single_row_path = Path(tmp) / 'single-row.xlsx'
+            write_xlsx(payload['rows'], str(single_row_path), payload['details'])
+            self.assertEqual(validate_xlsx(single_row_path, payload['rows'], payload['details'])['rows'], 1)
+            payload['rows'][0]['budgetStrategy'] = '【预算】\n' + ('渠道汇总：消耗 $100 → $120，占比 50% → 60%；环比 +20%\n' * 18) + '【调整出价】\n分布在：英语（3个）'
+            prepared, _ = prepare_layout(payload['rows'], payload['details'])
+            self.assertEqual(prepared[0]['budgetStrategy'], payload['rows'][0]['budgetStrategy'])
+            write_xlsx(payload['rows'], str(path), payload['details'])
+            counts = validate_xlsx(path, payload['rows'], payload['details'])
+            self.assertEqual(counts['details'], 1)
+            _, details = prepare_layout(payload['rows'], payload['details'])
+            self.assertEqual(''.join(r['extra'] for r in details if r['kind'] == '出价'), long_text)
+            self.assertNotIn('[续', details[0]['action'])
+            payload['details'][0]['extra'] = '过长' * 17000
+            with self.assertRaises(ValueError):
+                write_xlsx(payload['rows'], str(Path(tmp) / 'too-long.xlsx'), payload['details'])
+            payload['details'][0]['extra'] = long_text
+            with self.assertRaises(FileExistsError):
+                write_xlsx(payload['rows'], str(path), payload['details'])
+            final = Path(tmp) / 'final.xlsx'
+            final.write_bytes(b'existing')
+            with self.assertRaises(FileExistsError):
+                publish(path, final, payload)
+            self.assertEqual(final.read_bytes(), b'existing')
+            with self.assertRaises(ValueError):
+                validate_xlsx(path, small_payload()['rows'], [])
+
+
+class BatchExecution(unittest.TestCase):
+    """通过阻塞屏障验证实际重叠、即时交付以及任务隔离。"""
+
+    def setUp(self):
+        """离线固定字典，业务线并发测试不触发网关。"""
+        mocked = patch('strategy_output.load_tags', return_value={key: [{'id': index, 'name': '其他'}]
+                       for index, key in enumerate(('budget', 'product', 'audience'), 1)})
+        mocked.start()
+        self.addCleanup(mocked.stop)
+        # 离线工作流用已分析选择替代 Agent，语义交接协议另有真实文件测试。
+        review = patch('run_workflow.review_tags', side_effect=lambda row, dictionaries, *args, **kwargs:
+                       {key: [{'id': labels[0]['id'], 'reason': '样本仅提供其他标签'}]
+                        for key, labels in dictionaries.items()})
+        review.start()
+        self.addCleanup(review.stop)
+        # 批次调度旧测试只关心拉数/重试边界；AI 文件交接由独立测试覆盖。
+        ai_review = patch('run_workflow.review_ai_strategy', return_value=(
+            '一页速览\n- 样本。\n【预算策略】\n- 样本。\n【广告产品策略】\n- 样本。\n'
+            '【受众策略】\n- 样本。\n【创意策略】\n- 样本。'))
+        ai_review.start()
+        self.addCleanup(ai_review.stop)
+
+    def test_retries_wait_for_whole_round_and_stop_at_three(self):
+        """快失败不能抢跑下一轮；恢复后不重跑，永久失败含首次只能三次。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            completed, counts, lock = [], {}, threading.Lock()
+            events = []
+            def worker(target, args, batch, cancel, progress):
+                with lock:
+                    counts[target] = counts.get(target, 0) + 1
+                    attempt = counts[target]
+                    self.assertEqual(args.attempt, attempt)
+                    if attempt == 2:
+                        self.assertTrue({(1, 1), (2, 1), (3, 1)} <= set(completed))
+                    if attempt == 3:
+                        self.assertIn((2, 2), completed)
+                time.sleep(0.05 if target == 3 else 0.001)
+                with lock:
+                    completed.append((target, attempt))
+                return {'id': target, 'ok': target == 3 or (target == 2 and attempt == 2)}
+            result = run_batch(arguments(Path(tmp), [1, 2, 3]), worker=worker,
+                               progress=events.append, temp_parent=Path(tmp))
+            self.assertEqual(counts, {1: 3, 2: 2, 3: 1})
+            self.assertEqual((result['success'], result['failed']), (2, 1))
+            self.assertEqual([r['attempts'] for r in result['results']], [3, 2, 1])
+            self.assertEqual(len(result['results'][0]['attempt_history']), 3)
+            self.assertEqual([e['targets'] for e in events if e.get('event') == 'retry_round'], [[1, 2], [1]])
+
+    def test_cancel_after_failure_does_not_start_retry(self):
+        """用户取消优先于补跑；未启动条目不消失。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            cancel = threading.Event()
+            args = arguments(Path(tmp), [1, 2])
+            args.concurrency = 1
+            def worker(target, args, batch, cancel, progress):
+                cancel.set()
+                return {'id': target, 'ok': False}
+            result = run_batch(args, cancel=cancel, worker=worker, progress=lambda _: None, temp_parent=Path(tmp))
+            self.assertEqual([r['attempts'] for r in result['results']], [1, 0])
+            self.assertEqual(result['failed'], 2)
+
+    def test_round_resets_only_failed_tag_cache(self):
+        """真实标签缓存首轮失败后恢复；已成功的另一行业无需再查。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            calls = []
+            def tags(root, condition):
+                calls.append(condition)
+                if condition == '11' and calls.count('11') == 1:
+                    raise RuntimeError('临时错误')
+                return {'budget': []}
+            def worker(target, args, batch, cancel, progress):
+                try:
+                    args.tag_cache.get({'adCategoryIndustryIds': [22]})
+                    args.tag_cache.get({'adCategoryIndustryIds': [11]})
+                    return {'id': target, 'ok': True}
+                except RuntimeError:
+                    return {'id': target, 'ok': False}
+            with patch('strategy_output.load_tags', tags):
+                result = run_batch(arguments(Path(tmp)), worker=worker, progress=lambda _: None, temp_parent=Path(tmp))
+            self.assertTrue(result['ok'])
+            self.assertEqual(calls, ['22', '11', '11'])
+            self.assertEqual(result['results'][0]['attempts'], 2)
+
+    def test_unsplit_workers_keep_fetch_cap_and_deduplicate(self):
+        """未交接AI阶段的替代worker一直占拉数名额，仍应限制3条并去重。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            args = arguments(root / 'output', list(range(1, 11)) + [1])
+            barrier = threading.Barrier(3)
+            lock = threading.Lock()
+            active = peak = 0
+            observed = []
+            def worker(target, args, batch, cancel, progress):
+                nonlocal active, peak
+                with lock:
+                    active += 1
+                    peak = max(peak, active)
+                owned = OwnedDirectory.create(batch.path, f'line-{target}-')
+                if target <= 3:
+                    barrier.wait(timeout=5)
+                time.sleep(0.02 if target != 1 else 0.12)
+                cleanup = owned.cleanup()
+                with lock:
+                    active -= 1
+                return {'id': target, 'ok': True, 'cleanup': cleanup}
+            result = run_batch(args, worker=worker, progress=observed.append, temp_parent=root)
+            self.assertTrue(result['ok'])
+            self.assertEqual(result['success'], 10)
+            self.assertEqual(peak, 3)
+            self.assertNotEqual(observed[0]['id'], 1)
+            self.assertFalse(list(root.rglob('batch-*')))
+
+    def test_mixed_real_worker_results_cleanup_immediate(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            args = arguments(root / 'output', [1, 2, 3])
+            def fetch(local):
+                (Path(local.request_dir) / 'fixture.json').write_text('{}')
+                if local.id == 2:
+                    raise RuntimeError('fixture fetch failed')
+                return {'id': local.id, 'name': '同名', 'adCategoryIndustryIds': [11]}
+            def summarize(root):
+                payload = small_payload()
+                (root / 'payload.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
+                return payload, {'detail_count': 1}
+            with patch('run_workflow.fetch_business', fetch), patch('run_workflow.summarize_request', side_effect=summarize):
+                result = run_batch(args, progress=lambda _: None, temp_parent=root)
+            self.assertFalse(result['ok'])
+            self.assertEqual(result['success'], 2)
+            self.assertEqual(len(list((root / 'output').glob('*.xlsx'))), 2)
+            self.assertFalse(list(root.rglob('batch-*')))
+            self.assertIn('fixture fetch failed', str(result))
+
+    def test_invalid_concurrency_before_creating_directory(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            args = arguments(Path(tmp) / 'output')
+            args.concurrency = 4
+            with self.assertRaises(ValueError):
+                run_batch(args, temp_parent=Path(tmp))
+            self.assertFalse(list(Path(tmp).iterdir()))
+
+    def test_cleanup_failure_keeps_final_and_fails_batch(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            real_cleanup = OwnedDirectory.cleanup
+            def locked_cleanup(owned, final=None):
+                if owned.path.name.startswith('line-1-'):
+                    return {'ok': False, 'residual': [{'path': str(owned.path), 'error': 'fixture locked'}]}
+                return real_cleanup(owned, final)
+            def summarize(root):
+                payload = small_payload()
+                (root / 'payload.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
+                return payload, {'detail_count': 1}
+            with patch('run_workflow.fetch_business', return_value={'id': 1, 'name': '样本', 'adCategoryIndustryIds': [11]}), patch('run_workflow.summarize_request', side_effect=summarize), patch.object(OwnedDirectory, 'cleanup', locked_cleanup):
+                result = run_batch(arguments(root / 'output'), progress=lambda _: None, temp_parent=root)
+            self.assertFalse(result['ok'])
+            self.assertTrue(Path(result['results'][0]['output_path']).is_file())
+            self.assertTrue(result['results'][0]['cleanup_failed'])
+            self.assertTrue(result['cleanup']['residual'])
+
+    def test_cancel_terminates_cli_and_cleans(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            cancel = threading.Event()
+            timer = threading.Timer(0.15, cancel.set)
+            timer.start()
+            try:
+                with cli_context(cancel, lambda _: None):
+                    with self.assertRaises(InterruptedError):
+                        exec_cli_to_file([sys.executable, '-c', 'import time; time.sleep(30)'], Path(tmp) / 'cancel.out.json')
+            finally:
+                timer.join()
+            # 子进程退出后输出文件可立即独占打开，证明不持有清理所需句柄。
+            with (Path(tmp) / 'cancel.out.json').open('wb') as stream:
+                stream.write(b'closed')
+            args = arguments(Path(tmp) / 'output', [1, 2, 3, 4])
+            result = run_batch(args, cancel=cancel, progress=lambda _: None, temp_parent=Path(tmp))
+            self.assertEqual(result['failed'], 4)
+            self.assertFalse(list(Path(tmp).rglob('batch-*')))
+
+
+class ConfigurationAndRoot(unittest.TestCase):
+    """配置失败不重跑，目录固定在明确的工作根内。"""
+
+    def test_missing_industry_saves_once_and_other_line_continues(self):
+        """使用真实fetch及批次入口，缺行业时不取项目，另一条仍正常预检。"""
+        calls, saves = [], []
+        def query(command, body, output):
+            calls.append((command, body))
+            ident = body['idList'][0]
+            return {'ok': True, 'data': {'total': 1, 'result': [
+                {'id': ident, 'name': '样本', 'projectIds': [],
+                 'adCategoryIndustryIds': [] if ident == 1 else [11]}]}}
+        def save(root, body):
+            saves.append(body)
+            return 10 + body['bizLineId']
+        with tempfile.TemporaryDirectory() as tmp:
+            args = arguments(Path(tmp)/'output', [1, 2])
+            args.output_mode, args.output_dir = 'database', None
+            args.curr_start, args.curr_end = '2026-09-07', '2026-09-13'
+            with patch('fetch_data.run_cli', query), patch('strategy_output.load_tags', return_value={}), \
+                 patch('strategy_output.run_cli', return_value={'ok': True, 'data': {'total': 0, 'result': []}}) as projects, \
+                 patch('run_workflow.save_result', save):
+                result = run_batch(args, temp_parent=Path(tmp), progress=lambda _: None)
+            self.assertEqual(len(calls), 2)
+            self.assertEqual(projects.call_count, 1)
+            self.assertEqual(len(saves), 2)
+            failed, other = result['results']
+            self.assertEqual(failed['attempts'], 1)
+            self.assertFalse(failed['ok'])
+            self.assertFalse(failed['retryable'])
+            self.assertEqual(failed['generateCode'], 'GENERATION_FAILED')
+            self.assertIn('首个行业 ID', saves[0]['remark'] if saves[0]['bizLineId'] == 1 else saves[1]['remark'])
+            self.assertTrue(other['database_saved'])
+            self.assertEqual(other['generateCode'], 'NO_PROJECT')
+
+    def test_local_missing_industry_does_not_save(self):
+        """本地输出只报告配置错误，不能新增写库副作用。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            def query(command, body, output):
+                return {'ok': True, 'data': {'total': 1, 'result': [
+                    {'id': 1, 'name': '样本', 'adCategoryIndustryIds': None}]}}
+            with patch('fetch_data.run_cli', side_effect=query) as api, patch('run_workflow.save_result') as save:
+                result=run_batch(arguments(Path(tmp)/'output'), temp_parent=Path(tmp), progress=lambda _: None)
+            self.assertEqual(api.call_count, 1)
+            self.assertEqual(result['results'][0]['attempts'], 1)
+            save.assert_not_called()
+
+    def test_task_root_date_is_frozen_across_retry(self):
+        """跨午夜和业务线重试仍使用启动日期，同日期其他批次不被清理。"""
+        seen=[]
+        with tempfile.TemporaryDirectory() as tmp:
+            task_root=Path(tmp)/'durable'
+            history=task_root/'strategy_task'/'2026-10-13'/'tmp'/'other-batch'
+            history.mkdir(parents=True)
+            (history/'keep.txt').write_text('保留',encoding='utf-8')
+            args=arguments(Path(tmp)/'output')
+            args.task_root=str(task_root)
+            def worker(target,args,batch,cancel,progress):
+                seen.append(batch.path)
+                return {'id':target,'ok':args.attempt==2}
+            with patch('run_workflow.date') as dates:
+                dates.today.side_effect=[date(2026,10,13),date(2026,10,14)]
+                result=run_batch(args,worker=worker,progress=lambda _:None)
+                self.assertEqual(dates.today.call_count,1)
+            self.assertTrue(result['ok'])
+            self.assertEqual(seen[0],seen[1])
+            self.assertEqual(seen[0].parent,history.parent.resolve())
+            self.assertEqual([item.resolve() for item in history.parent.iterdir()],[history.resolve()])
+
+    def test_default_root_and_relative_override(self):
+        """默认cwd与相对工作根都解析成固定绝对路径。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            for override,expected in ((None,Path(tmp)),('persist',Path(tmp)/'persist')):
+                args=arguments(Path(tmp)/'output')
+                args.task_root=override
+                roots=[]
+                def worker(target,args,batch,cancel,progress):
+                    roots.append(batch.path)
+                    return {'id':target,'ok':True}
+                with patch('run_workflow.Path.cwd',return_value=Path(tmp)):
+                    run_batch(args,worker=worker,progress=lambda _:None)
+                self.assertEqual(roots[0].parents[3],expected.resolve())
+
+    def test_bad_root_does_not_fall_back_to_temp(self):
+        """空根或已存在普通文件的根不能悄悄回退系统TEMP。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            for bad in ('',str(Path(tmp)/'file')):
+                Path(tmp,'file').write_text('普通文件',encoding='utf-8')
+                args=arguments(Path(tmp)/'output')
+                args.task_root=bad
+                with self.assertRaises((ValueError,OSError)):
+                    run_batch(args,worker=lambda *a: {'ok':True},progress=lambda _:None)
+            parsed=workflow_parser().parse_args(['--id','1','--task-root',tmp])
+            self.assertEqual(parsed.task_root,tmp)
+
+    def test_task_root_cannot_write_inside_expert_skill(self):
+        """安装技能树保持只读，不能因在技能目录启动而写入缓存。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            args=arguments(Path(tmp)/'output')
+            args.task_root=str(Path(__file__).resolve().parent.parent)
+            with self.assertRaisesRegex(ValueError,'安装技能'):
+                run_batch(args,worker=lambda *a:{'ok':True},progress=lambda _:None)
+
+    def test_task_root_link_cannot_redirect_into_expert_skill(self):
+        """解析完整任务路径，拒绝中间链接把临时文件引向安装技能树。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            task_root, skill_root = root / 'durable', root / 'skill'
+            task_root.mkdir()
+            skill_root.mkdir()
+            link = task_root / 'strategy_task'
+            if os.name == 'nt':
+                # Windows junction 不要求开发者模式，验证真实目录重定向。
+                import _winapi
+                _winapi.CreateJunction(str(skill_root), str(link))
+            else:
+                link.symlink_to(skill_root, target_is_directory=True)
+            args = arguments(root / 'output')
+            args.task_root = str(task_root)
+            with patch('run_workflow.__file__', str(skill_root / 'scripts' / 'run_workflow.py')):
+                with self.assertRaisesRegex(ValueError, '安装技能'):
+                    run_batch(args, worker=lambda *a: {'ok': True}, progress=lambda _: None)
+
+
+if __name__ == "__main__":
+    unittest.main()