sino-bc-cli 1.8.41 → 1.8.42

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

@@ -0,0 +1,198 @@
+"""正式入库恢复：离线验证写入意图、回包恢复和查询认领。"""
+import json
+import tempfile
+import threading
+import unittest
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+from resumable_delivery import UnknownWrite, perform_write, read_intent, recover_write
+
+
+def ready_body():
+    body = {'bizLineId': 31, 'periodStart': '2026-10-12', 'periodEnd': '2026-10-18',
+            'generateCode': 'READY', 'fileStorageKey': 'test-file-key'}
+    for key in ('budget', 'media', 'audience', 'creative'):
+        body[key + 'Strategy' + ('' if key == 'creative' else 'Supplement')] = key + '正文'
+        body[key + 'StrategyEffect'] = 3
+        body[key + 'StrategyLearning'] = key + '学习'
+        if key != 'creative':
+            body[key + 'StrategyTags'] = [2, 1]
+    return body
+
+
+def stored_row(body, ident=91):
+    return {('weekStart' if key == 'periodStart' else 'weekEnd' if key == 'periodEnd' else key): value
+            for key, value in body.items()} | {'id': ident}
+
+
+def page(rows, total=100):
+    return {'ok': True, 'data': {'result': rows, 'total': total}}
+
+
+class DeliveryTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.root = Path(self.temp.name)
+        self.addCleanup(self.temp.cleanup)
+
+    def pending(self, kind, body):
+        with self.assertRaises(UnknownWrite):
+            perform_write(self.root, kind, body, Mock(side_effect=TimeoutError('模拟超时')))
+
+    def test_success_persists_id_before_return_and_never_replays(self):
+        body = ready_body()
+        operation = Mock(return_value=91)
+        self.assertEqual(perform_write(self.root, 'save', body, operation), 91)
+        self.assertEqual(read_intent(self.root, 'save')['status'], 'done')
+        self.assertEqual(perform_write(self.root, 'save', body, operation), 91)
+        operation.assert_called_once()
+
+    def test_upload_success_is_recovered_from_bound_output(self):
+        self.pending('upload', {'file': 'final.xlsx'})
+        (self.root / 'upload.out.json').write_text(json.dumps({'ok': True, 'data': {'storageKey': 'uploaded-key'}}))
+        self.assertEqual(recover_write(self.root, 'upload'), 'uploaded-key')
+        self.assertEqual(read_intent(self.root, 'upload')['status'], 'done')
+
+    def test_save_success_output_wins_over_query(self):
+        self.pending('save', ready_body())
+        (self.root / 'save.out.json').write_text(json.dumps({'ok': True, 'data': 91}))
+        with patch('resumable_delivery.run_cli') as cli:
+            self.assertEqual(recover_write(self.root, 'save'), 91)
+        cli.assert_not_called()
+
+    def test_upload_unknown_does_not_replay_or_query_ai(self):
+        self.pending('upload', {'file': 'final.xlsx'})
+        operation = Mock(return_value='unwanted')
+        with patch('resumable_delivery.run_cli') as cli, self.assertRaises(UnknownWrite):
+            perform_write(self.root, 'upload', {'file': 'final.xlsx'}, operation)
+        operation.assert_not_called()
+        cli.assert_not_called()
+
+    def test_query_uses_complete_pages_and_ignores_changing_total(self):
+        body = ready_body()
+        self.pending('save', body)
+        row = stored_row(body)
+        row['budgetStrategyTags'] = [1, 2]
+        with patch('resumable_delivery.run_cli', side_effect=[page([row], 1), page([], 7)]) as cli:
+            self.assertEqual(recover_write(self.root, 'save'), 91)
+        request = cli.call_args_list[0].args[1]
+        self.assertEqual(request['weekStart'], body['periodStart'])
+        self.assertNotIn('periodStart', request)
+        self.assertEqual(cli.call_count, 2)
+
+    def test_second_page_match_conflict_stays_unknown(self):
+        body = ready_body()
+        self.pending('save', body)
+        pages = [page([stored_row(body, 91)]), page([stored_row(body, 92)]), page([])] * 3
+        with patch('resumable_delivery.run_cli', side_effect=pages), patch('resumable_delivery.time.sleep'), \
+                self.assertRaises(UnknownWrite):
+            recover_write(self.root, 'save')
+        self.assertEqual(read_intent(self.root, 'save')['status'], 'pending')
+
+    def test_content_mismatch_is_not_success(self):
+        body = ready_body()
+        self.pending('save', body)
+        row = stored_row(body)
+        row['creativeStrategyLearning'] = '其他内容'
+        with patch('resumable_delivery.run_cli', side_effect=[page([row]), page([])] * 3), \
+                patch('resumable_delivery.time.sleep'), self.assertRaises(UnknownWrite):
+            recover_write(self.root, 'save')
+
+    def test_nonready_same_record_cannot_be_claimed(self):
+        body = {'bizLineId': 31, 'periodStart': '2026-10-12', 'periodEnd': '2026-10-18',
+                'generateCode': 'NO_AD_ACCOUNT', 'remark': '没有账号'}
+        self.pending('save', body)
+        with patch('resumable_delivery.run_cli', side_effect=[page([stored_row(body)]), page([])] * 3) as cli, \
+                patch('resumable_delivery.time.sleep'), self.assertRaises(UnknownWrite):
+            recover_write(self.root, 'save')
+        self.assertGreater(cli.call_count, 0)
+
+    def test_incomplete_or_failed_query_cannot_claim_seen_match(self):
+        body = ready_body()
+        self.pending('save', body)
+        with patch('resumable_delivery.run_cli', side_effect=[page([stored_row(body)]), RuntimeError('断网')] * 3), \
+                patch('resumable_delivery.time.sleep'), self.assertRaises(UnknownWrite):
+            recover_write(self.root, 'save')
+
+    def test_stale_output_without_intent_is_rejected(self):
+        (self.root / 'save.out.json').write_text(json.dumps({'ok': True, 'data': 91}))
+        operation = Mock(return_value=92)
+        with self.assertRaises(ValueError):
+            perform_write(self.root, 'save', ready_body(), operation)
+        operation.assert_not_called()
+
+    def test_changed_body_cannot_reuse_intent(self):
+        body = ready_body()
+        perform_write(self.root, 'save', body, Mock(return_value=91))
+        with self.assertRaises(ValueError):
+            perform_write(self.root, 'save', body | {'fileStorageKey': 'different'}, Mock())
+
+    def test_cancel_during_operation_keeps_intent_pending(self):
+        with self.assertRaises(InterruptedError):
+            perform_write(self.root, 'save', ready_body(), Mock(side_effect=InterruptedError('中断')))
+        self.assertEqual(read_intent(self.root, 'save')['status'], 'pending')
+
+    def test_success_output_recovers_after_checkpoint_write_failure(self):
+        body = ready_body()
+        from task_state import atomic_json
+        writes = []
+        def fail_done(path, value):
+            writes.append(value['status'])
+            if value['status'] == 'done':
+                raise OSError('模拟状态写入失败')
+            atomic_json(path, value)
+        def operation():
+            (self.root / 'save.out.json').write_text(json.dumps({'ok': True, 'data': 91}))
+            return 91
+        with patch('resumable_delivery.atomic_json', side_effect=fail_done), self.assertRaises(UnknownWrite):
+            perform_write(self.root, 'save', body, operation)
+        self.assertEqual(writes, ['pending', 'done'])
+        with patch('resumable_delivery.run_cli') as cli:
+            self.assertEqual(recover_write(self.root, 'save'), 91)
+        cli.assert_not_called()
+
+    def test_upload_checkpoint_failure_is_unknown_not_business_failure(self):
+        from task_state import atomic_json
+        def fail_done(path, value):
+            if value['status'] == 'done':
+                raise OSError('模拟上传成功记录落盘失败')
+            atomic_json(path, value)
+        operation = Mock(return_value='uploaded-key')
+        with patch('resumable_delivery.atomic_json', side_effect=fail_done), self.assertRaises(UnknownWrite):
+            perform_write(self.root, 'upload', {'file': 'final.xlsx'}, operation)
+        self.assertEqual(read_intent(self.root, 'upload')['status'], 'pending')
+        operation.assert_called_once()
+
+    def test_unterminated_pagination_does_not_claim_match(self):
+        body = ready_body()
+        self.pending('save', body)
+        with patch('resumable_delivery.run_cli', return_value=page([stored_row(body)])), \
+                patch('resumable_delivery._QUERY_LIMIT', 2), patch('resumable_delivery.time.sleep'), \
+                self.assertRaises(UnknownWrite):
+            recover_write(self.root, 'save')
+
+    def test_boolean_id_is_not_a_success(self):
+        with self.assertRaises(UnknownWrite):
+            perform_write(self.root, 'save', ready_body(), Mock(return_value=True))
+        self.assertEqual(read_intent(self.root, 'save')['status'], 'pending')
+
+    def test_identity_guard_runs_before_each_query_page(self):
+        body = ready_body()
+        self.pending('save', body)
+        guard = Mock()
+        with patch('resumable_delivery.run_cli', side_effect=[page([stored_row(body)]), page([])]):
+            self.assertEqual(recover_write(self.root, 'save', before_request=guard), 91)
+        self.assertEqual(guard.call_count, 2)
+
+    def test_cancel_before_query_does_not_make_http_calls(self):
+        self.pending('save', ready_body())
+        cancel = threading.Event()
+        cancel.set()
+        with patch('resumable_delivery.run_cli') as cli, self.assertRaises(InterruptedError):
+            recover_write(self.root, 'save', cancel=cancel)
+        cli.assert_not_called()
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,301 @@
+"""分阶段任务的组合回归：真实Excel及提交脚本，业务接口仅用匿名本地替代。"""
+from contextlib import ExitStack, contextmanager
+import json
+from pathlib import Path
+import signal
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import unittest
+from unittest.mock import patch
+import zipfile
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from detail_store import write_detail_rows
+from resumable_workflow import run_resumable
+from run_workflow import run_batch, workflow_parser
+from strategy_output import submit_tag_choices
+from resumable_requests import submit_ai_response
+from task_state import atomic_json, read_task
+from test_workflow import small_payload
+
+IDENTITY = {'authContextId': 'test-context', 'userType': 'sso', 'gatewayUrl': 'http://127.0.0.1'}
+AI_TEXT = '一页速览\n匿名数据，仅供测试。\n' + '\n'.join(f'【{heading}】\n- 匿名策略内容{index}。\nLearning（待观察）：样本不足，继续观察。'
+                    for index, heading in enumerate(('预算策略', '广告产品策略', '受众策略', '创意策略')))
+DICTIONARIES = {key: [{'id': index, 'name': key + '标签', 'isOther': 0},
+                      {'id': index + 10, 'name': '其他', 'isOther': 1}]
+                for index, key in enumerate(('budget', 'product', 'audience'), 1)}
+SCRIPTS = Path(__file__).resolve().parent
+
+
+def arguments(root, mode='excel', resume=None, ids=(11,)):
+    if resume:
+        return workflow_parser().parse_args(['--resume', str(resume)])
+    flags = ['--resumable', '--task-root', str(root), '--output-mode', mode,
+             '--curr-start', '2026-10-12', '--curr-end', '2026-10-18', '--concurrency', '1']
+    for ident in ids:
+        flags.extend(['--id', str(ident)])
+    if mode == 'excel':
+        flags.extend(['--output-dir', str(root / 'output')])
+    return workflow_parser().parse_args(flags)
+
+
+@contextmanager
+def fixture_apis(root, *, pause_fetch=False):
+    """替代取数/分析和出站调用，阶段调度、请求、文件生成校验保持真实。"""
+    calls = {'fetch': 0, 'analyze': 0, 'upload': 0, 'save': 0, 'saved': []}
+    def fetch(args):
+        calls['fetch'] += 1
+        directory = Path(args.request_dir)
+        atomic_json(directory / 'save-context.json', {'bizLineId': args.id,
+                    'periodStart': args.curr_start, 'periodEnd': args.curr_end})
+        if pause_fetch:
+            (root / 'fetch-entered').write_text(str(directory))
+            while not (root / 'continue-fetch').exists():
+                # 模拟真实取数所检查的工作流取消标记，不运行任何HTTP。
+                from cli_json import _local
+                if getattr(_local, 'cancel', None) and _local.cancel.is_set():
+                    raise InterruptedError('模拟取数收到SIGTERM')
+                time.sleep(0.01)
+        return {'id': args.id, 'name': '匿名业务线', 'adCategoryIndustryIds': [1]}
+    def analyze(directory):
+        calls['analyze'] += 1
+        payload = small_payload()
+        details = write_detail_rows(directory, payload.pop('details'))
+        payload['detailSource'] = details.reference(directory)
+        summary = {'detail_count': len(details), 'curr_total': 10, 'tag_evidence': {}}
+        atomic_json(directory / 'payload.json', payload)
+        atomic_json(directory / 'summary.json', summary)
+        return {**payload, 'details': details}, summary
+    def upload(directory, workbook):
+        calls['upload'] += 1
+        assert Path(workbook).is_file()
+        atomic_json(directory / 'upload.out.json', {'ok': True, 'data': {'storageKey': 'sample-key'}})
+        return 'sample-key'
+    def save(directory, body):
+        calls['save'] += 1
+        calls['saved'].append(body)
+        atomic_json(directory / 'save.out.json', {'ok': True, 'data': 321})
+        return 321
+    with ExitStack() as stack:
+        stack.enter_context(patch('run_workflow.fetch_business', fetch))
+        stack.enter_context(patch('run_workflow.summarize_request', analyze))
+        stack.enter_context(patch('strategy_output.TagCache.get', return_value=DICTIONARIES))
+        stack.enter_context(patch('run_workflow.upload_excel', upload))
+        stack.enter_context(patch('run_workflow.save_result', save))
+        yield calls
+
+
+def choices(request):
+    return {'selections': {key: [{'choiceKey': item['labels'][0]['choiceKey'], 'reason': '匿名正文动作对应'}]
+                           for key, item in request['strategies'].items()}}
+
+
+def submit_event(event, *, script=False):
+    packet = json.loads(Path(event['request_path']).read_text())
+    if event['event'] == 'tag_review_required':
+        body = choices(packet)
+        command = [sys.executable, str(SCRIPTS / 'submit_tags.py'), '--request', event['request_path'],
+                   '--review-id', event['reviewId']]
+        direct = lambda: submit_tag_choices(event['request_path'], event['reviewId'], body)
+    else:
+        body = {'text': AI_TEXT}
+        command = [sys.executable, str(SCRIPTS / 'submit_ai_strategy.py'), '--request', event['request_path'],
+                   '--request-id', event['requestId']]
+        direct = lambda: submit_ai_response(event['request_path'], event['requestId'], body)
+    if script:
+        result = subprocess.run(command, input=json.dumps(body), capture_output=True, text=True, timeout=10)
+        if result.returncode:
+            raise AssertionError(result.stderr)
+    else:
+        direct()
+
+
+class ResumableIntegrationTests(unittest.TestCase):
+    def advance(self, args, events=None, cancel=None):
+        return run_resumable(args, cancel or threading.Event(), (events if events is not None else []).append,
+                             identity_check=lambda _: IDENTITY)
+
+    def test_excel_three_calls_and_submit_scripts_match_legacy_workbook(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            with fixture_apis(root) as calls:
+                first = self.advance(arguments(root))
+                self.assertFalse(first['complete'])
+                self.assertEqual(first['results'][0]['request']['event'], 'tag_review_required')
+                task_path = first['taskPath']
+                submit_event(first['results'][0]['request'], script=True)
+                second = self.advance(arguments(root, resume=task_path))
+                self.assertEqual(second['results'][0]['request']['event'], 'ai_strategy_required', second)
+                submit_event(second['results'][0]['request'], script=True)
+                final = self.advance(arguments(root, resume=task_path))
+                self.assertTrue(final['ok'], final)
+                self.assertTrue(final['complete'])
+                self.assertEqual(calls['fetch'], 1)
+                self.assertEqual(calls['analyze'], 1)
+                self.assertEqual((calls['upload'], calls['save']), (0, 0))
+                output = Path(final['results'][0]['output_path'])
+                repeated = self.advance(arguments(root, resume=task_path))
+                self.assertEqual(repeated['results'][0]['output_path'], str(output))
+                self.assertEqual(len(list((root / 'output').glob('*.xlsx'))), 1)
+
+                def legacy_progress(event):
+                    if event.get('event') == 'tag_review_required':
+                        packet = json.loads(Path(event['request_path']).read_text())
+                        submit_tag_choices(event['request_path'], event['reviewId'], choices(packet))
+                    elif event.get('event') == 'ai_strategy_required':
+                        packet = {key: event[key] for key in ('bizLineId', 'attempt', 'requestId')}
+                        atomic_json(Path(event['response_path']), {**packet, 'text': AI_TEXT})
+                old_args = arguments(root / 'legacy')
+                old_args.resumable = False
+                legacy = run_batch(old_args, progress=legacy_progress)
+                self.assertTrue(legacy['ok'], legacy)
+                with zipfile.ZipFile(output) as actual, zipfile.ZipFile(legacy['results'][0]['output_path']) as old:
+                    self.assertEqual(set(actual.namelist()), set(old.namelist()))
+                    for name in actual.namelist():
+                        self.assertEqual(actual.read(name), old.read(name), name)
+
+    def test_database_saves_once_and_keeps_id_after_repeated_resume(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            with fixture_apis(root) as calls:
+                first = self.advance(arguments(root, 'database'))
+                submit_event(first['results'][0]['request'])
+                second = self.advance(arguments(root, resume=first['taskPath']))
+                submit_event(second['results'][0]['request'])
+                final = self.advance(arguments(root, resume=first['taskPath']))
+                self.assertTrue(final['ok'], final)
+                self.assertEqual(final['results'][0]['aiStrategyId'], 321)
+                self.assertEqual((calls['upload'], calls['save']), (1, 1))
+                self.assertEqual(calls['saved'][0]['fileStorageKey'], 'sample-key')
+                again = self.advance(arguments(root, resume=first['taskPath']))
+                self.assertTrue(again['ok'], again)
+                self.assertEqual((calls['upload'], calls['save']), (1, 1))
+                self.assertFalse(list(root.rglob('*.xlsx')))
+
+    def test_next_day_restarts_data_and_rejects_old_request(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            with fixture_apis(root) as calls, patch('resumable_workflow.shanghai_date', return_value='2026-10-25'):
+                first = self.advance(arguments(root))
+                old_request = first['results'][0]['request']
+            with fixture_apis(root) as next_calls, patch('resumable_workflow.shanghai_date', return_value='2026-10-26'):
+                resumed = self.advance(arguments(root, resume=first['taskPath']))
+                self.assertEqual(resumed['results'][0]['generation'], 2, resumed)
+                self.assertEqual(next_calls['fetch'], 1)
+                self.assertNotEqual(resumed['results'][0]['request']['reviewId'], old_request['reviewId'])
+                with self.assertRaises((ValueError, FileNotFoundError)):
+                    submit_event(old_request)
+                self.assertEqual(read_task(first['taskPath'])['inputs']['curr_start'], '2026-10-12')
+
+    def test_sigterm_during_fetch_preserves_task_for_a_new_process(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            code = """import sys,signal,threading,json
+from pathlib import Path
+sys.path.insert(0,sys.argv[1])
+from test_resumable_integration import arguments,fixture_apis,IDENTITY
+from resumable_workflow import run_resumable
+root=Path(sys.argv[2]); cancel=threading.Event()
+signal.signal(signal.SIGTERM,lambda *_:cancel.set())
+with fixture_apis(root,pause_fetch=True) as calls:
+ result=run_resumable(arguments(root,'database'),cancel,lambda _:None,identity_check=lambda _:IDENTITY)
+ (root/'child-result.json').write_text(json.dumps({'result':result,'calls':calls}))
+"""
+            proc = subprocess.Popen([sys.executable, '-B', '-c', code, str(SCRIPTS), str(root)],
+                                    stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            try:
+                deadline = time.monotonic() + 8
+                while not (root / 'fetch-entered').exists() and time.monotonic() < deadline:
+                    if proc.poll() is not None:
+                        self.fail(proc.communicate()[1])
+                    time.sleep(0.01)
+                self.assertTrue((root / 'fetch-entered').exists())
+                proc.send_signal(signal.SIGTERM)
+                out, error = proc.communicate(timeout=8)
+                self.assertEqual(proc.returncode, 0, out + error)
+                saved = json.loads((root / 'child-result.json').read_text())
+                self.assertEqual(saved['result']['status'], 'interrupted', saved)
+                self.assertEqual(saved['calls']['save'], 0)
+                task_path = saved['result']['taskPath']
+                task = read_task(task_path)
+                self.assertTrue(Path(task['lines']['11']['workPath']).is_dir())
+                # 原进程已经结束；由当前独立进程继续相同任务。
+                with fixture_apis(root) as calls:
+                    resumed = self.advance(arguments(root, resume=task_path))
+                    self.assertEqual(resumed['results'][0]['request']['event'], 'tag_review_required', resumed)
+                    self.assertEqual(calls['fetch'], 1)
+                    self.assertEqual(calls['save'], 0)
+            finally:
+                if proc.poll() is None:
+                    proc.kill()
+                    proc.communicate(timeout=5)
+
+    def test_midnight_after_upload_does_not_save_old_data(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            day = {'value': '2026-10-25'}
+            with fixture_apis(root) as calls, patch('resumable_workflow.shanghai_date', side_effect=lambda: day['value']):
+                first = self.advance(arguments(root, 'database'))
+                submit_event(first['results'][0]['request'])
+                second = self.advance(arguments(root, resume=first['taskPath']))
+                submit_event(second['results'][0]['request'])
+                import run_workflow
+                upload = run_workflow.upload_excel
+                def cross_midnight(directory, workbook):
+                    value = upload(directory, workbook)
+                    day['value'] = '2026-10-26'
+                    return value
+                with patch('run_workflow.upload_excel', cross_midnight):
+                    paused = self.advance(arguments(root, resume=first['taskPath']))
+                self.assertFalse(paused['complete'], paused)
+                self.assertEqual(calls['upload'], 1)
+                self.assertEqual(calls['save'], 0)
+                refreshed = self.advance(arguments(root, resume=first['taskPath']))
+                self.assertEqual(refreshed['results'][0]['generation'], 2, refreshed)
+                self.assertEqual(refreshed['results'][0]['request']['event'], 'tag_review_required')
+                self.assertEqual(calls['fetch'], 2)
+                self.assertEqual(calls['save'], 0)
+
+    def test_midnight_after_export_does_not_publish_old_data(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            day = {'value': '2026-10-25'}
+            with fixture_apis(root), patch('resumable_workflow.shanghai_date', side_effect=lambda: day['value']):
+                first = self.advance(arguments(root))
+                submit_event(first['results'][0]['request'])
+                second = self.advance(arguments(root, resume=first['taskPath']))
+                submit_event(second['results'][0]['request'])
+                import run_workflow
+                export = run_workflow.write_xlsx
+                def cross_midnight(rows, filename, details, **kwargs):
+                    value = export(rows, filename, details, **kwargs)
+                    if Path(filename).name == 'final.xlsx':
+                        day['value'] = '2026-10-26'
+                    return value
+                with patch('run_workflow.write_xlsx', cross_midnight):
+                    paused = self.advance(arguments(root, resume=first['taskPath']))
+                self.assertFalse(paused['complete'], paused)
+                self.assertFalse(list((root / 'output').glob('*.xlsx')))
+                refreshed = self.advance(arguments(root, resume=first['taskPath']))
+                self.assertEqual(refreshed['results'][0]['generation'], 2, refreshed)
+                self.assertEqual(refreshed['results'][0]['request']['event'], 'tag_review_required')
+
+    def test_pending_retains_ai_capacity_across_calls(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            with fixture_apis(root) as calls:
+                first = self.advance(arguments(root, ids=(11, 12, 13)))
+                self.assertEqual(calls['fetch'], 2)
+                self.assertEqual(sum(x['request'] is not None and x['request']['event'] == 'tag_review_required'
+                                     for x in first['results']), 1)
+                self.advance(arguments(root, resume=first['taskPath']))
+                self.assertEqual(calls['fetch'], 2)
+
+
+if __name__ == '__main__':
+    unittest.main()