@miravia_test/miravia-publish-skill 0.1.7 → 0.1.9

package/dist/SKILL.md

@@ -112,10 +112,12 @@ description: Miravia 商品发布 AI Skill。仅负责商品创建（手动一
 | `need_brand_create` | 品牌未找到，需去 Seller Center 处理 | 先引导查看已有品牌及审核状态（https://sellercenter.miravia.es/apps/setting/seller/brandlist，可能已在审核中），确无再创建（https://sellercenter.miravia.es/apps/product/publish/brand）；创建后重新运行命令 |
 | `need_mandatory_fields` | 缺少必填字段；**图片缺失为硬阻断（不可 Draft）**，价格/重量/尺寸缺失可 `--draft` | 补充字段后重跑 |
 | `need_category_attributes` | 类目必填属性缺失（AI抽取模式） | 通过 `--attribute-data` 补充或使用 `--draft` |
+| `need_attribute_mapping` | Excel/CSV 列未能自动匹配到类目属性（不静默丢弃），返回该列及其候选属性 | 向用户展示候选属性，确认后用 `--attribute-data '{"<属性名>":"<值>"}'` 重跑；非商品属性则删除该列 |
 | `need_field_summary` | 需要确认字段摘要或选择草稿模式 | 回传 `field_summary_token`，可加 `--draft` |
 | `need_compliance` | 制造商/EU 负责人匹配失败 | 按返回候选选择或补充信息后重跑 |
 | `compliance_missing_suggest_draft` | 合规字段缺失（制造商/欧代/Safety Warning内容/合规文档） | 补充合规字段或加 `--draft` 发布为草稿 |
 | `gpsr_missing_suggest_draft` | GPSR 字段缺失（制造商和/或欧盟负责人为空） | 补充 GPSR 字段或加 `--draft` 发布为草稿 |
+| `need_safety_warning_confirm` | AI/Excel 源检测到安全相关内容，但卖家未显式设置「该产品是否有安全警告」；系统**不会**静默默认为 No | 展示 `detected_safety_content` 证据与当前值，让卖家确认：确有则加 `--safety-warning yes`（必要时 `--safety-warning-content`）重跑；确无则加 `--safety-warning no` 确认；或在 Excel 补齐该列后重跑 |
 | `post_to_inactive_missing_suggest_draft` | 类目必填字段缺失（EAN） | 补充字段或加 `--draft` 发布为草稿 |
 | `special_category_block` | 特殊类目规则阻断（PPU 值无效 / 图书类目 ISBN 缺失） | 修正错误后重跑，不可转 Draft |
 | `special_category_suggest_draft` | 特殊类目字段缺失（PPU 缺失 / 食品属性缺失） | 补充字段或加 `--draft` 发布为草稿 |

package/dist/VERSION

@@ -1 +1 @@
-0.1.7
+0.1.9

package/dist/scripts/config.py

@@ -220,6 +220,31 @@ def require_business_credentials() -> None:
             pass
 
 
+def has_valid_business_credentials() -> bool:
+    """Return True when credentials are present and not expired.
+
+    Non-raising companion to ``require_business_credentials``. The publish
+    flow uses this to decide whether the seller is already authorized: when
+    valid credentials exist (they can only exist after a successful
+    ``auth_cli.py login``, which grants the read-profile / access-products /
+    update-products scopes), the skill must not re-prompt the three-item
+    authorization consent on every run. Returns False for missing or expired
+    credentials so the caller falls back to asking the seller.
+    """
+    if not (APP_KEY and APP_SECRET and ACCESS_TOKEN):
+        return False
+
+    if TOKEN_EXPIRES_AT:
+        try:
+            expires_at_ms = int(TOKEN_EXPIRES_AT)
+            if expires_at_ms > 0 and int(time.time() * 1000) > expires_at_ms - 60_000:
+                return False
+        except ValueError:
+            pass
+
+    return True
+
+
 def mask_token(token: str) -> str:
     if not token:
         return "<empty>"

package/dist/scripts/extraction_engine.py

@@ -371,6 +371,7 @@ _TABLE_FIELD_SYNONYMS: Dict[str, tuple] = {
     "length_cm": ("长度", "长cm", "长", "length", "largura"),
     "width_cm": ("宽度", "宽cm", "宽", "width", "ancho"),
     "height_cm": ("高度", "高cm", "高", "height", "altura"),
+    "delivery_method": ("deliverymethod", "delivery", "shippingmethod", "shipping", "物流方式", "物流", "发货方式", "配送方式", "metododeenvío", "metododeenvio", "envío", "envio", "spedizione", "metododiconsegna"),
     "manufacturer_name": ("制造商", "厂家", "manufacturer", "fabricante"),
     "eu_responsible_person_name": ("欧盟负责人", "欧代", "euresponsibleperson", "eurp"),
     "variation_1": ("颜色", "color", "colour", "variation1", "variation", "款式"),
@@ -389,6 +390,7 @@ _PRODUCT_LEVEL_FIELDS = {
     "length_cm",
     "width_cm",
     "height_cm",
+    "delivery_method",
     "manufacturer_name",
     "eu_responsible_person_name",
 }

package/dist/scripts/i18n.py

@@ -218,6 +218,11 @@ TRANSLATIONS: Dict[str, Dict[str, str]] = {
         "pub_compliance_manufacturer_eurp_both_empty": "Manufacturer and EU Responsible Person are both empty. Non-EU manufacturers require an EU Responsible Person.",
         "pub_compliance_eurp_missing_with_manufacturer": "Manufacturer is filled but EU Responsible Person is empty. Non-EU manufacturers require an EU Responsible Person.",
         "pub_safety_warning_content_missing": "Safety Warning is set to Yes but the warning content is empty. Please provide the safety warning content.",
+        "pub_safety_confirm_title": "Safety warning needs your confirmation",
+        "pub_safety_confirm_message": "We detected safety-related content in your source ({evidence}), but the 'Does this product have a safety warning' flag was not set explicitly. We will NOT silently default it to 'No'. Please confirm the correct value, or complete the field in your Excel and rerun.",
+        "pub_safety_confirm_next_yes": "If the product does have a safety warning, rerun with --safety-warning yes (add --safety-warning-content if needed).",
+        "pub_safety_confirm_next_no": "If it genuinely has no safety warning, rerun with --safety-warning no to confirm.",
+        "pub_safety_confirm_next_excel": "Your Excel fields may be incomplete; you can fill the safety column there and rerun.",
         "pub_compliance_docs_missing": "Compliance documents are required for this category but not provided.",
         "pub_compliance_missing_message": "Some compliance fields are missing. You can fill them or publish to Draft.",
         "pub_compliance_fill_or_draft": "Fill the missing compliance fields, or publish as Draft to complete them later.",
@@ -249,6 +254,7 @@ TRANSLATIONS: Dict[str, Dict[str, str]] = {
         "pub_dbm_dim_sum_exceeded": "Dimension sum {dim_sum} exceeds DBM limit {limit}cm.",
         "pub_dbm_volume_exceeded": "Volumetric weight {volume} exceeds DBM limit {limit}.",
         "pub_dbm_auto_switch_to_dbs": "Package exceeds DBM limits. Delivery method auto-switched to DBS.",
+        "pub_dbs_no_permission_downgrade": "Seller requested DBS but this account has no DBS permission; the delivery method was set to DBM.",
         "pub_dbm_no_dbs_permission": "Package exceeds DBM limits but seller has no DBS permission. Cannot auto-switch to DBS.",
         "pub_dbm_fix_or_apply_dbs": "Please reduce package size/weight to meet DBM limits, or apply for DBS permission in Seller Center.",
         # SKU already exists (concurrency conflict)
@@ -338,6 +344,9 @@ TRANSLATIONS: Dict[str, Dict[str, str]] = {
         "pub_need_category_attributes_description": "The category {category_id} requires the following attributes that were not found in the extracted data. Please provide them via --attribute-data or rerun with --draft to publish as an inactive draft.",
         "pub_need_category_attributes_item": "{idx}. {label} ({en_name}) - {input_type}",
         "pub_need_category_attributes_next": "Provide the missing attributes and rerun with --attribute-data '<json>', or use --draft to publish as inactive draft and complete them later.",
+        "pub_need_attribute_mapping_title": "Some columns could not be matched automatically",
+        "pub_need_attribute_mapping_description": "These Excel/CSV columns did not clearly match a category attribute, so they were not bound. Please confirm which attribute each column should map to, then rerun with --attribute-data using the canonical attribute names shown below (or drop the column if it is not a product attribute).",
+        "pub_need_attribute_mapping_next": "Rerun with --attribute-data '{\"<attribute_name>\": \"<value>\"}' using one of the suggested attribute names, or remove the column if it is not needed.",
         "pub_html_cleaned_notice": "The product description has been cleaned: unsafe HTML tags (script, iframe, style attributes, etc.) were removed. Only safe formatting tags (p, br, b, ul, li, etc.) are kept.",
         "pub_create_pending_review": "Product submitted successfully. It is currently under Miravia review and temporarily unavailable for sale; approval may take up to 48 hours, especially if package photos or documents are required. Once approved, it will be activated automatically. If rejected, please check the Suspended tab.",
         "pub_pdp_link": "Product detail page: {url}",
@@ -883,6 +892,11 @@ TRANSLATIONS: Dict[str, Dict[str, str]] = {
         "pub_compliance_manufacturer_eurp_both_empty": "制造商和欧盟负责人均为空。非欧盟制造商必须填写欧盟负责人。",
         "pub_compliance_eurp_missing_with_manufacturer": "已填写制造商但欧盟负责人为空。非欧盟制造商必须填写欧盟负责人。",
         "pub_safety_warning_content_missing": "安全警告已设为 Yes 但未填写警告内容。请补充安全警告内容。",
+        "pub_safety_confirm_title": "安全警告需要你确认",
+        "pub_safety_confirm_message": "我们从你的源文件中检测到安全相关内容（{evidence}），但“该产品是否有安全警告”这一项没有被显式设置。我们不会把它静默默认为 No。请确认应取的值，或先在 Excel 中补全该项后重新运行。",
+        "pub_safety_confirm_next_yes": "如果该商品确实有安全警告，请加 --safety-warning yes 重新运行（必要时再加 --safety-warning-content）。",
+        "pub_safety_confirm_next_no": "如果确实没有安全警告，请加 --safety-warning no 确认。",
+        "pub_safety_confirm_next_excel": "Excel 字段可能不完整，你可以在其中补上安全警告列后重新运行。",
         "pub_compliance_docs_missing": "该类目要求上传合规文档但未提供。",
         "pub_compliance_missing_message": "部分合规字段缺失。您可以补充完整或发布为草稿。",
         "pub_compliance_fill_or_draft": "补充缺失的合规字段，或发布为草稿（Draft）稍后在 Seller Center 中完善。",
@@ -914,6 +928,7 @@ TRANSLATIONS: Dict[str, Dict[str, str]] = {
         "pub_dbm_dim_sum_exceeded": "三边之和 {dim_sum} 超过 DBM 限制 {limit}cm。",
         "pub_dbm_volume_exceeded": "体积重 {volume} 超过 DBM 限制 {limit}。",
         "pub_dbm_auto_switch_to_dbs": "包裹超出 DBM 限制，物流方式自动转为 DBS。",
+        "pub_dbs_no_permission_downgrade": "商家请求使用 DBS，但当前账号没有 DBS 权限，物流方式已设为 DBM。",
         "pub_dbm_no_dbs_permission": "包裹超出 DBM 限制，但卖家无 DBS 权限，无法自动转为 DBS。",
         "pub_dbm_fix_or_apply_dbs": "请减小包裹尺寸/重量以满足 DBM 限制，或在 Seller Center 申请 DBS 权限。",
         # SKU already exists (concurrency conflict)
@@ -968,6 +983,9 @@ TRANSLATIONS: Dict[str, Dict[str, str]] = {
         "pub_need_category_attributes_description": "类目 {category_id} 要求以下属性，但 AI 抽取的数据中未包含。请通过 --attribute-data 补充，或使用 --draft 发布为未激活草稿。",
         "pub_need_category_attributes_item": "{idx}. {label}（{en_name}）- {input_type}",
         "pub_need_category_attributes_next": "补充缺失属性后使用 --attribute-data '<json>' 重新运行，或使用 --draft 发布为未激活草稿稍后补充。",
+        "pub_need_attribute_mapping_title": "部分列未能自动匹配",
+        "pub_need_attribute_mapping_description": "以下 Excel/CSV 列未能明确匹配到类目属性，因此未绑定。请确认每列应对应哪个属性，然后用下方展示的规范属性名通过 --attribute-data 重新运行（若该列不是商品属性则可删除）。",
+        "pub_need_attribute_mapping_next": "使用下方建议的属性名之一，通过 --attribute-data '{\"<属性名>\": \"<值>\"}' 重新运行；若不需要该列则删除。",
         "pub_html_cleaned_notice": "商品描述已清理：不安全的 HTML 标签（script、iframe、style 属性等）已被移除。仅保留安全格式标签（p、br、b、ul、li 等）。",
         "pub_create_pending_review": "商品提交成功，目前正在接受 Miravia 审核，暂不可售；审核最长可能需要 48 小时，特别是需要包装照片或文件时。审核通过后会自动激活，如被拒绝请在“已暂停(Suspended)”选项卡中查看。",
         "pub_pdp_link": "商品详情页：{url}",

package/dist/scripts/product_client.py

@@ -360,13 +360,14 @@ class ProductClient:
 
         # GPSR compliance fields are injected at SKU level (see below).
 
-        # Delivery method -> Miravia create field ``Attributes.deliverySof``
-        # ("DBM" or "DBS"). Only written when the seller explicitly chose one;
+        # Delivery method -> Miravia create field ``Attributes.delivery_option_sof``,
+        # which is a YES/NO flag: "Yes" = DBS (seller-fulfilled), "No" = DBM
+        # (platform-fulfilled). Only written when the seller explicitly chose one;
         # when absent, publish_module._check_dbm_limits applies the default
-        # (DBM generally, DBS if the seller has DBS permission).
+        # (No/DBM generally, Yes/DBS if the seller has DBS permission).
         _dm = str(data.get("delivery_method") or "").strip().upper()
         if _dm in ("DBM", "DBS"):
-            attributes["deliverySof"] = _dm
+            attributes["delivery_option_sof"] = "Yes" if _dm == "DBS" else "No"
 
         product_payload: Dict[str, Any] = {
             "PrimaryCategory": category_id,
@@ -405,13 +406,14 @@ class ProductClient:
         if draft:
             product_payload["Status"] = "inactive"
 
-        # Country-specific prices (best-effort mapping)
-        country_prices = data.get("country_general_prices", {})
-        if country_prices:
-            product_payload["CountryPrice"] = [
-                {"country": c, "price": str(p)}
-                for c, p in country_prices.items()
-            ]
+        # Country-specific prices are NOT injected here at the product level.
+        # Verified against the authoritative /product/create contract: each
+        # country override lives INSIDE the SKU as
+        # ``CountryPrice: [{"CountryCode":"ES","Price":"1.9","SalePrice":"1.8"}]``
+        # (capitalised keys). A product-level ``CountryPrice`` list with the
+        # old ``{"country","price"}`` shape is silently ignored by the API.
+        # This is built per SKU in
+        # ``PublishModule._build_sku_list_from_schema``.
 
         # Standard unit type / count
         if data.get("standard_unit_type"):

package/dist/scripts/product_skill.py

@@ -373,6 +373,25 @@ def _print_conversational_result(result: Dict[str, Any]) -> None:
             print(f"• {action}")
         return
 
+    # Unmapped Excel/CSV columns needing a confirmed attribute mapping
+    if status == "need_attribute_mapping":
+        print(result.get("title", ""))
+        print(result.get("message", ""))
+        print()
+        for item in result.get("unmapped_columns", []):
+            print(f"  列 \"{item.get('header')}\" = {item.get('value')} 可能对应：")
+            for c in item.get("candidates", []):
+                mand = "（必填）" if str(c.get("is_mandatory")) == "1" else ""
+                print(
+                    f"    - {c.get('label')} "
+                    f"[name={c.get('name')}, en_name={c.get('en_name')}, "
+                    f"type={c.get('attribute_type')}]{mand}"
+                )
+            print()
+        for action in result.get("next_actions", []):
+            print(f"• {action}")
+        return
+
     if status == "need_images":
         print(result.get("message", ""))
         if result.get("failed_images"):
@@ -796,7 +815,8 @@ def main() -> None:
             print(json.dumps(auth_payload, indent=2, ensure_ascii=False))
         return
 
-    if not skip_credential_check and args.scenario and not getattr(args, "authorized", False):
+    already_authorized = getattr(args, "authorized", False) or config.has_valid_business_credentials()
+    if not skip_credential_check and args.scenario and not already_authorized:
         auth_payload = {
             "status": "need_authorization",
             "title": i18n._("pub_authorization_title"),

package/dist/scripts/publish_module.py

@@ -801,24 +801,55 @@ class PublishModule:
         *,
         has_dbs_permission: bool = False,
     ) -> Optional[Dict[str, Any]]:
-        """Resolve ``Attributes.deliverySof`` and enforce DBM package limits.
-
-        Miravia ``/product/create`` expects ``Attributes.deliverySof`` to be
-        ``"DBM"`` or ``"DBS"``. When the seller did not choose one it is
-        defaulted here: generally DBM, but DBS when the seller has DBS
-        permission. If the effective method is DBM but the package exceeds the
-        DBM limits (weight <= 40KG, L+W+H <= 300cm, volumetric weight
-        L*W*H/6000 <= 40), it is switched to DBS when permitted, otherwise the
-        caller blocks. Returns a result dict, or None when nothing to do.
+        """Resolve ``Attributes.delivery_option_sof`` and enforce DBM package limits.
+
+        Miravia ``/product/create`` expects ``Attributes.delivery_option_sof`` to be
+        a YES/NO flag: ``"Yes"`` = DBS (seller-fulfilled), ``"No"`` = DBM
+        (platform-fulfilled). The legacy ``deliverySof="DBM"/"DBS"`` literal is
+        silently ignored by the platform. Internally we normalise to ``"DBM"``/
+        ``"DBS"`` for the package-limit logic and always write the flag back as
+        Yes/No. When the seller did not choose one it is defaulted here: generally
+        DBM (No), but DBS (Yes) when the seller has DBS permission. If the
+        effective method is DBM but the package exceeds the DBM limits (weight
+        <= 40KG, L+W+H <= 300cm, volumetric weight L*W*H/6000 <= 40), it is
+        switched to DBS when permitted, otherwise the caller blocks. Returns a
+        result dict, or None when nothing to do.
         """
         attrs = product_payload.setdefault("Attributes", {})
-        delivery_method = str(attrs.get("deliverySof") or "").strip().upper()
 
-        # Default when there is no explicit entry: DBS if the seller is
-        # permitted, otherwise DBM.
+        def _write_flag(method: str) -> None:
+            # Canonical wire flag the platform actually honours; replaces the
+            # legacy deliverySof value so no stale key lingers.
+            attrs["delivery_option_sof"] = "Yes" if method == "DBS" else "No"
+            attrs.pop("deliverySof", None)
+
+        _raw = str(
+            attrs.get("delivery_option_sof") or attrs.get("deliverySof") or ""
+        ).strip().upper()
+        # Accept the wire flag (Yes/No) as well as legacy DBM/DBS codes.
+        if _raw in ("YES", "DBS"):
+            delivery_method = "DBS"
+        elif _raw in ("NO", "DBM"):
+            delivery_method = "DBM"
+        else:
+            delivery_method = ""
+        downgraded_from_dbs = False
+
         if delivery_method not in ("DBM", "DBS"):
+            # No explicit entry: default to DBS when the seller is permitted,
+            # otherwise DBM.
             delivery_method = "DBS" if has_dbs_permission else "DBM"
-            attrs["deliverySof"] = delivery_method
+            _write_flag(delivery_method)
+        elif delivery_method == "DBS" and not has_dbs_permission:
+            # Seller explicitly chose DBS but the account has no DBS permission:
+            # never grant DBS without permission — fall back to DBM and still
+            # enforce the DBM package limits below.
+            delivery_method = "DBM"
+            _write_flag(delivery_method)
+            downgraded_from_dbs = True
+        else:
+            # Normalise an explicit/legacy value to the canonical Yes/No flag.
+            _write_flag(delivery_method)
 
         # Only DBM carries package limits.
         if delivery_method != "DBM":
@@ -856,12 +887,17 @@ class PublishModule:
             )
 
         if not exceeded:
+            if downgraded_from_dbs:
+                return {
+                    "downgraded_to_dbm": True,
+                    "message": i18n._("pub_dbs_no_permission_downgrade"),
+                }
             return None
 
         # Exceeded DBM limits — check DBS permission
         if has_dbs_permission:
             # Auto-switch to DBS
-            attrs["deliverySof"] = "DBS"
+            _write_flag("DBS")
             return {
                 "switched_to_dbs": True,
                 "reasons": exceeded,
@@ -902,11 +938,14 @@ class PublishModule:
         seller_sku_required = self._field_is_required(
             "SellerSku", category_attributes or []
         )
-        _validate_create_payload(product_payload, seller_sku_required=seller_sku_required)
+        _validate_create_payload(
+            product_payload, seller_sku_required=seller_sku_required, draft=draft
+        )
 
         # Check DBM limits — auto-switch to DBS if exceeded (requires DBS permission)
         has_dbs = self.product.get_shipping_permission()
         dbm_result = self._check_dbm_limits(product_payload, has_dbs_permission=has_dbs)
+        dbm_notes: List[str] = []
         if dbm_result:
             if dbm_result.get("blocked"):
                 # No DBS permission and exceeds DBM limits — block
@@ -919,10 +958,12 @@ class PublishModule:
                     ],
                 }
             if dbm_result.get("switched_to_dbs"):
-                if draft_issues is not None:
-                    draft_issues.append(dbm_result["message"])
-                    for reason in dbm_result.get("reasons", []):
-                        draft_issues.append(f"  - {reason}")
+                dbm_notes.append(dbm_result["message"])
+                dbm_notes.extend(f"  - {r}" for r in dbm_result.get("reasons", []))
+            if dbm_result.get("downgraded_to_dbm"):
+                # Seller asked for DBS but has no DBS permission — explain the
+                # fallback so the delivery-method change is not silent.
+                dbm_notes.append(dbm_result["message"])
 
         # Run pre-validate early so errors are visible in the preview
         prevalidate_result = self._run_prevalidate(product_payload)
@@ -935,6 +976,7 @@ class PublishModule:
 
         # Merge all issues for preview
         all_issues = list(draft_issues or [])
+        all_issues.extend(dbm_notes)
         if prevalidate_errors:
             all_issues.extend(prevalidate_errors)
 
@@ -1340,11 +1382,59 @@ class PublishModule:
             draft=draft_requested,
         )
 
+        # Explicit --attribute-data must reach the AI payload too (it used to be
+        # honored only in the manual flow, so AI-mode values were silently
+        # dropped). Applied before unmatched-column binding so explicit values win.
+        self._apply_attribute_data_override(product_payload)
+
         # Bind extra Excel/CSV columns that the whitelist did not recognize,
         # using the category attribute definitions fetched above.
-        self._unmapped_columns = self._apply_unmatched_category_attributes(
+        unmapped_cols = self._apply_unmatched_category_attributes(
             product_payload, schema, category_attributes
         )
+        self._unmapped_columns = unmapped_cols
+
+        # If a provided column could not be confidently matched but plausibly
+        # maps to one or more category attributes, ask the seller to confirm the
+        # mapping instead of silently dropping it (which would otherwise surface
+        # later as a cryptic batchValidate "missing attribute" error).
+        mapping_check = self._check_unmapped_columns(unmapped_cols, product_payload)
+        if mapping_check:
+            return mapping_check
+
+        # Safety warning: honor an explicit --safety-warning in the source flow.
+        # build_create_product_payload defaults the flag to "No" and manual mode
+        # applies the CLI flags at build time, but the Excel/source flow never did
+        # — so --safety-warning was silently ignored here. Apply it now so the
+        # seller's explicit choice is never overwritten by the default.
+        self._apply_safety_cli_override(product_payload)
+
+        # Safety guidance gate: never silently ship an inferred "No". If the seller
+        # has not chosen a value but the source carries real safety content, pause
+        # and ask them to confirm yes/no (or complete the Excel). The flag can only
+        # be auto-populated once the seller answers, per the "surface assumed
+        # values, do not silently replace" rule.
+        if getattr(self.args, "safety_warning", None) is None:
+            safety_evidence = self._detect_safety_content(product_payload, schema)
+            if safety_evidence:
+                current_flag = (product_payload.get("Attributes") or {}).get(
+                    "Does_this_product_have_a_safety_warning"
+                )
+                return {
+                    "status": "need_safety_warning_confirm",
+                    "title": i18n._("pub_safety_confirm_title"),
+                    "message": i18n._(
+                        "pub_safety_confirm_message",
+                        evidence=", ".join(safety_evidence),
+                    ),
+                    "detected_safety_content": safety_evidence,
+                    "current_value": current_flag,
+                    "next_actions": [
+                        i18n._("pub_safety_confirm_next_yes"),
+                        i18n._("pub_safety_confirm_next_no"),
+                        i18n._("pub_safety_confirm_next_excel"),
+                    ],
+                }
 
         # Stage 3b: unified compliance check (GPSR + Safety Warning + compliance docs)
         draft_issues: list = []
@@ -1506,8 +1596,8 @@ class PublishModule:
 
     # Structural fields Miravia always requires for any product (not category
     # attributes, so the API never governs them) — always blocking. NOTE:
-    # delivery method (Attributes.deliverySof) is intentionally NOT here — it is
-    # auto-defaulted (DBM, or DBS when the seller has DBS permission) rather
+    # delivery method (Attributes.delivery_option_sof) is intentionally NOT here — it is
+    # auto-defaulted (DBM=No, or DBS=Yes when the seller has DBS permission) rather
     # than hard-collected; see _check_dbm_limits.
     _CORE_MANDATORY_KEYS = frozenset(
         {
@@ -1672,15 +1762,19 @@ class PublishModule:
         """
         confirmed_brand_id = getattr(self.args, "confirmed_brand_id", None)
         if confirmed_brand_id:
+            # Honor an explicitly passed --brand-name too (aligns with the
+            # manual flow's _resolve_brand_interactive). Otherwise a seller who
+            # confirms by ID but whose source lacks the brand name would have
+            # the brand silently dropped from the payload.
             return {
                 "brand_id": int(confirmed_brand_id),
-                "brand_name": schema.brand_name or "",
+                "brand_name": getattr(self.args, "brand_name", None) or schema.brand_name or "",
             }
 
         if schema.brand_id:
             return {
                 "brand_id": int(schema.brand_id),
-                "brand_name": schema.brand_name or "",
+                "brand_name": getattr(self.args, "brand_name", None) or schema.brand_name or "",
             }
 
         brand_name = self.args.brand_name or schema.brand_name
@@ -2013,8 +2107,8 @@ class PublishModule:
         # jeans, so an empty EAN must NOT be flagged as missing.
         api_optional: List[str] = []
 
-        # Delivery method (Attributes.deliverySof) is NOT a hard-collect field:
-        # Miravia defaults it when absent (DBM, or DBS if the seller has DBS
+        # Delivery method (Attributes.delivery_option_sof) is NOT a hard-collect field:
+        # Miravia defaults it when absent (DBM=No, or DBS=Yes if the seller has DBS
         # permission — see _check_dbm_limits), so an empty value shows as
         # "Optional" here and never blocks.
         if not (getattr(schema, "delivery_method", None) or "").strip():
@@ -2179,8 +2273,9 @@ class PublishModule:
         value under the attribute's canonical key — into each SKU for
         ``attribute_type == 'sku'``, otherwise into the product-level
         ``Attributes``. Existing keys are never overwritten (whitelist/LLM
-        values win). Returns the headers that matched no category attribute
-        so the caller can surface them instead of silently dropping them.
+        values win). Returns a list of ``{header, value, candidates}`` for the
+        headers that matched no category attribute confidently, so the caller can
+        ask the seller to confirm the mapping instead of silently dropping them.
 
         We intentionally bind ONLY the non-whitelisted columns here. Columns
         the whitelist already consumed (Title/Price/Image/Color/Stock/...) are
@@ -2196,11 +2291,31 @@ class PublishModule:
             return []
         attributes = product_payload.setdefault("Attributes", {})
         skus = (product_payload.get("Skus") or {}).get("Sku") or []
-        unmapped: List[str] = []
+        unmapped: List[Dict[str, Any]] = []
         for header, value in unmatched.items():
             attr = self._find_category_attribute(category_attributes, (header,))
             if not attr:
-                unmapped.append(header)
+                # No confident match: collect the header with fuzzy candidates so
+                # the caller can ask the seller to confirm the intended attribute
+                # instead of silently dropping the column.
+                unmapped.append(
+                    {
+                        "header": header,
+                        "value": value,
+                        "candidates": [
+                            {
+                                "name": c.get("name"),
+                                "en_name": c.get("en_name"),
+                                "label": c.get("label") or c.get("en_name") or c.get("name"),
+                                "attribute_type": c.get("attribute_type") or "normal",
+                                "is_mandatory": str(c.get("is_mandatory", "0")),
+                            }
+                            for c in self._suggest_attribute_candidates(
+                                header, category_attributes
+                            )
+                        ],
+                    }
+                )
                 continue
             key = attr.get("name") or attr.get("en_name") or header
             if (attr.get("attribute_type") or "normal") == "sku":
@@ -2212,11 +2327,122 @@ class PublishModule:
                     attributes[key] = value
         if unmapped:
             logger.info(
-                "Excel/CSV columns not matching any category attribute: %s",
-                ", ".join(unmapped),
+                "Excel/CSV columns not confidently matched: %s",
+                ", ".join(u["header"] for u in unmapped),
             )
         return unmapped
 
+    def _suggest_attribute_candidates(
+        self,
+        header: str,
+        category_attributes: List[Dict[str, Any]],
+        max_candidates: int = 8,
+    ) -> List[Dict[str, Any]]:
+        """Fuzzy-suggest category attributes a free-text column header might map
+        to — for the confirmation prompt only, never auto-bound.
+
+        Uses a shared-prefix (stem) heuristic so e.g. header ``packaging``
+        suggests ``Package_Label_Photo_EU``. Deliberately looser than
+        ``_find_category_attribute`` because a human confirms the result.
+        """
+        def _words(text: Any) -> List[str]:
+            return [w for w in re.split(r"[^a-z0-9]+", str(text).lower()) if len(w) >= 4]
+
+        header_words = set(_words(header))
+        h_sq = self._squash_attr_name(header)
+        if h_sq:
+            header_words.add(h_sq)
+        out: List[Dict[str, Any]] = []
+        for attr in category_attributes or []:
+            attr_words: List[str] = []
+            for key in ("name", "en_name", "label", "attribute_name"):
+                if attr.get(key):
+                    attr_words.extend(_words(attr.get(key)))
+                    attr_words.append(self._squash_attr_name(attr.get(key)))
+            hit = False
+            for hw in header_words:
+                for aw in attr_words:
+                    if (
+                        len(hw) >= 5
+                        and len(aw) >= 5
+                        and hw[:5] == aw[:5]
+                    ) or hw in aw or aw in hw:
+                        hit = True
+                        break
+                if hit:
+                    break
+            if hit:
+                out.append(attr)
+                if len(out) >= max_candidates:
+                    break
+        return out
+
+    def _apply_attribute_data_override(self, product_payload: Dict[str, Any]) -> None:
+        """Merge ``--attribute-data`` into the AI-built payload.
+
+        The AI flow builds Attributes/Skus from the extracted schema and never
+        consulted ``--attribute-data``, so values passed there were silently
+        dropped. ``--attribute-data`` is the seller's own explicit input, so it
+        overrides extracted values; SKU-level keys are merged into every SKU.
+        """
+        raw = getattr(self.args, "attribute_data", None)
+        if not raw:
+            return
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"--attribute-data is not valid JSON: {exc}") from exc
+        if not isinstance(data, dict):
+            raise ValueError("--attribute-data must be a JSON object")
+        attributes = product_payload.setdefault("Attributes", {})
+        skus = (product_payload.get("Skus") or {}).get("Sku") or []
+        for key, value in data.items():
+            if key in _SKU_LEVEL_ATTRIBUTE_NAMES:
+                for sku in skus:
+                    sku[key] = value
+            else:
+                attributes[key] = value
+
+    def _check_unmapped_columns(
+        self,
+        unmapped_cols: List[Dict[str, Any]],
+        product_payload: Dict[str, Any],
+    ) -> Optional[Dict[str, Any]]:
+        """Return a ``need_attribute_mapping`` prompt when an unmapped column
+        looks like a category attribute the seller intended, so they confirm the
+        mapping instead of us dropping it silently (which would later surface as
+        a cryptic batchValidate "missing attribute" error). Columns with no
+        plausible candidate — or whose candidates are already filled via
+        ``--attribute-data`` — are ignored.
+        """
+        attributes = product_payload.get("Attributes") or {}
+        skus = (product_payload.get("Skus") or {}).get("Sku") or []
+
+        def _filled(cand: Dict[str, Any]) -> bool:
+            names = [cand.get("name"), cand.get("en_name")]
+
+            def _present(container: Dict[str, Any]) -> bool:
+                return any(n and str(container.get(n) or "").strip() for n in names)
+
+            if (cand.get("attribute_type") or "normal") == "sku":
+                return bool(skus) and all(_present(s) for s in skus)
+            return _present(attributes)
+
+        need: List[Dict[str, Any]] = []
+        for item in unmapped_cols or []:
+            open_cands = [c for c in (item.get("candidates") or []) if not _filled(c)]
+            if open_cands:
+                need.append({**item, "candidates": open_cands})
+        if not need:
+            return None
+        return {
+            "status": "need_attribute_mapping",
+            "title": i18n._("pub_need_attribute_mapping_title"),
+            "message": i18n._("pub_need_attribute_mapping_description"),
+            "unmapped_columns": need,
+            "next_actions": [i18n._("pub_need_attribute_mapping_next")],
+        }
+
     def _field_is_required(
         self,
         field_key: str,
@@ -2503,7 +2729,7 @@ class PublishModule:
         confirmed_brand_id = getattr(self.args, "confirmed_brand_id", None)
         if confirmed_brand_id:
             return {
-                "brand_name": schema.brand_name or "",
+                "brand_name": getattr(self.args, "brand_name", None) or schema.brand_name or "",
                 "brand_id": int(confirmed_brand_id),
             }
 
@@ -2642,7 +2868,11 @@ class PublishModule:
 
         Per the Miravia ``/product/create`` documentation:
 
-        - ``SellerSku`` is mandatory for every SKU.
+        - ``SellerSku`` is NOT hard-coded mandatory: whether it must be filled is
+          governed by the category attribute API and enforced once in
+          :meth:`_validate_create_payload` (via ``seller_sku_required``), which
+          applies to both Draft and online publishes. Here we simply omit an
+          empty SellerSku so ``/product/create`` can auto-generate a value.
         - Package dimensions/weight are per-SKU fields
           (``package_length/width/height/weight``).
         - Sales properties are flat SKU fields, not a nested ``Variation``
@@ -2671,11 +2901,12 @@ class PublishModule:
             seller_sku = raw.get("seller_sku") or (
                 schema.seller_skus[idx] if idx < len(schema.seller_skus) else None
             )
-            if not seller_sku:
-                raise ValueError(
-                    i18n._("pub_seller_sku_required", idx=idx + 1)
-                )
-            sku["SellerSku"] = seller_sku
+            # Do NOT hard-require SellerSku here. Its mandatory-ness comes from
+            # the category attribute API and is enforced in _validate_create_payload
+            # (draft-aware: a live publish blocks an interface-mandatory empty value;
+            # a draft defers it). Omit empty values so create can auto-generate.
+            if seller_sku:
+                sku["SellerSku"] = seller_sku
 
             ean_code = raw.get("ean_code") or (
                 schema.ean_codes[idx] if idx < len(schema.ean_codes) else None
@@ -2721,6 +2952,25 @@ class PublishModule:
             if sku_images:
                 sku["Images"] = {"Image": sku_images}
 
+            # Country-specific prices live INSIDE each SKU (per the
+            # authoritative /product/create contract), with capitalised keys
+            # ``CountryCode`` / ``Price`` / ``SalePrice``. ``country_general_prices``
+            # supplies the per-country Price and ``country_discounted_prices``
+            # the per-country SalePrice. A product-level list or the old
+            # lowercase ``{"country","price"}`` shape is silently ignored.
+            _cgp = schema.country_general_prices or {}
+            _cdp = schema.country_discounted_prices or {}
+            _country_price = []
+            for _cc in sorted(set(_cgp) | set(_cdp)):
+                _entry: Dict[str, Any] = {"CountryCode": _cc}
+                if _cgp.get(_cc) not in (None, ""):
+                    _entry["Price"] = str(_cgp[_cc])
+                if _cdp.get(_cc) not in (None, ""):
+                    _entry["SalePrice"] = str(_cdp[_cc])
+                _country_price.append(_entry)
+            if _country_price:
+                sku["CountryPrice"] = _country_price
+
             skus.append(sku)
 
         if len(skus) > _MAX_SKUS_PER_PRODUCT:
@@ -2729,6 +2979,84 @@ class PublishModule:
             )
         return skus
 
+    # Boilerplate default warning text — must NOT be treated as real safety content.
+    _SAFETY_CONTENT_DEFAULT = "no specific safety warnings apply to this product"
+
+    def _apply_safety_cli_override(self, product_payload: Dict[str, Any]) -> None:
+        """Honor ``--safety-warning`` / ``--safety-warning-content`` in the source flow.
+
+        ``build_create_product_payload`` defaults ``Does_this_product_have_a_safety_warning``
+        to "No" when ``schema.safety_warning`` is falsy, and manual mode applies the CLI
+        flags at build time (see the manual path). The Excel/source flow never applied
+        them, so ``--safety-warning`` was silently ignored there. Write the seller's
+        explicit choice here using the same "Yes"/"No" casing the client already emits,
+        so the platform contract is unchanged and only the previously-ignored flag is
+        now respected.
+        """
+        safety_arg = getattr(self.args, "safety_warning", None)
+        if safety_arg is None:
+            return
+        is_yes = str(safety_arg).strip().lower() in ("yes", "1", "true", "y")
+        attributes = product_payload.setdefault("Attributes", {})
+        value = "Yes" if is_yes else "No"
+        attributes["Does this product have a safety warning"] = value
+        attributes["Does_this_product_have_a_safety_warning"] = value
+        content = getattr(self.args, "safety_warning_content", None)
+        if is_yes and content:
+            attributes["Safety_warning_content"] = content
+
+    def _detect_safety_content(
+        self, product_payload: Dict[str, Any], schema: MiraviaListingSchema
+    ) -> List[str]:
+        """Return human-readable evidence that the product has safety info.
+
+        Used to decide whether the auto-defaulted safety flag should be surfaced
+        to the seller instead of shipped silently. Ignores the boilerplate default
+        warning text and a plain "No" flag so we do not raise false prompts. Counts
+        real safety artifacts that came from the source: safety documents
+        (Safety_Date_Sheet / CPSR / CPNP URLs), an affirmative Hazmat flag, a
+        non-default ``Safety_warning_content`` already present, or an explicit
+        ``Does_this_product_have_a_safety_warning=Yes``.
+        """
+        attributes = product_payload.get("Attributes") or {}
+        evidence: List[str] = []
+        for key, val in attributes.items():
+            if not isinstance(val, str) or not val.strip():
+                continue
+            low = key.lower()
+            # Skip the yes/no flag itself (handled explicitly below).
+            if low in (
+                "does this product have a safety warning",
+                "does_this_product_have_a_safety_warning",
+            ):
+                if val.strip().lower() == "yes":
+                    evidence.append(f"{key}=Yes")
+                continue
+            if not any(tok in low for tok in ("safety", "cpsr", "cpnp", "hazmat", "warning")):
+                continue
+            # Boilerplate default content is not evidence.
+            if self._SAFETY_CONTENT_DEFAULT in val.strip().lower():
+                continue
+            # A negative/empty Hazmat flag is not evidence.
+            if "hazmat" in low and val.strip().lower() in ("no", "false", "0", "n/a", "-"):
+                continue
+            # Null-like placeholder strings from empty cells are not evidence.
+            if val.strip().lower() in ("none", "null", "n/a", "na", "-"):
+                continue
+            display = val if len(val) <= 60 else val[:57] + "..."
+            evidence.append(f"{key}={display}")
+        sc = getattr(schema, "safety_warning_content", None)
+        if sc and self._SAFETY_CONTENT_DEFAULT not in str(sc).strip().lower():
+            evidence.append("safety_warning_content provided")
+        # Deduplicate while preserving order.
+        seen: set = set()
+        uniq: List[str] = []
+        for item in evidence:
+            if item not in seen:
+                seen.add(item)
+                uniq.append(item)
+        return uniq
+
     def _run_prevalidate(
         self, product_payload: Dict[str, Any]
     ) -> Optional[Dict[str, Any]]:
@@ -3186,10 +3514,11 @@ class PublishModule:
                 processed["SellerSku"] = processed.pop("seller_sku")
             elif "seller_sku" in processed:
                 processed.pop("seller_sku")  # SellerSku already set
+            # SellerSku is optional (governed by the category attribute API and
+            # enforced in _validate_create_payload, not relaxed by draft). When
+            # empty, drop the key so /product/create can auto-generate it.
             if not processed.get("SellerSku"):
-                raise ValueError(
-                    i18n._("pub_seller_sku_required", idx=idx + 1)
-                )
+                processed.pop("SellerSku", None)
             # Migrate SKU-level images
             sku_images = processed.get("Images", {}).get("Image", [])
             if sku_images:
@@ -3333,6 +3662,7 @@ def _validate_title(title: str) -> None:
 def _validate_create_payload(
     payload: Dict[str, Any],
     seller_sku_required: bool = False,
+    draft: bool = False,
 ) -> None:
     """Validate a Miravia ``/product/create`` Product payload.
 
@@ -3342,7 +3672,9 @@ def _validate_create_payload(
 
     ``seller_sku_required`` is decided by the caller from the category attribute
     API (``_field_is_required``): when False, an empty SellerSku is allowed and
-    the create API auto-generates a unique value.
+    the create API auto-generates a unique value. When True but ``draft`` is set,
+    the empty value is deferred to the draft (surfaced as a draft_issue) rather
+    than hard-blocked, consistent with P7 — only a live publish enforces it.
     """
     attributes = payload.get("Attributes") or {}
     title = attributes.get("name")
@@ -3386,7 +3718,11 @@ def _validate_create_payload(
         raise ValueError(i18n._("pub_seller_sku_duplicate_in_product"))
 
     for idx, sku in enumerate(skus, start=1):
-        if seller_sku_required and not (sku.get("SellerSku") or sku.get("seller_sku")):
+        if (
+            seller_sku_required
+            and not draft
+            and not (sku.get("SellerSku") or sku.get("seller_sku"))
+        ):
             raise ValueError(i18n._("pub_seller_sku_required", idx=idx))
 
         price = sku.get("price")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miravia_test/miravia-publish-skill",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Miravia Product Publish Skill installer — one command to install the Miravia AI product listing skill into any AI Agent (Qoder / Cursor / Claude Code). Upload materials and let the AI extract data and publish products automatically.",
   "bin": {
     "miravia-publish-skill": "bin/cli.js"