sino-bc-cli 1.0.0-beta.0

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

@@ -0,0 +1,556 @@
+"""策略工作流的标签、业务预检及入库计划；所有网络请求仍由 CLI 执行。"""
+from datetime import date, datetime, timedelta, timezone
+from contextlib import contextmanager
+from hashlib import sha256
+import json
+import math
+import os
+from pathlib import Path
+import re
+import threading
+import time
+from uuid import uuid4
+
+from cli_json import optional_num, require_ok, run_cli
+from cleanup import is_link
+
+# 策略键与服务字段集中映射；数据库正文取 AI sheet，标签绑定沿用审核结果。
+STRATEGIES = {'budget': 'budget', 'product': 'media', 'audience': 'audience', 'creative': 'creative'}
+SCENES = {'budget': 'BUDGET_STRATEGY', 'product': 'MEDIA_STRATEGY', 'audience': 'AUDIENCE_STRATEGY'}
+RESULT_CODES = {'READY', 'NO_PROJECT', 'UNSUPPORTED_CHANNEL', 'NO_AD_ACCOUNT', 'NO_DELIVERY_DATA', 'GENERATION_FAILED'}
+TAG_REVIEW_SECONDS = 420
+TAG_REVIEW_ATTEMPTS = 2
+TAG_SUBMIT_HINT = '请使用 scripts/submit_tags.py 提交 choiceKey、reason；id（整数）由脚本自动补齐，不要直接写 response.json。'
+
+
+class IndustryConfigurationError(ValueError):
+    """缺少行业配置不能通过重拉成效修复，入库一次后不整条重试。"""
+
+
+def industry_condition(biz):
+    """行业筛选严格取业务线第一个行业 ID，不使用后续行业或人工默认值兜底。"""
+    ids = biz.get('adCategoryIndustryIds')
+    if not isinstance(ids, list) or not ids or type(ids[0]) is not int or ids[0] <= 0:
+        raise IndustryConfigurationError('业务线 adCategoryIndustryIds 缺少有效的首个行业 ID，无法查询策略标签')
+    return str(ids[0])
+
+
+class TagCache:
+    """同批次按行业缓存三类标签与错误；锁内加载避免并发重复查询。"""
+    def __init__(self, root):
+        self.root = root
+        self.lock = threading.Lock()
+        self.values, self.errors = {}, {}
+
+    def reset_errors(self):
+        """整轮结束后才清除失败缓存，成功行业字典继续在本批次复用。"""
+        with self.lock:
+            self.errors.clear()
+
+    def get(self, biz):
+        """同行业复用，不同行业使用独立文件目录；不跨批次复用过期字典。"""
+        condition = industry_condition(biz)
+        with self.lock:
+            if condition in self.errors:
+                raise RuntimeError(self.errors[condition])
+            if condition not in self.values:
+                try:
+                    industry_root = self.root / ('industry-' + condition)
+                    industry_root.mkdir(parents=True, exist_ok=True)
+                    self.values[condition] = load_tags(industry_root, condition)
+                except Exception as exc:
+                    self.errors[condition] = str(exc)
+                    raise
+            return self.values[condition]
+
+
+class GenerationOutcome(RuntimeError):
+    """预期不可生成结果，与传输错误分开，防止失败回包被解释成无数据。"""
+    def __init__(self, code, message):
+        super().__init__(message)
+        self.code = code
+
+
+def validate_period(start, end, today=None):
+    """保存接口只接受已结束且受支持的完整自然周，不发送展示状态。"""
+    start, end = date.fromisoformat(start), date.fromisoformat(end)
+    if start.weekday() != 0 or end != start + timedelta(days=6):
+        raise ValueError('入库周期必须是同一自然周的周一至周日')
+    if end >= (today or date.today()):
+        raise ValueError('入库周期尚未结束')
+    if start < date(2026, 9, 7):
+        raise ValueError('入库周期早于当前契约支持的 2026-09-07')
+
+
+def precheck_projects(root, biz_id, expected_ids=None, *, skip_spend_check=False):
+    """逐页核对项目覆盖和上周消耗；渠道由关联接口的广告账号单独校验。"""
+    total = None
+    count = 0
+    all_zero, positive = True, False
+    seen = set()
+    for page in range(1, 81):
+        env = require_ok(run_cli(['biz-line', '+queryByPage'], {
+            'bizLineIdList': [biz_id], 'pageNum': page, 'pageSize': 100,
+        }, root / f'precheck.p{page}.out.json'), '项目预检')
+        data = env.get('data')
+        if not isinstance(data, dict) or not isinstance(data.get('result'), list) or type(data.get('total')) is not int or data['total'] < 0:
+            raise RuntimeError('项目预检分页格式无效')
+        if total is not None and total != data['total']:
+            raise RuntimeError('项目预检分页总数变化')
+        total = data['total']
+        rows = data['result']
+        for item in rows:
+            if not isinstance(item, dict) or item.get('projectId') is None or item['projectId'] in seen:
+                raise RuntimeError('项目预检含无效或重复项目')
+            seen.add(item['projectId'])
+            value = optional_num(item, 'lastWeekSpend')
+            if isinstance(item.get('lastWeekSpend'), bool):
+                value = None
+            all_zero = all_zero and value == 0
+            positive = positive or (value is not None and value > 0)
+        count += len(rows)
+        if count > total:
+            raise RuntimeError('项目预检累计数量超过总数')
+        if count == total:
+            break
+        if not rows or page == 80:
+            raise RuntimeError('项目预检分页未取全')
+    # 服务端默认只查代投服务，必须用业务线关联 ID 校验覆盖，防止漏项目误判全零。
+    if expected_ids is not None and {str(v) for v in seen} != {str(v) for v in expected_ids}:
+        raise RuntimeError('项目分页未覆盖业务线全部关联项目（接口默认服务范围为 1、85），不能判断无项目或消耗全零')
+    if not count:
+        raise GenerationOutcome('NO_PROJECT', '业务线未关联项目')
+    # 仅用户显式跳过消耗门槛；项目覆盖、后续关联账号渠道和目标周期检查仍保留。
+    if not skip_spend_check and all_zero:
+        raise GenerationOutcome('NO_DELIVERY_DATA', '全部关联项目上周消耗 lastWeekSpend 均为 0')
+    if not skip_spend_check and not positive:
+        raise RuntimeError('项目上周消耗缺失或异常，不能判断为全零')
+
+
+def load_tags(root, condition):
+    """每批次串行获取三类字典，保留服务返回的 ID 与名称，不虚构枚举。"""
+    if not isinstance(condition, str) or not condition.isdecimal() or int(condition) <= 0:
+        raise ValueError('策略字典筛选值必须是业务线首个行业 ID 的字符串')
+    result = {}
+    for key, scene in SCENES.items():
+        # 三个场景共用该业务线首个行业 ID，保留真实字典 ID/name。
+        query = {'sceneCode': scene, 'filterCondition': condition}
+        env = require_ok(run_cli(['biz-line', '+categories'], query,
+                                 root / f'tags-{key}.out.json'), f'{scene} 字典')
+        data = env.get('data')
+        if not isinstance(data, list) or not data:
+            raise ValueError(f'{scene} 字典为空或格式无效，无法取得标签 ID，请核对服务端场景字典配置')
+        result[key] = flatten_tags(data)
+    return result
+
+
+def flatten_tags(items):
+    """兼容字典 children 树，重复 ID 必须对应同名，避免输出与写入不一致。"""
+    found = {}
+    def visit(nodes):
+        for item in nodes:
+            if not isinstance(item, dict) or type(item.get('id')) is not int or item['id'] <= 0 or not isinstance(item.get('name'), str) or not item['name'].strip():
+                raise ValueError('策略字典缺少有效 ID/name')
+            if item['id'] in found and found[item['id']]['name'] != item['name']:
+                raise ValueError('策略字典同 ID 对应不同名称')
+            found[item['id']] = item
+            children = item.get('children')
+            if children is not None:
+                if not isinstance(children, list):
+                    raise ValueError('策略字典 children 格式无效')
+                visit(children)
+    visit(items)
+    return list(found.values())
+
+
+def reviewed_tags(labels, selections):
+    """校验 Agent 内容分析结果：只接受本场景真实 ID、有理由的非重复选择。"""
+    by_id = {item['id']: item for item in flatten_tags(labels)}
+    if not isinstance(selections, list) or not selections:
+        raise ValueError('每类策略必须提供至少一个标签选择及理由')
+    matched = []
+    for choice in selections:
+        if not isinstance(choice, dict) or type(choice.get('id')) is not int or choice['id'] not in by_id:
+            raise ValueError('标签选择包含不属于本行业本场景的 ID')
+        if not isinstance(choice.get('reason'), str) or not choice['reason'].strip():
+            raise ValueError('标签选择必须说明策略内容与标签的对应关系；其他须说明无适合项')
+        item = by_id[choice['id']]
+        if item in matched:
+            raise ValueError('标签选择包含重复 ID')
+        matched.append(item)
+    if len(matched) > 1 and any(item.get('isOther') == 1 or item['name'].strip() == '其他' for item in matched):
+        raise ValueError('有适合标签时不能同时选其他')
+    if any(item.get('isOther') == 1 or item['name'].strip() == '其他' for item in matched):
+        others = [item for item in by_id.values() if item.get('isOther') == 1 or item['name'].strip() == '其他']
+        if len(others) != 1:
+            raise ValueError('本场景缺少唯一其他标签，不能任意选择兜底')
+    if len(json.dumps([item['id'] for item in matched])) > 500:
+        raise ValueError('策略标签 ID 数组序列化后超过 500 字符')
+    return matched
+
+
+def choice_key(review_id, strategy, tag_id):
+    """编号绑定本次随机审核和策略类别，同行业同ID也不能错投。"""
+    return strategy[0].upper() + '-' + sha256(f'{review_id}:{strategy}:{tag_id}'.encode('utf-8')).hexdigest()[:16]
+
+
+@contextmanager
+def tag_review_lock(root):
+    """提交、消费与关闭共用本条目录锁；目录清理后不重新创建。"""
+    root = Path(root).absolute()
+    if not root.is_dir() or is_link(root):
+        raise ValueError('标签请求目录不存在或路径已变化')
+    # Windows临时根可能使用8.3短路径，规范化后再创建本条锁。
+    root = root.resolve()
+    lock = root / '.tag-review.lock'
+    deadline = time.monotonic() + 5
+    while True:
+        try:
+            descriptor = os.open(lock, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
+            break
+        except FileExistsError:
+            if time.monotonic() >= deadline:
+                raise ValueError('标签交接锁繁忙，禁止删除锁或覆盖响应')
+            time.sleep(0.02)
+    try:
+        yield
+    finally:
+        # 仅释放本次实际创建的锁，不清理其他提交者替换的文件。
+        original = os.fstat(descriptor)
+        os.close(descriptor)
+        try:
+            if os.path.samestat(original, lock.stat(follow_symlinks=False)):
+                lock.unlink()
+        except FileNotFoundError:
+            pass
+
+
+def close_tag_review(request):
+    """期限结束或取消后保留关闭标记，迟到提交不能复活旧请求。"""
+    request = Path(request)
+    with tag_review_lock(request.parent):
+        closed = request.with_name(request.name.replace('.request.json', '.closed.json'))
+        if not closed.exists():
+            with closed.open('x', encoding='utf-8') as stream:
+                json.dump({'closed': True}, stream)
+
+
+def read_tag_request(path, expected_review_id):
+    """提交只接受当前审核路径，拒绝过期、关闭、被替代和已有响应。"""
+    path = Path(path).absolute()
+    match = re.fullmatch(r'tag-review\.([12])\.request\.json', path.name)
+    if not match or is_link(path):
+        raise ValueError('标签请求路径无效')
+    raw = path.read_bytes()
+    packet = json.loads(raw.decode('utf-8-sig'))
+    if not isinstance(packet, dict) or type(packet.get('bizLineId')) is not int or packet['bizLineId'] <= 0 \
+            or type(packet.get('attempt')) is not int or packet['attempt'] <= 0 \
+            or not isinstance(expected_review_id, str) or not expected_review_id \
+            or packet.get('reviewId') != expected_review_id or packet.get('submissionMode') != 'choice-key-v1':
+        raise ValueError('标签请求身份或编号协议不一致')
+    expires = packet.get('expiresAt')
+    closed = path.with_name(path.name.replace('.request.json', '.closed.json'))
+    if type(expires) not in (int, float) or not math.isfinite(expires) or time.time() >= expires \
+            or closed.exists() or any((path.parent / f'tag-review.{later}.request.json').exists()
+                                     for later in range(int(match[1]) + 1, TAG_REVIEW_ATTEMPTS + 1)):
+        raise ValueError('标签请求已过期、关闭或被下一次审核替代')
+    response = path.with_name(path.name.replace('.request.json', '.response.json'))
+    if response.exists() or response.is_symlink():
+        raise ValueError('标签响应已存在，禁止覆盖')
+    return raw, packet, response
+
+
+def validate_tag_choice_fields(item, location, *, include_id=False):
+    """提交端与消费端复用字段诊断，只细化错误提示，不改变标签合法性规则。"""
+    if not isinstance(item, dict):
+        raise ValueError(f'{location} 必须是标签选择对象；{TAG_SUBMIT_HINT}')
+    fields = ('id', 'choiceKey', 'reason') if include_id else ('choiceKey', 'reason')
+    missing = [field for field in fields if field not in item]
+    if missing:
+        raise ValueError(f'{location} 缺少字段：{", ".join(missing)}；{TAG_SUBMIT_HINT}')
+    if include_id and type(item['id']) is not int:
+        raise ValueError(f'{location}.id 必须是整数，不能是布尔值或字符串；{TAG_SUBMIT_HINT}')
+    if not isinstance(item['choiceKey'], str) or not item['choiceKey'].strip():
+        raise ValueError(f'{location}.choiceKey 必须是本次候选的非空字符串编号；{TAG_SUBMIT_HINT}')
+    if not isinstance(item['reason'], str) or not item['reason'].strip():
+        raise ValueError(f'{location}.reason 必须是非空字符串，说明正文与标签的对应依据；{TAG_SUBMIT_HINT}')
+
+
+def map_tag_choices(packet, selection):
+    """复用原ID/理由校验；输出携带编号，消费端再次验证对应关系。"""
+    if not isinstance(selection, dict) or set(selection) != {'selections'} \
+            or not isinstance(selection['selections'], dict) or set(selection['selections']) != set(SCENES) \
+            or not isinstance(packet.get('strategies'), dict) or set(packet['strategies']) != set(SCENES):
+        raise ValueError(f'提交必须只包含 selections.budget/product/audience 三类编号与理由；{TAG_SUBMIT_HINT}')
+    result = {}
+    for key in SCENES:
+        labels = flatten_tags(packet['strategies'][key]['labels'])
+        by_key = {item['choiceKey']: item for item in labels}
+        if len(by_key) != len(labels) or any(item['choiceKey'] != choice_key(packet['reviewId'], key, item['id'])
+                                           for item in labels):
+            raise ValueError('候选编号与当前请求或场景不一致')
+        choices = selection['selections'][key]
+        if not isinstance(choices, list) or not choices:
+            raise ValueError(f'{key} 必须是非空标签选择数组；{TAG_SUBMIT_HINT}')
+        result[key] = []
+        for index, item in enumerate(choices):
+            location = f'{key}[{index}]'
+            validate_tag_choice_fields(item, location)
+            if set(item) != {'choiceKey', 'reason'}:
+                extra = ', '.join(sorted(set(item) - {'choiceKey', 'reason'}))
+                raise ValueError(f'{location} 含多余字段：{extra}，提交输入只允许 choiceKey、reason；{TAG_SUBMIT_HINT}')
+            if item['choiceKey'] not in by_key:
+                raise ValueError(f'{location}.choiceKey 不属于当前请求/场景；请重新读取本次 request.json；{TAG_SUBMIT_HINT}')
+            result[key].append({'id': by_key[item['choiceKey']]['id'], **item})
+        reviewed_tags(labels, result[key])
+    return result
+
+
+def submit_tag_choices(request, review_id, selection):
+    """统一提交入口：回读、映射、再核对原文，完整落盘后独占原子发布。"""
+    request = Path(request).absolute()
+    with tag_review_lock(request.parent):
+        raw, packet, response = read_tag_request(request, review_id)
+        mapped = map_tag_choices(packet, selection)
+        body = {key: packet[key] for key in ('bizLineId', 'attempt', 'reviewId')}
+        body['selections'] = mapped
+        temp = response.with_name(response.name + '.' + uuid4().hex + '.tmp')
+        created = False
+        try:
+            with temp.open('x', encoding='utf-8') as stream:
+                created = True
+                json.dump(body, stream, ensure_ascii=False)
+                stream.flush()
+                os.fsync(stream.fileno())
+            latest, _, _ = read_tag_request(request, review_id)
+            if raw != latest:
+                raise ValueError('标签请求在提交期间发生变化')
+            os.link(temp, response)
+        finally:
+            if created:
+                temp.unlink(missing_ok=True)
+        return response
+
+
+def review_tags(row, dictionaries, evidence, root, cancel, progress, *, biz_line_id, attempt):
+    """只重试已分析数据的标签选择；穷尽后按真实字典兜底。"""
+    if type(biz_line_id) is not int or biz_line_id <= 0 or type(attempt) is not int or attempt <= 0:
+        raise ValueError('标签审核缺少有效的业务线 ID 或尝试轮次')
+    # 在进入审核循环前验证字典，避免字典故障被误当成回包错误并触发兜底。
+    flat_dictionaries = {key: flatten_tags(dictionaries[key]) for key in SCENES}
+    strategies = {}
+    for key in SCENES:
+        labels = []
+        for item in flat_dictionaries[key]:
+            # 候选只传审核所需语义字段，原字典仍用于最终 ID/名称校验。
+            candidate = {'id': item['id'], 'name': item['name'],
+                         'isOther': 1 if item.get('isOther') == 1 or item['name'].strip() == '其他' else 0}
+            for field in ('description', 'itemCode'):
+                if isinstance(item.get(field), str) and item[field].strip():
+                    candidate[field] = item[field].strip()
+            labels.append(candidate)
+        strategies[key] = {'strategy': row[key + 'Strategy'], 'labels': labels,
+                           'facts': evidence.get(key, [])}
+    failures = []
+    for review_attempt in range(1, TAG_REVIEW_ATTEMPTS + 1):
+        if cancel.is_set():
+            raise InterruptedError('任务已取消')
+        # 每次选择独立文件与审核 ID；旧回包即使晚到也不会被新一轮读取。
+        request = root / f'tag-review.{review_attempt}.request.json'
+        response = root / f'tag-review.{review_attempt}.response.json'
+        review_id = uuid4().hex
+        content = {'bizLineId': biz_line_id, 'attempt': attempt, 'reviewId': review_id,
+                   'expiresAt': time.time() + TAG_REVIEW_SECONDS, 'submissionMode': 'choice-key-v1',
+                   'strategies': {key: {**value, 'labels': [
+                       {**label, 'choiceKey': choice_key(review_id, key, label['id'])}
+                       for label in value['labels']]} for key, value in strategies.items()}}
+        request.write_text(json.dumps(content, ensure_ascii=False), encoding='utf-8')
+        issued_at = datetime.now(timezone.utc).isoformat(timespec='milliseconds').replace('+00:00', 'Z')
+        started = time.monotonic()
+        try:
+            progress({'event': 'tag_review_required', 'bizLineId': biz_line_id, 'attempt': attempt,
+                  'reviewAttempt': review_attempt, 'reviewId': review_id, 'issuedAt': issued_at,
+                  'expiresAt': content['expiresAt'], 'request_path': str(request), 'response_path': str(response)})
+            selected, reason, kind = _wait_tag_response(request, response, content, cancel,
+                                                       started + TAG_REVIEW_SECONDS)
+        finally:
+            close_tag_review(request)
+        if cancel.is_set():
+            raise InterruptedError('任务已取消')
+        if selected is not None:
+            progress({'event': 'tag_review_accepted', 'bizLineId': biz_line_id,
+                      'attempt': attempt, 'reviewAttempt': review_attempt, 'reviewId': review_id,
+                      'waitSeconds': round(time.monotonic() - started, 3)})
+            return selected
+        failures.append({'reviewAttempt': review_attempt, 'reason': reason, 'kind': kind})
+        progress({'event': 'tag_review_rejected', 'bizLineId': biz_line_id,
+                  'attempt': attempt, 'reviewAttempt': review_attempt, 'reviewId': review_id, 'reason': reason})
+    selections, missing_other = {}, []
+    for key in SCENES:
+        others = [item for item in flat_dictionaries[key]
+                  if item.get('isOther') == 1 or item['name'].strip() == '其他']
+        if len(others) == 1:
+            selections[key] = [{'id': others[0]['id'],
+                                'reason': '两次标签审核被拒绝或超时，自动选择本场景其他标签'}]
+        else:
+            selections[key] = []
+            missing_other.append(key)
+    progress({'event': 'tag_review_fallback', 'bizLineId': biz_line_id, 'attempt': attempt,
+              'reviewAttempts': TAG_REVIEW_ATTEMPTS, 'failures': failures, 'missingOtherScenes': missing_other})
+    return selections
+
+
+def _wait_tag_response(request, response, content, cancel, deadline):
+    """消费端复核编号映射；成功仍返回原ID/理由供Excel和入库共用。"""
+    while not cancel.is_set():
+        with tag_review_lock(request.parent):
+            # 排队等待锁和映射校验同样计入7分钟，不另加分析时限。
+            if time.monotonic() >= deadline:
+                return None, '等待 Agent 分析策略标签达到 7 分钟上限', 'timeout'
+            if response.exists():
+                try:
+                    if is_link(response):
+                        raise ValueError('标签响应不能是链接')
+                    reply = json.loads(response.read_text(encoding='utf-8-sig'))
+                    if not isinstance(reply, dict) or set(reply) != {'bizLineId', 'attempt', 'reviewId', 'selections'}:
+                        raise ValueError('标签审核响应身份或结构无效')
+                    # 同行业共享候选 ID，必须先核对请求身份，再检查标签属于对应场景。
+                    if type(reply['bizLineId']) is not int or reply['bizLineId'] != content['bizLineId'] or \
+                            type(reply['attempt']) is not int or reply['attempt'] != content['attempt'] or \
+                            not isinstance(reply['reviewId'], str) or reply['reviewId'] != content['reviewId']:
+                        raise ValueError('标签审核响应身份与当前业务线、轮次或请求不一致')
+                    selections = reply['selections']
+                    if not isinstance(selections, dict) or set(selections) != set(SCENES):
+                        raise ValueError('标签分析结果必须包含 budget/product/audience 三类')
+                    for key, items in selections.items():
+                        if not isinstance(items, list) or not items:
+                            raise ValueError(f'{key} 必须是非空标签响应数组；{TAG_SUBMIT_HINT}')
+                        for index, item in enumerate(items):
+                            validate_tag_choice_fields(item, f'{key}[{index}]', include_id=True)
+                    # 三类全部核实后才接受，不能部分采用一份被拒绝的回包。
+                    numbered = {'selections': {key: [
+                        {'choiceKey': item['choiceKey'], 'reason': item['reason']} for item in selections[key]]
+                        for key in SCENES}}
+                    mapped = map_tag_choices(content, numbered)
+                    if mapped != selections:
+                        raise ValueError(f'标签响应的 id/choiceKey 映射或字段与本次请求不一致；{TAG_SUBMIT_HINT}')
+                except KeyError as exc:
+                    return None, f'标签响应或请求缺少字段：{exc.args[0]}；{TAG_SUBMIT_HINT}', 'rejected'
+                except (ValueError, TypeError, UnicodeError) as exc:
+                    return None, str(exc), 'rejected'
+                if time.monotonic() >= deadline:
+                    return None, '等待 Agent 分析策略标签达到 7 分钟上限', 'timeout'
+                if cancel.is_set():
+                    raise InterruptedError('任务已取消')
+                return {key: [{'id': item['id'], 'reason': item['reason']} for item in mapped[key]]
+                        for key in SCENES}, '', ''
+        cancel.wait(min(0.2, max(0, deadline - time.monotonic())))
+    raise InterruptedError('任务已取消')
+
+
+def attach_tags(row, dictionaries, evidence, selections):
+    """展示名称与保存 ID 同时生成，防止 Excel 与数据库各自重新匹配。"""
+    for key in SCENES:
+        if selections[key] == []:
+            others = [item for item in flatten_tags(dictionaries[key])
+                      if item.get('isOther') == 1 or item['name'].strip() == '其他']
+            if len(others) == 1:
+                raise ValueError('存在唯一其他标签时不得保存空标签')
+            row[key + 'TagIds'] = []
+            row[key + 'Tags'] = ''
+            row[key + 'TagFallbackMissingOther'] = True
+            continue
+        matched = reviewed_tags(dictionaries[key], selections[key])
+        row[key + 'TagIds'] = [item['id'] for item in matched]
+        row[key + 'Tags'] = '\n'.join(item['name'] for item in matched)
+
+
+def effect_code(verdict):
+    """以分析器的结构化结论编码，预警仍归入待观察。"""
+    if verdict == '有效':
+        return 1
+    if verdict == '无效':
+        return 2
+    if verdict in ('待观察', '待观察（预警）', '待观察（潜力）'):
+        return 3
+    raise ValueError(f'未知策略效果结论：{verdict}')
+
+
+# 只识别独立末段标题，不从投放叙述里的“有效”词汇推断效果。
+_AI_LEARNING = re.compile(
+    r'(?im)^[ \t]*(?:【Learning】[ \t]*\n[ \t]*(?:Learning[ \t]*)?|Learning[ \t]*)'
+    r'[（(](有效|无效|待观察)[）)][ \t]*[：:]')
+_AI_LEARNING_MARKER = re.compile(r'(?im)^[ \t]*(?:【Learning】|Learning\b)')
+AI_HEADINGS = {'budget': '预算策略', 'product': '广告产品策略',
+               'audience': '受众策略', 'creative': '创意策略'}
+
+
+def split_ai_learning(value):
+    """机械拆分 AI 最后一段：保留正文与说明内部换行，标签精确转效果码。"""
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError('AI 策略单元格为空')
+    normalized = value.replace('\r\n', '\n').replace('\r', '\n')
+    matches = list(_AI_LEARNING.finditer(normalized))
+    if len(matches) != 1:
+        raise ValueError('AI 策略缺少唯一合法 Learning（有效/无效/待观察）：说明')
+    match = matches[0]
+    # 单独小节标题和其紧接的标签视为同一段；其他 Learning 标题一律拒绝。
+    if any(not match.start() <= marker.start() < match.end()
+           for marker in _AI_LEARNING_MARKER.finditer(normalized)):
+        raise ValueError('AI 策略存在重复或无效 Learning 段')
+    strategy = normalized[:match.start()].strip()
+    learning = normalized[match.end():].strip()
+    if not strategy or not learning:
+        raise ValueError('AI 策略正文或 Learning 说明不能为空')
+    # Learning 必须收尾，不能把其后重新出现的策略小节误存为效果说明。
+    if re.search(r'(?m)^[ \t]*(?:【(?:策略总结|调整方向|关键数据)】|(?:策略总结|调整方向|关键数据)[ \t]*[：:])', learning):
+        raise ValueError('AI 策略 Learning 必须是最后一个小节')
+    return strategy, effect_code(match.group(1)), learning
+
+
+def ready_body(context, ai_sheet, tag_row, storage_key):
+    """从实际 AI sheet 组装 READY；固定行仅提供本业务线已审核的标签 ID 绑定。"""
+    if not isinstance(storage_key, str) or not storage_key.strip() or len(storage_key) > 512:
+        raise ValueError('缺少有效 Excel storageKey')
+    body = {**context, 'generateCode': 'READY', 'fileStorageKey': storage_key}
+    for local, remote in STRATEGIES.items():
+        strategy, effect, learning = split_ai_learning(ai_sheet.get(AI_HEADINGS[local]))
+        destination = 'creativeStrategy' if local == 'creative' else remote + 'StrategySupplement'
+        body[destination] = strategy
+        body[remote + 'StrategyLearning'] = learning
+        body[remote + 'StrategyEffect'] = effect
+        if local in SCENES:
+            # 名称来自工作簿，只能绑定本条已审核 ID；同名也不重新查询行业字典。
+            names = ai_sheet.get(AI_HEADINGS[local] + '标签')
+            expected_names = tag_row.get(local + 'Tags')
+            if not isinstance(names, str) or names != expected_names:
+                raise ValueError(f'{local} AI sheet 标签与本业务线审核结果不一致')
+            tags = tag_row.get(local + 'TagIds')
+            empty_fallback = tags == [] and names == '' and tag_row.get(local + 'TagFallbackMissingOther') is True
+            if not isinstance(tags, list) or ((not tags or not names) and not empty_fallback) or \
+                    any(type(v) is not int or v <= 0 for v in tags) or len(json.dumps(tags)) > 500:
+                raise ValueError(f'{local} 策略标签 ID 无效')
+            body[remote + 'StrategyTags'] = list(tags)
+    return body
+
+
+def upload_excel(root, path):
+    """通用上传返回值已经被 CLI 解包为 data；不使用营销协同 file 域。"""
+    env = require_ok(run_cli(['common-file', '+upload'], {'file': str(path), 'serviceName': 'sino-opti-hive'},
+                             root / 'upload.out.json'), 'Excel 上传')
+    data = env.get('data')
+    key = data.get('storageKey') if isinstance(data, dict) else None
+    if not isinstance(key, str) or not key.strip() or len(key) > 512:
+        raise RuntimeError('上传未返回有效 storageKey')
+    return key
+
+
+def save_result(root, body):
+    """非幂等保存只尝试一次，错误或不完整回包交由调用方报告，不重试。"""
+    if body.get('generateCode') not in RESULT_CODES:
+        raise ValueError('禁止保存展示状态或未知 generateCode')
+    env = require_ok(run_cli(['biz-line-ai-strategy', '+ai-strategy-save'], body, root / 'save.out.json'), 'AI 策略保存失败或结果未知')
+    ident = env.get('data')
+    if type(ident) is not int or ident <= 0:
+        raise RuntimeError('保存未返回有效 aiStrategyId，结果未知，不自动重试')
+    return ident

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

@@ -0,0 +1,32 @@
+"""复用标签审核规则，一次提交本请求的候选编号，不由AI手写身份或真实ID。"""
+import argparse
+import json
+from pathlib import Path
+import sys
+
+# 从安装目录独立调用也不产生解释器缓存。
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from strategy_output import submit_tag_choices
+
+
+def main():
+    """固定UTF-8 stdin，主工作流接受事件才代表审核完成。"""
+    for stream in (sys.stdin, sys.stdout, sys.stderr):
+        if hasattr(stream, 'reconfigure'):
+            stream.reconfigure(encoding='utf-8')
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--request', required=True)
+    parser.add_argument('--review-id', required=True)
+    args = parser.parse_args()
+    try:
+        response = submit_tag_choices(args.request, args.review_id, json.load(sys.stdin))
+        print(json.dumps({'ok': True, 'response_path': str(response)}, ensure_ascii=False))
+        return 0
+    except (ValueError, OSError, KeyError, TypeError, UnicodeError) as exc:
+        print(json.dumps({'ok': False, 'error': str(exc)}, ensure_ascii=False), file=sys.stderr)
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())