sino-bc-cli 1.0.0-beta.0

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

@@ -0,0 +1,904 @@
+"""数据库输出离线回归：使用真实工作流和替代 CLI，不访问生产数据。"""
+import json
+import sys
+import tempfile
+import threading
+import unittest
+import zipfile
+from pathlib import Path
+from unittest.mock import patch
+from xml.etree import ElementTree as ET
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from strategy_output import GenerationOutcome, precheck_projects, ready_body, save_result, validate_period
+from strategy_output import (load_tags, effect_code, TagCache, industry_condition, split_ai_learning,
+                             choice_key, submit_tag_choices)
+from concurrent.futures import ThreadPoolExecutor
+from run_workflow import run_batch, workflow_parser
+from test_workflow import arguments, small_payload
+from fetch_data import fetch_business, load_projects, resolve_periods
+from datetime import date
+from argparse import Namespace
+
+
+class TagReviewProtocol(unittest.TestCase):
+    """标签审核必须绑定业务线与本次尝试，同行业同标签也不能串线。"""
+
+    def setUp(self):
+        self.row = {key + 'Strategy': f'{key} 完整策略正文：新增互动目标与国家'
+                    for key in ('budget', 'product', 'audience')}
+        self.dictionaries = {key: [{
+            'id': index, 'name': f'{key}具体标签', 'description': '与正文动作对应',
+            'itemCode': '', 'isEnable': 1, 'isOther': 0, 'sortOrder': 0, 'children': None,
+        }, {'id': index + 10, 'name': '其他', 'description': '', 'isOther': 1}]
+            for index, key in enumerate(('budget', 'product', 'audience'), 1)}
+
+    def response_for(self, request):
+        """测试回包只从当前请求取身份和当前场景候选，模拟正确 Agent。"""
+        return {key: request[key] for key in ('bizLineId', 'attempt', 'reviewId')} | {
+            'selections': {key: [{'id': item['labels'][0]['id'],
+                                 'choiceKey': item['labels'][0]['choiceKey'], 'reason': '正文明确出现对应动作'}]
+                           for key, item in request['strategies'].items()},
+        }
+
+    def test_bound_response_is_compact_and_timed(self):
+        """保留全部正文与候选，去掉空白管理字段并输出可核对的审核耗时。"""
+        from strategy_output import review_tags
+        events = []
+        with tempfile.TemporaryDirectory() as tmp:
+            def progress(event):
+                events.append(event)
+                if event.get('event') != 'tag_review_required':
+                    return
+                request = json.loads(Path(event['request_path']).read_text(encoding='utf-8'))
+                self.assertEqual((request['bizLineId'], request['attempt'], request['reviewId']),
+                                 (340, 2, event['reviewId']))
+                self.assertEqual(request['strategies']['budget']['strategy'], self.row['budgetStrategy'])
+                self.assertEqual(len(request['strategies']['budget']['labels']), 2)
+                self.assertEqual(request['strategies']['budget']['labels'][0], {
+                    'id': 1, 'name': 'budget具体标签', 'description': '与正文动作对应', 'isOther': 0,
+                    'choiceKey': choice_key(request['reviewId'], 'budget', 1),
+                })
+                self.assertEqual(request['strategies']['budget']['labels'][1], {
+                    'id': 11, 'name': '其他', 'isOther': 1,
+                    'choiceKey': choice_key(request['reviewId'], 'budget', 11),
+                })
+                selected = {'selections': {key: [{'choiceKey': item['labels'][0]['choiceKey'],
+                                                  'reason': '正文明确出现对应动作'}]
+                                            for key, item in request['strategies'].items()}}
+                submit_tag_choices(event['request_path'], event['reviewId'], selected)
+            choices = review_tags(self.row, self.dictionaries, {}, Path(tmp), threading.Event(), progress,
+                                  biz_line_id=340, attempt=2)
+        self.assertEqual(choices['budget'][0]['id'], 1)
+        self.assertTrue(events[0]['issuedAt'].endswith('Z'))
+        self.assertEqual(events[-1]['event'], 'tag_review_accepted')
+        self.assertGreaterEqual(events[-1]['waitSeconds'], 0)
+
+    def test_same_industry_concurrent_responses_cannot_cross(self):
+        """并发错投不会被接受；两次后各线只拿本场景真实的其他标签。"""
+        from strategy_output import review_tags
+        barrier = threading.Barrier(3)
+        lock = threading.Lock()
+        events = {}
+        with tempfile.TemporaryDirectory() as tmp:
+            def run(ident):
+                root = Path(tmp) / str(ident)
+                root.mkdir()
+                def progress(event):
+                    if event.get('event') != 'tag_review_required':
+                        return
+                    with lock:
+                        events[(ident, event['reviewAttempt'])] = event
+                    barrier.wait(timeout=5)
+                    recipient = 340 + (ident - 339) % 3
+                    request = json.loads(Path(event['request_path']).read_text(encoding='utf-8'))
+                    Path(events[(recipient, event['reviewAttempt'])]['response_path']).write_text(
+                        json.dumps(self.response_for(request)), encoding='utf-8')
+                choices = review_tags(self.row, self.dictionaries, {}, root, threading.Event(), progress,
+                                      biz_line_id=ident, attempt=1)
+                self.assertEqual(choices['budget'][0]['id'], 11)
+            with ThreadPoolExecutor(max_workers=3) as pool:
+                list(pool.map(run, (340, 341, 342)))
+
+    def test_stale_or_missing_identity_is_rejected(self):
+        """旧轮次或旧格式回包不能用本行业合法 ID 绕过身份核对。"""
+        from strategy_output import review_tags
+        for mutation in ('old_attempt', 'old_review_id', 'missing_identity'):
+            with self.subTest(mutation=mutation), tempfile.TemporaryDirectory() as tmp:
+                def progress(event):
+                    if event.get('event') != 'tag_review_required':
+                        return
+                    request = json.loads(Path(event['request_path']).read_text(encoding='utf-8'))
+                    response = self.response_for(request)
+                    if mutation == 'old_attempt':
+                        response['attempt'] -= 1
+                    elif mutation == 'old_review_id':
+                        response['reviewId'] = 'previous-review-id'
+                    else:
+                        response.pop('reviewId')
+                    Path(event['response_path']).write_text(json.dumps(response), encoding='utf-8')
+                choices = review_tags(self.row, self.dictionaries, {}, Path(tmp), threading.Event(), progress,
+                                      biz_line_id=340, attempt=2)
+                self.assertEqual(choices['budget'][0]['id'], 11)
+
+    def test_second_review_accepts_without_reusing_first_response(self):
+        """一次拒绝后立即重新请求，第二次使用新路径与审核 ID。"""
+        from strategy_output import review_tags
+        requests, events = [], []
+        with tempfile.TemporaryDirectory() as tmp:
+            def progress(event):
+                events.append(event)
+                if event.get('event') != 'tag_review_required':
+                    return
+                request = json.loads(Path(event['request_path']).read_text(encoding='utf-8'))
+                requests.append(request)
+                reply = self.response_for(request)
+                if len(requests) == 1:
+                    reply['bizLineId'] += 1
+                else:
+                    self.assertNotEqual(requests[0]['reviewId'], request['reviewId'])
+                    self.assertNotEqual(events[0]['response_path'], event['response_path'])
+                    # 旧响应晚到时仍只能落在第一轮独立路径。
+                    Path(events[0]['response_path']).write_text(json.dumps(self.response_for(requests[0])), encoding='utf-8')
+                Path(event['response_path']).write_text(json.dumps(reply), encoding='utf-8')
+            choices = review_tags(self.row, self.dictionaries, {}, Path(tmp), threading.Event(), progress,
+                                  biz_line_id=340, attempt=1)
+        self.assertEqual(len(requests), 2)
+        self.assertEqual(choices['budget'][0]['id'], 1)
+        self.assertEqual(events[-1]['event'], 'tag_review_accepted')
+
+    def test_two_rejections_use_other_or_empty_for_each_scene(self):
+        """两次无效后只对缺其他的场景给空标签，策略正文仍保留。"""
+        from strategy_output import review_tags
+        self.dictionaries['audience'] = self.dictionaries['audience'][:1]
+        events = []
+        with tempfile.TemporaryDirectory() as tmp:
+            def progress(event):
+                events.append(event)
+                if event.get('event') == 'tag_review_required':
+                    request = json.loads(Path(event['request_path']).read_text(encoding='utf-8'))
+                    reply = self.response_for(request)
+                    reply['bizLineId'] += 1
+                    Path(event['response_path']).write_text(json.dumps(reply), encoding='utf-8')
+            choices = review_tags(self.row, self.dictionaries, {}, Path(tmp), threading.Event(), progress,
+                                  biz_line_id=340, attempt=1)
+        self.assertEqual(len([event for event in events if event['event'] == 'tag_review_required']), 2)
+        self.assertEqual(choices['budget'][0]['id'], 11)
+        self.assertEqual(choices['product'][0]['id'], 12)
+        self.assertEqual(choices['audience'], [])
+        self.assertEqual(events[-1]['event'], 'tag_review_fallback')
+        self.assertEqual(events[-1]['missingOtherScenes'], ['audience'])
+        self.assertEqual(self.row['audienceStrategy'], 'audience 完整策略正文：新增互动目标与国家')
+
+    def test_two_timeouts_then_fallback_after_seven_minutes_each(self):
+        """用模拟时钟验证每次420秒与两次上限，不真实等待。"""
+        from strategy_output import review_tags
+        clock = {'seconds': 0}
+        class NeverCancel:
+            def is_set(self):
+                return False
+            def wait(self, _):
+                clock['seconds'] += 210
+                return None
+        events = []
+        with tempfile.TemporaryDirectory() as tmp, patch('strategy_output.time.monotonic', side_effect=lambda: clock['seconds']):
+            choices = review_tags(self.row, self.dictionaries, {}, Path(tmp), NeverCancel(), events.append,
+                                  biz_line_id=340, attempt=1)
+        self.assertEqual(len([event for event in events if event['event'] == 'tag_review_required']), 2)
+        self.assertEqual(len([event for event in events if event['event'] == 'tag_review_rejected']), 2)
+        self.assertEqual(clock['seconds'], 840)
+        self.assertEqual(choices['budget'][0]['id'], 11)
+
+    def test_non_review_error_does_not_auto_fallback(self):
+        """进度输出自身故障不是标签拒绝，不能悄悄改选其他。"""
+        from strategy_output import review_tags
+        with tempfile.TemporaryDirectory() as tmp, self.assertRaisesRegex(OSError, 'progress failed'):
+            review_tags(self.row, self.dictionaries, {}, Path(tmp), threading.Event(),
+                        lambda _: (_ for _ in ()).throw(OSError('progress failed')),
+                        biz_line_id=340, attempt=1)
+
+
+class DatabaseRules(unittest.TestCase):
+    """明确业务分支及非幂等写入边界。"""
+
+    def test_content_review_handoff_and_real_tag_ids(self):
+        """真实文件协议：名称不同也能由内容分析选择，Excel 名称与入库 ID 同源。"""
+        import threading
+        from strategy_output import review_tags, attach_tags
+        row = {key + 'Strategy': '上调 5 个广告组出价，分布在 EN（5个）'
+               for key in ('budget', 'product', 'audience')}
+        dictionaries = {key: [{'id': index, 'name': '竞价增强'}, {'id': index + 10, 'name': '其他'}]
+                        for index, key in enumerate(('budget', 'product', 'audience'), 1)}
+        with tempfile.TemporaryDirectory() as tmp:
+            def respond(event):
+                if event['event'] != 'tag_review_required':
+                    return
+                request = json.loads(Path(event['request_path']).read_text(encoding='utf-8'))
+                self.assertEqual(request['strategies']['budget']['strategy'], row['budgetStrategy'])
+                self.assertEqual([item['id'] for item in request['strategies']['budget']['labels']], [1, 11])
+                selection = {key: [{'choiceKey': item['labels'][0]['choiceKey'], 'reason': '上调广告组出价对应竞价增强'}]
+                             for key, item in request['strategies'].items()}
+                submit_tag_choices(event['request_path'], event['reviewId'], {'selections': selection})
+            choices = review_tags(row, dictionaries, {}, Path(tmp), threading.Event(), respond,
+                                  biz_line_id=1, attempt=1)
+            attach_tags(row, dictionaries, {}, choices)
+            self.assertEqual(row['budgetTagIds'], [1])
+            self.assertEqual(row['budgetTags'], '竞价增强')
+
+    def test_tag_review_rejects_foreign_ids_and_other_mixed_with_match(self):
+        """不接受跨场景 ID、无理由、重复选择或具体标签同时带其他。"""
+        from strategy_output import reviewed_tags
+        labels = [{'id': 1, 'name': '拓展受众'}, {'id': 2, 'name': '其他'}]
+        for choices in ([], [{'id': 99, 'reason': '错误场景'}], [{'id': 1}],
+                        [{'id': 1, 'reason': '新增受众'}, {'id': 2, 'reason': '其他'}],
+                        [{'id': 1, 'reason': '新增受众'}, {'id': 1, 'reason': '重复'}]):
+            with self.subTest(choices=choices), self.assertRaises(ValueError):
+                reviewed_tags(labels, choices)
+        self.assertEqual(reviewed_tags(labels, [{'id': 2, 'reason': '正文未涉及受众拓展，其他标签均不适用'}]), [labels[1]])
+
+    def test_tag_review_cancellation(self):
+        """等待分析时取消可立即清理退出，不阻塞下一批。"""
+        import threading
+        from strategy_output import review_tags
+        cancel = threading.Event()
+        cancel.set()
+        keys = ('budget', 'product', 'audience')
+        with tempfile.TemporaryDirectory() as tmp, self.assertRaises(InterruptedError):
+            review_tags({key + 'Strategy': '内容' for key in keys},
+                        {key: [{'id': 1, 'name': '其他'}] for key in keys}, {}, Path(tmp), cancel, lambda _: None,
+                        biz_line_id=1, attempt=1)
+
+    def test_all_zero_stops_before_channel_query(self):
+        with tempfile.TemporaryDirectory() as tmp, patch('strategy_output.run_cli', return_value={
+            'ok': True, 'data': {'result': [{'projectId': 1, 'lastWeekSpend': 0}], 'total': 1}
+        }) as api:
+            with self.assertRaises(GenerationOutcome) as caught:
+                precheck_projects(Path(tmp), 1)
+            self.assertEqual(caught.exception.code, 'NO_DELIVERY_DATA')
+            self.assertEqual(api.call_count, 1)
+            self.assertEqual(api.call_args.args[1], {'bizLineIdList': [1], 'pageNum': 1, 'pageSize': 100})
+
+    def test_explicit_skip_spend_still_checks_project_coverage(self):
+        """显式跳过只放行消耗门槛；项目渠道不再作为预检依据。"""
+        project = {'projectId': 1, 'lastWeekSpend': 0, 'channelIdList': ['unknown']}
+        page = {'ok': True, 'data': {'result': [project], 'total': 1}}
+        with tempfile.TemporaryDirectory() as tmp:
+            with patch('strategy_output.run_cli', return_value=page) as api:
+                precheck_projects(Path(tmp), 1, [1], skip_spend_check=True)
+                self.assertEqual(api.call_count, 1)
+            with patch('strategy_output.run_cli', return_value=page):
+                with self.assertRaisesRegex(RuntimeError, '未覆盖'):
+                    precheck_projects(Path(tmp), 1, [1, 2], skip_spend_check=True)
+        self.assertFalse(workflow_parser().parse_args(['--id', '1']).skip_project_spend_check)
+        self.assertTrue(workflow_parser().parse_args(['--id', '1', '--skip-project-spend-check']).skip_project_spend_check)
+
+    def test_later_page_positive_ignores_project_channels(self):
+        """项目列表仅判断消耗；未知或缺失项目渠道不应提前拒绝。"""
+        pages = [
+            {'ok': True, 'data': {'result': [{'projectId': 1, 'lastWeekSpend': 0, 'channelIdList': ['unknown']}], 'total': 2}},
+            {'ok': True, 'data': {'result': [{'projectId': 2, 'lastWeekSpend': 2}], 'total': 2}},
+        ]
+        with tempfile.TemporaryDirectory() as tmp, patch('strategy_output.run_cli', side_effect=pages) as api:
+            precheck_projects(Path(tmp), 1)
+            self.assertEqual(api.call_count, 2)
+            self.assertEqual(api.call_args_list[1].args[1]['pageNum'], 2)
+
+    def test_missing_spend_and_failed_page_are_not_zero(self):
+        for env in ({'ok': True, 'data': {'result': [{'projectId': 1}], 'total': 1}}, {'ok': False, 'error': 'denied'}):
+            with self.subTest(env=env), tempfile.TemporaryDirectory() as tmp, patch('strategy_output.run_cli', return_value=env):
+                with self.assertRaises(RuntimeError) as caught:
+                    precheck_projects(Path(tmp), 1)
+                self.assertNotEqual(getattr(caught.exception, 'code', None), 'NO_DELIVERY_DATA')
+
+    def test_default_service_filter_cannot_hide_linked_projects(self):
+        """即使分页 total 完整，也要与业务线 projectIds 核对，不能遗漏其他服务项目。"""
+        with tempfile.TemporaryDirectory() as tmp, patch('strategy_output.run_cli', return_value={
+            'ok': True, 'data': {'result': [{'projectId': 1, 'lastWeekSpend': 0}], 'total': 1}
+        }):
+            with self.assertRaisesRegex(RuntimeError, '未覆盖业务线全部关联项目') as caught:
+                precheck_projects(Path(tmp), 1, [1, 2])
+            self.assertNotIsInstance(caught.exception, GenerationOutcome)
+
+    def test_calendar_periods_and_explicit_overrides(self):
+        """周一、周日及跨年均取已结束周，用户可分别覆盖两期。"""
+        args = Namespace(curr_start='', curr_end='', prev_start='', prev_end='')
+        for anchor in (date(2026, 9, 21), date(2026, 9, 22), date(2026, 9, 27)):
+            self.assertEqual(resolve_periods(args, anchor), {
+                'curr': ('2026-09-14', '2026-09-20'), 'prev': ('2026-09-07', '2026-09-13')})
+        self.assertEqual(resolve_periods(args, date(2026, 1, 1)), {
+            'curr': ('2025-12-22', '2025-12-28'), 'prev': ('2025-12-15', '2025-12-21')})
+        args.curr_start, args.curr_end = '2026-09-01', '2026-09-05'
+        self.assertEqual(resolve_periods(args, date(2026, 9, 22))['curr'], ('2026-09-01', '2026-09-05'))
+        self.assertEqual(resolve_periods(args, date(2026, 9, 22))['prev'], ('2026-09-07', '2026-09-13'))
+        args.prev_start, args.prev_end = '2026-08-25', '2026-08-29'
+        self.assertEqual(resolve_periods(args)['prev'], ('2026-08-25', '2026-08-29'))
+        args.prev_end = ''
+        with self.assertRaises(ValueError):
+            resolve_periods(args)
+
+    def test_invalid_week_rejected(self):
+        validate_period('2026-09-07', '2026-09-13')
+        for bounds in [('2026-09-08', '2026-09-13'), ('2026-09-07', '2026-09-20'), ('2026-08-31', '2026-09-06')]:
+            with self.subTest(bounds=bounds), self.assertRaises(ValueError):
+                validate_period(*bounds)
+
+    def test_full_ready_mapping_and_effect_validation(self):
+        """READY 正文与效果只取 AI 单元格，固定行仅提供审核过的标签绑定。"""
+        from build_report import read_ai_sheet, write_xlsx
+        row = {key + 'Strategy': '固定正文' for key in ('budget', 'product', 'audience', 'creative')}
+        for key in ('budget', 'product', 'audience'):
+            row.update({key + 'TagIds': [21], key + 'Tags': '真实标签'})
+        text = '一页速览\n- 概览。\n' + '\n'.join(
+            f'【{heading}】\nAI正文{index}\nLearning（{label}）：独立说明\nKPI目标 <= 3'
+            for index, (heading, label) in enumerate(zip(
+                ('预算策略', '广告产品策略', '受众策略', '创意策略'), ('有效', '无效', '待观察', '有效'))))
+        context = {'bizLineId': 1, 'periodStart': '2026-09-07', 'periodEnd': '2026-09-13'}
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / 'final.xlsx'
+            write_xlsx([row], str(path), [], ai_strategy=text)
+            sheet = read_ai_sheet(path)
+        body = ready_body(context, sheet, row, 'key.xlsx')
+        self.assertEqual(body['mediaStrategyTags'], [21])
+        self.assertEqual(body['mediaStrategyEffect'], 2)
+        self.assertEqual(body['creativeStrategy'], 'AI正文3')
+        self.assertEqual(body['budgetStrategySupplement'], 'AI正文0')
+        self.assertEqual(body['fileStorageKey'], 'key.xlsx')
+        for remote in ('budget', 'media', 'audience', 'creative'):
+            self.assertEqual(body[remote + 'StrategyLearning'], '独立说明\nKPI目标 <= 3')
+        self.assertEqual(row['budgetStrategy'], '固定正文')
+        sheet['预算策略标签'] = '另一业务线标签'
+        with self.assertRaisesRegex(ValueError, '标签'):
+            ready_body(context, sheet, row, 'key.xlsx')
+        sheet['预算策略标签'] = ''
+        row.update(budgetTags='', budgetTagIds=[], budgetTagFallbackMissingOther=True)
+        self.assertEqual(ready_body(context, sheet, row, 'key.xlsx')['budgetStrategyTags'], [])
+        row.pop('budgetTagFallbackMissingOther')
+        with self.assertRaises(ValueError):
+            ready_body(context, sheet, row, 'key.xlsx')
+
+    def test_learning_labels_and_standalone_heading(self):
+        """精确解析末段，不从正文中的有效词汇猜效果，保留说明换行。"""
+        variants = ('Learning（{label}）：', 'learning({label}):',
+                    '【Learning】\nLearning（{label}）：', '【Learning】\n（{label}）：')
+        for label, effect in (('有效', 1), ('无效', 2), ('待观察', 3)):
+            for marker in variants:
+                with self.subTest(label=label, marker=marker):
+                    self.assertEqual(split_ai_learning('有效动作正文\n' + marker.format(label=label) +
+                                                       '动作解释\n- KPI数据'),
+                                     ('有效动作正文', effect, '动作解释\n- KPI数据'))
+        for value in ('正文', '正文\nLearning（潜力）：说明', '正文\nLearning（有效）： ',
+                      'Learning（有效）：只有说明',
+                      '正文\nLearning（有效）：说明\n【调整方向】\n继续加投。',
+                      '正文\nLearning（有效）：说明\n策略总结：成本降低。',
+                      '正文\nLearning（有效）：说明\n关键数据: 消耗下降。',
+                      '正文\nLearning（有效）：说明\nLearning（无效）：说明',
+                      '正文\n【Learning】\n【Learning】\n（有效）：说明'):
+            with self.subTest(value=value), self.assertRaises(ValueError):
+                split_ai_learning(value)
+
+    def test_save_failure_never_retries(self):
+        with tempfile.TemporaryDirectory() as tmp, patch('strategy_output.run_cli', return_value={'ok': False, 'error': 'timeout'}) as api:
+            with self.assertRaises(RuntimeError):
+                save_result(Path(tmp), {'generateCode': 'NO_PROJECT'})
+            self.assertEqual(api.call_count, 1)
+            self.assertEqual(api.call_args.args[0], ['biz-line-ai-strategy', '+ai-strategy-save'])
+
+    def test_dictionary_requests_and_empty_results(self):
+        with tempfile.TemporaryDirectory() as tmp, patch('strategy_output.run_cli', return_value={'ok': True, 'data': [
+            {'id': 1, 'name': '其他', 'isOther': 1, 'children': None}
+        ]}) as api:
+            dictionaries = load_tags(Path(tmp), '11')
+            self.assertEqual(len(dictionaries), 3)
+            self.assertEqual([call.args[1]['sceneCode'] for call in api.call_args_list],
+                             ['BUDGET_STRATEGY', 'MEDIA_STRATEGY', 'AUDIENCE_STRATEGY'])
+            self.assertTrue(all(call.args[1]['filterCondition'] == '11' for call in api.call_args_list))
+            api.return_value = {'ok': True, 'data': []}
+            with self.assertRaises(ValueError):
+                load_tags(Path(tmp), '11')
+
+    def test_industry_cache_concurrent_reuse_and_isolation(self):
+        """多行业并发时同一行业只查三次，且多个行业只取首个。"""
+        with tempfile.TemporaryDirectory() as tmp, patch('strategy_output.run_cli', return_value={
+            'ok': True, 'data': [{'id': 1, 'name': '其他'}]
+        }) as api:
+            cache = TagCache(Path(tmp))
+            lines = [{'adCategoryIndustryIds': ids} for ids in ([11, 22], [11], [22], [33], [22])]
+            with ThreadPoolExecutor(max_workers=3) as executor:
+                values = list(executor.map(cache.get, lines))
+            self.assertIs(values[0], values[1])
+            self.assertEqual(api.call_count, 9)
+            for industry in ('11', '22', '33'):
+                queries = [call.args[1] for call in api.call_args_list if call.args[1]['filterCondition'] == industry]
+                self.assertEqual(queries, [{'sceneCode': scene, 'filterCondition': industry} for scene in
+                    ('BUDGET_STRATEGY', 'MEDIA_STRATEGY', 'AUDIENCE_STRATEGY')])
+            self.assertEqual(len({str(call.args[2]) for call in api.call_args_list}), 9)
+
+    def test_invalid_industry_and_failure_cache(self):
+        """不能改用第二个行业，失败仅缓存对应行业，不影响其他行业。"""
+        for ids in (None, [], [None, 11], [False], [-1], ['bad', 11]):
+            with self.assertRaises(ValueError):
+                industry_condition({'adCategoryIndustryIds': ids})
+        with tempfile.TemporaryDirectory() as tmp, patch('strategy_output.run_cli', return_value={'ok': True, 'data': []}) as api:
+            cache = TagCache(Path(tmp))
+            for _ in range(2):
+                with self.assertRaises((ValueError, RuntimeError)):
+                    cache.get({'adCategoryIndustryIds': [11]})
+            self.assertEqual(api.call_count, 1)
+            api.return_value = {'ok': True, 'data': [{'id': 1, 'name': '其他'}]}
+            cache.get({'adCategoryIndustryIds': [22]})
+            self.assertEqual(api.call_count, 4)
+
+    def test_effects_and_parser(self):
+        self.assertEqual([effect_code(v) for v in ('有效', '无效', '待观察', '待观察（预警）')], [1, 2, 3, 3])
+        self.assertEqual(workflow_parser().parse_args(['--id', '1']).output_mode, 'excel')
+        self.assertEqual(workflow_parser().parse_args(['--id', '1', '--output-mode', 'database']).output_mode, 'database')
+
+    def test_real_fetch_zero_precheck_creates_context_before_stopping(self):
+        """不替换 fetch_business，确认真实入口在广告拉数前结束且可写正确周期状态。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            args = Namespace(**{**vars(arguments(root)), 'id': 1, 'request_dir': str(root), 'output_mode': 'database'})
+            with patch('fetch_data.date', wraps=date) as clock, patch('fetch_data.run_cli', return_value={'ok': True, 'data': {'result': [{
+                'id': 1, 'name': '匿名业务线', 'projectIds': [10],
+                'periodStart': '2026-09-07', 'periodEnd': '2026-09-13',
+            }], 'total': 1}}) as fetch_api, patch('strategy_output.run_cli', return_value={
+                'ok': True, 'data': {'result': [{'projectId': 10, 'lastWeekSpend': 0}], 'total': 1}
+            }):
+                clock.today.return_value = date(2026, 9, 22)
+                with self.assertRaises(GenerationOutcome) as outcome:
+                    fetch_business(args)
+                self.assertEqual(outcome.exception.code, 'NO_DELIVERY_DATA')
+                self.assertEqual(fetch_api.call_count, 1)
+                self.assertEqual(json.loads((root / 'save-context.json').read_text())['periodStart'], '2026-09-14')
+
+    def test_fetch_queries_industry_tags_before_project_precheck(self):
+        """真实 fetch 入口先解析业务线行业并查字典，再进入项目检查。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            args = Namespace(**{**vars(arguments(Path(tmp))), 'id': 1, 'request_dir': tmp,
+                'output_mode': 'database', 'curr_start': '2026-09-07', 'curr_end': '2026-09-13',
+                'tag_cache': TagCache(Path(tmp) / 'tags')})
+            events = []
+            def lookup(*_):
+                events.append('biz')
+                return {'ok': True, 'data': {'result': [{'id': 1, 'projectIds': [10], 'adCategoryIndustryIds': [11, 22]}], 'total': 1}}
+            def tags(command, body, out):
+                events.append(body)
+                return {'ok': True, 'data': [{'id': 1, 'name': '其他'}]}
+            def precheck(*_, **kwargs):
+                events.append('projects')
+                raise GenerationOutcome('NO_DELIVERY_DATA', '全零')
+            with patch('fetch_data.run_cli', side_effect=lookup), patch('strategy_output.run_cli', side_effect=tags), patch('fetch_data.precheck_projects', side_effect=precheck):
+                with self.assertRaises(GenerationOutcome):
+                    fetch_business(args)
+            self.assertEqual(events, ['biz',
+                {'sceneCode': 'BUDGET_STRATEGY', 'filterCondition': '11'},
+                {'sceneCode': 'MEDIA_STRATEGY', 'filterCondition': '11'},
+                {'sceneCode': 'AUDIENCE_STRATEGY', 'filterCondition': '11'}, 'projects'])
+
+    def test_invalid_output_options_do_not_create_files(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            args = arguments(Path(tmp) / 'out')
+            args.output_mode = 'database'
+            with self.assertRaises(ValueError):
+                run_batch(args, temp_parent=Path(tmp))
+            args.output_dir, args.curr_start = None, '2026-09-07'
+            with self.assertRaises(ValueError):
+                run_batch(args, temp_parent=Path(tmp))
+            self.assertFalse(list(Path(tmp).iterdir()))
+
+    def test_unknown_channel_is_not_dropped(self):
+        """后续项目的未知账号渠道也必须拒绝，不能只保留前面的支持账号。"""
+        projects = [{'projectName': '支持项目', 'adAccounts': [{'adAccountId': 'f', 'channelName': 'Meta'}]},
+                    {'projectName': '其他项目', 'adAccounts': [{'adAccountId': 'x', 'channelName': 'Other'}]}]
+        with tempfile.TemporaryDirectory() as tmp, patch('fetch_data.run_cli', return_value={'ok': True, 'data': projects}):
+            with self.assertRaises(GenerationOutcome) as outcome:
+                load_projects(Path(tmp), 1)
+            self.assertEqual(outcome.exception.code, 'UNSUPPORTED_CHANNEL')
+
+
+class AccountChannelSource(unittest.TestCase):
+    """关联账号是渠道唯一来源，项目分页的配置不能覆盖或绕过它。"""
+
+    def test_supported_channel_combinations_and_account_deduplication(self):
+        """三个渠道任意非空组合均可用，跨项目重复账号只统计一次。"""
+        entries = [('Facebook', 'fb'), ('Google', 'gg'), ('TikTok', 'tt')]
+        for mask in range(1, 8):
+            selected = [item for index, item in enumerate(entries) if mask & (1 << index)]
+            accounts = [{'adAccountId': key, 'channelName': name} for name, key in selected]
+            projects = [{'projectName': '项目一', 'adAccounts': accounts},
+                        {'projectName': '项目二', 'adAccounts': accounts}]
+            with self.subTest(mask=mask), tempfile.TemporaryDirectory() as tmp, \
+                 patch('fetch_data.run_cli', return_value={'ok': True, 'data': projects}) as api:
+                names, buckets = load_projects(Path(tmp), 1)
+                self.assertEqual(names, ['项目一', '项目二'])
+                self.assertEqual(buckets, {key: [key] if (name, key) in selected else [] for name, key in entries})
+                self.assertEqual(api.call_count, 1)
+                self.assertEqual(api.call_args.args[:2], (['biz-line', '+project-list'], {'bizLineId': 1}))
+
+    def test_channel_id_resolves_missing_or_stale_account_name(self):
+        """契约规定名称可能为空，channelId有值时以字典解析出的渠道为准。"""
+        projects = [{'projectName': '项目', 'adAccounts': [
+            {'adAccountId': 'g', 'channelId': 102, 'channelName': None},
+            {'adAccountId': 't', 'channelId': 103, 'channelName': 'Meta'},
+        ]}]
+        dictionary = [{'channelId': 102, 'channelName': 'Google'}, {'channelId': 103, 'channelName': 'TikTok'}]
+        with tempfile.TemporaryDirectory() as tmp, patch('fetch_data.run_cli', side_effect=[
+            {'ok': True, 'data': projects}, {'ok': True, 'data': dictionary},
+        ]) as api:
+            self.assertEqual(load_projects(Path(tmp), 1)[1], {'fb': [], 'gg': ['g'], 'tt': ['t']})
+            self.assertEqual(api.call_args_list[1].args[:2], (['media', '+channels'], None))
+            self.assertEqual(api.call_count, 2)
+
+    def test_unknown_id_cannot_be_hidden_by_supported_name(self):
+        """账号ID指向其他或未知渠道时，不能凭Facebook名称放行。"""
+        for dictionary in ([], [{'channelId': 999, 'channelName': 'Other'}]):
+            project = {'projectName': '项目', 'adAccounts': [
+                {'adAccountId': 'x', 'channelId': 999, 'channelName': 'Facebook'}]}
+            with self.subTest(dictionary=dictionary), tempfile.TemporaryDirectory() as tmp, \
+                 patch('fetch_data.run_cli', side_effect=[{'ok': True, 'data': [project]}, {'ok': True, 'data': dictionary}]):
+                with self.assertRaises(GenerationOutcome) as caught:
+                    load_projects(Path(tmp), 1)
+                self.assertEqual(caught.exception.code, 'UNSUPPORTED_CHANNEL')
+
+    def test_missing_channel_is_rejected_and_empty_accounts_are_preserved(self):
+        """有账号无渠道属于未知渠道；全部无账号留给原NO_AD_ACCOUNT逻辑。"""
+        for channel in (None, '', 'Other'):
+            project = {'projectName': '项目', 'adAccounts': [{'adAccountId': 'x', 'channelName': channel}]}
+            with self.subTest(channel=channel), tempfile.TemporaryDirectory() as tmp, \
+                 patch('fetch_data.run_cli', return_value={'ok': True, 'data': [project]}):
+                with self.assertRaises(GenerationOutcome) as caught:
+                    load_projects(Path(tmp), 1)
+                self.assertEqual(caught.exception.code, 'UNSUPPORTED_CHANNEL')
+        with tempfile.TemporaryDirectory() as tmp, patch('fetch_data.run_cli', return_value={
+            'ok': True, 'data': [{'projectName': '项目', 'adAccounts': []}],
+        }) as api:
+            self.assertEqual(load_projects(Path(tmp), 1)[1], {'fb': [], 'gg': [], 'tt': []})
+            self.assertEqual(api.call_count, 1)
+
+    def test_malformed_accounts_and_lookup_failure_are_technical_errors(self):
+        """损坏回包或字典失败不能被丢弃后生成部分报告。"""
+        cases = [[None], [{'projectName': '项目', 'adAccounts': 'invalid'}],
+                 [{'projectName': '项目', 'adAccounts': [None]}]]
+        for projects in cases:
+            with self.subTest(projects=projects), tempfile.TemporaryDirectory() as tmp, \
+                 patch('fetch_data.run_cli', return_value={'ok': True, 'data': projects}):
+                with self.assertRaises(RuntimeError) as caught:
+                    load_projects(Path(tmp), 1)
+                self.assertNotIsInstance(caught.exception, GenerationOutcome)
+        project = {'projectName': '项目', 'adAccounts': [{'adAccountId': 'f', 'channelId': 101}]}
+        with tempfile.TemporaryDirectory() as tmp, patch('fetch_data.run_cli', side_effect=[
+            {'ok': True, 'data': [project]}, {'ok': False, 'error': '查询失败'},
+        ]):
+            with self.assertRaises(RuntimeError) as caught:
+                load_projects(Path(tmp), 1)
+            self.assertNotIsInstance(caught.exception, GenerationOutcome)
+
+    def test_real_workflow_rejects_account_channel_even_with_explicit_override(self):
+        """项目渠道可用、消耗跳过和显式账号均不能绕过关联账号的未知渠道。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            args = arguments(root / 'out')
+            args.output_mode, args.output_dir = 'database', None
+            args.curr_start, args.curr_end = '2026-09-07', '2026-09-13'
+            args.account_fb, args.skip_project_spend_check = ['user-account'], True
+            saved, calls = [], []
+            def api(command, body, out):
+                calls.append(command)
+                if command == ['biz-line', '+list']:
+                    return {'ok': True, 'data': {'result': [{'id': 1, 'projectIds': [10], 'adCategoryIndustryIds': [11]}], 'total': 1}}
+                if command == ['biz-line', '+categories']:
+                    return {'ok': True, 'data': [{'id': 1, 'name': '其他', 'isOther': 1}]}
+                if command == ['biz-line', '+queryByPage']:
+                    return {'ok': True, 'data': {'result': [{'projectId': 10, 'lastWeekSpend': 0, 'channelIdList': [101]}], 'total': 1}}
+                if command == ['biz-line', '+detail']:
+                    return {'ok': True, 'data': {'id': 1}}
+                if command == ['biz-line', '+project-list']:
+                    return {'ok': True, 'data': [{'projectId': 10, 'projectName': '项目', 'adAccounts': [
+                        {'adAccountId': 'f', 'channelName': 'Meta'}, {'adAccountId': 'x', 'channelName': 'Other'}]}]}
+                if command == ['biz-line-ai-strategy', '+ai-strategy-save']:
+                    saved.append(body)
+                    return {'ok': True, 'data': 1}
+                raise AssertionError(f'不应继续拉数或上传：{command}')
+            with patch('fetch_data.run_cli', side_effect=api), patch('strategy_output.run_cli', side_effect=api):
+                result = run_batch(args, progress=lambda _: None, temp_parent=root)
+            self.assertTrue(result['ok'], result)
+            self.assertEqual(result['results'][0]['attempts'], 1)
+            self.assertEqual([item['generateCode'] for item in saved], ['UNSUPPORTED_CHANNEL'])
+            self.assertIn('广告账号', saved[0]['remark'])
+            self.assertFalse(list(root.rglob('line-*')))
+
+
+    def test_real_fetch_ignores_project_channels_and_uses_account_channel_filters(self):
+        """项目渠道无效仍按账号真实渠道继续，维度成效只查询Google及TikTok。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            args = Namespace(**{**vars(arguments(root / 'out')), 'id': 1, 'request_dir': tmp,
+                'output_mode': 'database', 'curr_start': '2026-09-07', 'curr_end': '2026-09-13'})
+            calls = []
+            def api(command, body, out):
+                calls.append(command)
+                if command == ['biz-line', '+list']:
+                    return {'ok': True, 'data': {'result': [{'id': 1, 'projectIds': [10, 20]}], 'total': 1}}
+                if command == ['biz-line', '+queryByPage']:
+                    return {'ok': True, 'data': {'result': [
+                        {'projectId': 10, 'lastWeekSpend': 1, 'channelIdList': ['unknown']},
+                        {'projectId': 20, 'lastWeekSpend': 0}], 'total': 2}}
+                if command == ['biz-line', '+detail']:
+                    return {'ok': True, 'data': {'id': 1}}
+                if command == ['biz-line', '+project-list']:
+                    return {'ok': True, 'data': [
+                        {'projectId': 10, 'projectName': '谷歌项目', 'adAccounts': [{'adAccountId': 'g', 'channelId': 102, 'channelName': None}]},
+                        {'projectId': 20, 'projectName': '短视频项目', 'adAccounts': [{'adAccountId': 't', 'channelId': 103, 'channelName': 'Meta'}]}]}
+                if command == ['media', '+channels']:
+                    return {'ok': True, 'data': [{'channelId': 102, 'channelName': 'Google'}, {'channelId': 103, 'channelName': 'TikTok'}]}
+                raise AssertionError(command)
+            with patch('fetch_data.run_cli', side_effect=api), patch('strategy_output.run_cli', side_effect=api), \
+                 patch('fetch_data.fetch_paged', return_value=0) as metrics:
+                self.assertEqual(fetch_business(args)['id'], 1)
+            self.assertEqual(calls.count(['media', '+channels']), 1)
+            self.assertEqual({call.args[0] for call in metrics.call_args_list},
+                             {'+google-dimension', '+google-metrics', '+tiktok-dimension', '+tiktok-metrics'})
+            for call in metrics.call_args_list:
+                self.assertEqual(call.args[1]['dimensionValues'], {'account_id': ['g' if 'google' in call.args[0] else 't']})
+            self.assertEqual(json.loads((root / 'projects.json').read_text(encoding='utf-8'))['allAccounts'],
+                             {'fb': [], 'gg': ['g'], 'tt': ['t']})
+
+
+class DatabaseWorkflow(unittest.TestCase):
+    """实际工作流导出真实 xlsx，仅替换外部 CLI；检查调用顺序与文件生命周期。"""
+
+    def run_fixture(self, root, *, failure=None, outcome=None):
+        args = arguments(root / 'desktop')
+        args.output_dir, args.output_mode = None, 'database'
+        payload = small_payload()
+        for key in ('budget', 'product', 'audience', 'creative'):
+            payload['rows'][0][key + 'Effect'] = 3
+        calls = []
+        self.fixture_counts = {'fetch': 0, 'analyze': 0}
+        self.fixture_review_events = []
+        self.fixture_ai_events = []
+        self.fixture_row = payload['rows'][0]
+        def fetch(local):
+            # 上下文写入时机与生产 fetch_business 一致。
+            self.fixture_counts['fetch'] += 1
+            (Path(local.request_dir) / 'save-context.json').write_text(json.dumps({
+                'bizLineId': 1, 'periodStart': '2026-09-07', 'periodEnd': '2026-09-13',
+            }))
+            if outcome:
+                raise GenerationOutcome(outcome, 'fixture reason')
+            return {'id': 1, 'name': '匿名样本', 'adCategoryIndustryIds': [11]}
+        def api(command, body, out):
+            calls.append((command, body))
+            if command == ['biz-line', '+categories']:
+                if failure == 'review_identity_missing_other' and body['sceneCode'] == 'AUDIENCE_STRATEGY':
+                    return {'ok': True, 'data': [{'id': len(calls), 'name': '受众具体标签'}]}
+                return {'ok': True, 'data': [{'id': len(calls), 'name': '其他'}]}
+            if command == ['common-file', '+upload']:
+                self.assertTrue(Path(body['file']).is_file())
+                self.assertEqual(body['serviceName'], 'sino-opti-hive')
+                with zipfile.ZipFile(body['file']) as workbook:
+                    xml = ET.fromstring(workbook.read('xl/workbook.xml'))
+                    ns = {'s': 'http://schemas.openxmlformats.org/spreadsheetml/2006/main'}
+                    self.assertEqual([sheet.attrib['name'] for sheet in xml.findall('s:sheets/s:sheet', ns)],
+                                     ['策略', '明细', 'AI策略'])
+                if failure == 'upload':
+                    return {'ok': False, 'error': 'upload failed'}
+                return {'ok': True, 'data': {'storageKey': '' if failure == 'empty_key' else 'saved.xlsx'}}
+            if command == ['biz-line-ai-strategy', '+ai-strategy-save']:
+                if body['generateCode'] == 'READY':
+                    self.assertFalse((out.parent / 'final.xlsx').exists())
+                    self.assertEqual(body['fileStorageKey'], 'saved.xlsx')
+                    self.assertEqual(body['mediaStrategyEffect'], 2)
+                    self.assertEqual(body['budgetStrategySupplement'], '- AI正文0。')
+                    self.assertEqual(body['creativeStrategy'], '- AI正文3。')
+                    self.assertEqual(body['budgetStrategyLearning'], 'AI说明0\n- KPI数据。')
+                if failure == 'save':
+                    return {'ok': False, 'error': 'timeout'}
+                if failure == 'save_id':
+                    return {'ok': True, 'data': None}
+                return {'ok': True, 'data': 123}
+            self.fail(f'未知请求 {command}')
+        def progress(event):
+            """通过真实交接文件提供离线 Agent 选择，验证保存前确实完成内容分析交接。"""
+            if event.get('event') == 'tag_review_required':
+                self.fixture_review_events.append(event)
+                request = json.loads(Path(event['request_path']).read_text(encoding='utf-8'))
+                selections = {key: [{'id': item['labels'][0]['id'], 'choiceKey': item['labels'][0]['choiceKey'],
+                                     'reason': '离线样本字典仅有其他'}]
+                              for key, item in request['strategies'].items()}
+                reply = {key: request[key] for key in ('bizLineId', 'attempt', 'reviewId')}
+                if failure in ('review_identity', 'review_identity_missing_other'):
+                    reply['bizLineId'] += 1
+                if failure in ('review_identity', 'review_identity_missing_other'):
+                    Path(event['response_path']).write_text(json.dumps({**reply, 'selections': selections}), encoding='utf-8')
+                else:
+                    numbered = {key: [{'choiceKey': item['choiceKey'], 'reason': item['reason']} for item in items]
+                                for key, items in selections.items()}
+                    submit_tag_choices(event['request_path'], event['reviewId'], {'selections': numbered})
+            if event.get('event') == 'ai_strategy_required':
+                self.fixture_ai_events.append(event)
+                request = json.loads(Path(event['request_path']).read_text(encoding='utf-8'))
+                self.assertTrue(Path(request['workbookPath']).is_file())
+                with zipfile.ZipFile(request['workbookPath']) as source:
+                    xml = ET.fromstring(source.read('xl/workbook.xml'))
+                    ns = {'s': 'http://schemas.openxmlformats.org/spreadsheetml/2006/main'}
+                    self.assertEqual([sheet.attrib['name'] for sheet in xml.findall('s:sheets/s:sheet', ns)], ['明细'])
+                self.assertIn('只依赖明细sheet，不要带入其他上下文', request['prompt'])
+                self.assertNotIn('payloadPath', request)
+                reply = {key: request[key] for key in ('bizLineId', 'attempt', 'requestId')}
+                self.assertIn('Learning', request['outputContract'])
+                reply['text'] = '一页速览\n- 样本数据。\n' + '\n'.join(
+                    f'【{heading}】\n- AI正文{index}。\nLearning（{label}）：AI说明{index}\n- KPI数据。'
+                    for index, (heading, label) in enumerate(zip(
+                        ('预算策略', '广告产品策略', '受众策略', '创意策略'), ('有效', '无效', '待观察', '有效'))))
+                if failure == 'ai_learning' or (failure == 'ai_learning_then_valid' and event['reviewAttempt'] < 3):
+                    reply['text'] = reply['text'].replace('Learning（有效）', 'Learning（不明）')
+                if failure == 'ai_identity':
+                    reply['bizLineId'] += 1
+                Path(event['response_path']).write_text(json.dumps(reply, ensure_ascii=False), encoding='utf-8')
+        def analyze(_):
+            self.fixture_counts['analyze'] += 1
+            (_ / 'payload.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
+            return payload, {'detail_count': 1, 'curr_total': 20, 'tag_evidence': {}}
+        with patch('run_workflow.fetch_business', fetch), patch('run_workflow.summarize_request', side_effect=analyze), patch('strategy_output.run_cli', api):
+            result = run_batch(args, progress=progress, temp_parent=root)
+        return result, calls
+
+    def test_success_upload_delete_save_without_desktop(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            result, calls = self.run_fixture(root)
+            self.assertTrue(result['ok'])
+            self.assertEqual(result['results'][0]['aiStrategyId'], 123)
+            self.assertIsNone(result['results'][0]['output_path'])
+            self.assertEqual([c[0] for c in calls][-2:], [['common-file', '+upload'], ['biz-line-ai-strategy', '+ai-strategy-save']])
+            self.assertFalse(list(root.rglob('*.xlsx')))
+            # 审核完成后仍由业务线 worker 清理自己的目录，不留等待审核的临时文件。
+            self.assertTrue(result['results'][0]['cleanup']['ok'])
+            self.assertFalse(list(root.rglob('line-*')))
+            self.assertEqual(len(self.fixture_ai_events), 1)
+
+    def test_ai_rejected_three_times_does_not_restart_business_or_upload(self):
+        """AI 失败仅三次审核，整条业务线不进入批次重跑。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            result, calls = self.run_fixture(root, failure='ai_identity')
+            self.assertFalse(result['ok'])
+            self.assertEqual(result['results'][0]['attempts'], 1)
+            self.assertEqual(self.fixture_counts, {'fetch': 1, 'analyze': 1})
+            self.assertEqual(len(self.fixture_ai_events), 3)
+            self.assertFalse(any(command == ['common-file', '+upload'] for command, _ in calls))
+            self.assertEqual(calls[-1][1]['generateCode'], 'GENERATION_FAILED')
+            self.assertFalse(list(root.rglob('line-*')))
+
+    def test_learning_format_failure_retries_only_ai_and_records_failure(self):
+        """三次非法 Learning 不上传，保存 GENERATION_FAILED，临时目录照常清理。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            result, calls = self.run_fixture(Path(tmp), failure='ai_learning')
+            self.assertFalse(result['ok'])
+            self.assertEqual(self.fixture_counts, {'fetch': 1, 'analyze': 1})
+            self.assertEqual(len(self.fixture_review_events), 1)
+            self.assertEqual(len(self.fixture_ai_events), 3)
+            self.assertEqual(result['results'][0]['attempts'], 1)
+            self.assertEqual(calls[-1][1]['generateCode'], 'GENERATION_FAILED')
+            self.assertTrue(calls[-1][1]['remark'])
+            self.assertFalse(any(command == ['common-file', '+upload'] for command, _ in calls))
+            self.assertFalse(list(Path(tmp).rglob('line-*')))
+
+    def test_learning_third_reply_valid_without_refetch_or_retag(self):
+        """只重试文案，第三次修正后用 AI 正文与效果入库。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            result, calls = self.run_fixture(Path(tmp), failure='ai_learning_then_valid')
+            self.assertTrue(result['ok'])
+            self.assertEqual(self.fixture_counts, {'fetch': 1, 'analyze': 1})
+            self.assertEqual(len(self.fixture_review_events), 1)
+            self.assertEqual(len(self.fixture_ai_events), 3)
+            self.assertEqual(calls[-1][1]['budgetStrategyEffect'], 1)
+
+    def test_sheet_tag_mismatch_is_checked_before_upload(self):
+        """工作簿读到其他业务线标签时预检即失败，不上传或提交 READY。"""
+        from build_report import read_ai_sheet
+        def foreign_tag(path):
+            cells = read_ai_sheet(path)
+            cells['预算策略标签'] = '其他业务线的标签'
+            return cells
+        with tempfile.TemporaryDirectory() as tmp, patch('run_workflow.read_ai_sheet', side_effect=foreign_tag):
+            result, calls = self.run_fixture(Path(tmp))
+            self.assertFalse(result['ok'])
+            self.assertFalse(any(command == ['common-file', '+upload'] for command, _ in calls))
+            self.assertTrue(all(body['generateCode'] == 'GENERATION_FAILED'
+                                for command, body in calls if command == ['biz-line-ai-strategy', '+ai-strategy-save']))
+
+    def test_foreign_review_retries_only_tags_then_delivers_other(self):
+        """同行业错投两次只重选标签，不重新拉数，最终以其他标签交付。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            result, calls = self.run_fixture(root, failure='review_identity')
+            self.assertTrue(result['ok'])
+            self.assertEqual(result['results'][0]['attempts'], 1)
+            self.assertEqual(self.fixture_counts, {'fetch': 1, 'analyze': 1})
+            self.assertEqual(len(self.fixture_review_events), 2)
+            self.assertEqual(sum(command == ['common-file', '+upload'] for command, _ in calls), 1)
+            self.assertEqual(calls[-1][1]['generateCode'], 'READY')
+            self.assertEqual(self.fixture_row['budgetTags'], '其他')
+            self.assertTrue(result['results'][0]['tag_review_fallback'])
+            self.assertFalse(list(root.rglob('line-*')))
+
+    def test_missing_other_keeps_strategy_and_learning_with_empty_tag(self):
+        """一个场景缺少其他仅令该场景标签为空，READY 仍保存完整策略。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            result, calls = self.run_fixture(Path(tmp), failure='review_identity_missing_other')
+            self.assertTrue(result['ok'])
+            self.assertEqual(self.fixture_counts, {'fetch': 1, 'analyze': 1})
+            self.assertEqual(len(self.fixture_review_events), 2)
+            self.assertEqual(self.fixture_row['audienceTags'], '')
+            self.assertEqual(self.fixture_row['audienceTagIds'], [])
+            self.assertTrue(self.fixture_row['audienceStrategy'])
+            self.assertTrue(self.fixture_row['audienceLearning'])
+            body = calls[-1][1]
+            self.assertEqual(body['generateCode'], 'READY')
+            self.assertEqual(body['audienceStrategyTags'], [])
+            self.assertTrue(body['audienceStrategySupplement'])
+            self.assertTrue(body['audienceStrategyLearning'])
+            self.assertTrue(body['budgetStrategyTags'])
+            self.assertTrue(body['mediaStrategyTags'])
+            self.assertEqual(result['results'][0]['tag_review_fallback']['missingOtherScenes'], ['audience'])
+
+    def test_upload_errors_save_failure_status(self):
+        for failure in ('upload', 'empty_key'):
+            with self.subTest(failure=failure), tempfile.TemporaryDirectory() as tmp:
+                result, calls = self.run_fixture(Path(tmp), failure=failure)
+                self.assertFalse(result['ok'])
+                self.assertEqual(calls[-1][1]['generateCode'], 'GENERATION_FAILED')
+                self.assertNotIn('fileStorageKey', calls[-1][1])
+                self.assertEqual(result['results'][0]['attempts'], 3)
+                self.assertEqual(sum(c[0] == ['common-file', '+upload'] for c in calls), 3)
+
+    def test_save_failure_preserves_key_and_never_writes_again(self):
+        for failure in ('save', 'save_id'):
+            with self.subTest(failure=failure), tempfile.TemporaryDirectory() as tmp:
+                result, calls = self.run_fixture(Path(tmp), failure=failure)
+                self.assertFalse(result['ok'])
+                self.assertEqual(sum(c[0] == ['biz-line-ai-strategy', '+ai-strategy-save'] for c in calls), 1)
+                self.assertEqual(result['results'][0]['storageKey'], 'saved.xlsx')
+                self.assertTrue(result['results'][0]['save_result_unknown'])
+                self.assertFalse(list(Path(tmp).rglob('*.xlsx')))
+
+    def test_failed_business_status_save_is_not_replayed(self):
+        """不可生成状态保存超时同样可能已落库，不整条重跑。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            result, calls = self.run_fixture(Path(tmp), failure='save', outcome='NO_PROJECT')
+            self.assertFalse(result['ok'])
+            self.assertTrue(result['results'][0]['save_result_unknown'])
+            self.assertEqual(result['results'][0]['attempts'], 1)
+            self.assertEqual(len(calls), 1)
+
+    def test_business_outcomes_saved_without_excel_or_upload(self):
+        for code in ('NO_PROJECT', 'UNSUPPORTED_CHANNEL', 'NO_AD_ACCOUNT', 'NO_DELIVERY_DATA'):
+            with self.subTest(code=code), tempfile.TemporaryDirectory() as tmp:
+                result, calls = self.run_fixture(Path(tmp), outcome=code)
+                self.assertTrue(result['ok'])
+                self.assertEqual(len(calls), 1)
+                self.assertEqual(calls[0][1]['generateCode'], code)
+                self.assertFalse(list(Path(tmp).rglob('*.xlsx')))
+
+    def test_excel_delete_failure_is_reported(self):
+        """模拟文件被占用，不能宣称清理成功；测试结束后由临时目录清理样本。"""
+        real_unlink = Path.unlink
+        def locked(path, *args, **kwargs):
+            if path.name == 'final.xlsx':
+                raise PermissionError('fixture file locked')
+            return real_unlink(path, *args, **kwargs)
+        with tempfile.TemporaryDirectory() as tmp:
+            with patch.object(Path, 'unlink', locked):
+                result, calls = self.run_fixture(Path(tmp))
+            self.assertFalse(result['ok'])
+            self.assertTrue(result['results'][0]['cleanup_failed'])
+            self.assertIn('fixture file locked', str(result))
+            self.assertEqual(calls[-1][1]['generateCode'], 'GENERATION_FAILED')
+
+
+if __name__ == '__main__':
+    unittest.main()