siluzan-tso-cli 1.1.21-beta.1 → 1.1.21-beta.2

package/README.md

@@ -51,7 +51,7 @@ siluzan-tso init -d /path/to/skills  # 写入自定义目录
 siluzan-tso init --force             # 强制覆盖已存在文件
 ```
 
-> **注意**：当前为测试版（1.1.21-beta.1），供内部测试使用。正式发布后安装命令将改为 `npm install -g siluzan-tso-cli`。
+> **注意**：当前为测试版（1.1.21-beta.2），供内部测试使用。正式发布后安装命令将改为 `npm install -g siluzan-tso-cli`。
 
 | 助手                    | 建议 `--ai`                          |
 | ----------------------- | ------------------------------------ |

package/dist/index.js

@@ -110184,6 +110184,81 @@ function inferMatchTypeFromDisplayText(text) {
   if (t.length >= 2 && t.startsWith("[") && t.endsWith("]")) return "Exact";
   return "Broad";
 }
+var MATCH_TYPE_SPLIT_ORDER = ["Broad", "Phrase", "Exact"];
+function resolveTargetMatchTypeForSplit(trimmedRaw, declaredUi) {
+  const inferred = inferMatchTypeFromDisplayText(trimmedRaw);
+  if (declaredUi === null) return inferred;
+  if (inferred === "Broad") return declaredUi;
+  if (inferred !== declaredUi) return inferred;
+  return declaredUi;
+}
+function collectKeywordEntriesFromBlock(block) {
+  const entries = [];
+  const texts = readBlockKeywordTextArray(block);
+  if (Array.isArray(texts)) {
+    for (const raw of texts) {
+      if (typeof raw === "string" && raw.trim()) entries.push({ kind: "text", raw });
+    }
+  }
+  const items = readBlockItemsArray(block);
+  if (Array.isArray(items)) {
+    for (const item of items) {
+      if (!item || typeof item !== "object") continue;
+      const raw = readItemText(item);
+      if (raw !== null && raw.trim()) entries.push({ kind: "item", raw, item });
+    }
+  }
+  return entries;
+}
+function cloneKeywordBlockShell(block) {
+  const shell = { ...block };
+  delete shell["KeywordText"];
+  delete shell["keywordText"];
+  delete shell["Items"];
+  delete shell["items"];
+  delete shell["MatchTypeV2"];
+  delete shell["matchTypeV2"];
+  return shell;
+}
+function splitKeywordsForBatchJobBlockIfMixed(block, path22, warnings) {
+  const declaredUi = matchTypeV2ToUi(readBlockMatchTypeRaw(block));
+  const entries = collectKeywordEntriesFromBlock(block);
+  if (entries.length === 0) return [block];
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const trimmedRaw = collapseDuplicateSpacesInKeywordText(entry.raw.trim());
+    const target = resolveTargetMatchTypeForSplit(trimmedRaw, declaredUi);
+    const list = groups.get(target) ?? [];
+    list.push(
+      entry.kind === "text" ? { kind: "text", raw: trimmedRaw } : { kind: "item", raw: trimmedRaw, item: { ...entry.item } }
+    );
+    groups.set(target, list);
+  }
+  if (groups.size <= 1) return [block];
+  const labels = MATCH_TYPE_SPLIT_ORDER.filter((ui) => groups.has(ui)).map(
+    (ui) => matchTypeUiToV2(ui)
+  );
+  warnings.push(
+    `${path22} \u542B\u591A\u79CD\u5339\u914D\u7C7B\u578B\uFF0C\u5DF2\u81EA\u52A8\u62C6\u5206\u4E3A ${groups.size} \u4E2A KeywordsForBatchJob \u5757\uFF08${labels.join("\u3001")}\uFF09`
+  );
+  const shell = cloneKeywordBlockShell(block);
+  const splitBlocks = [];
+  for (const ui of MATCH_TYPE_SPLIT_ORDER) {
+    const list = groups.get(ui);
+    if (!list?.length) continue;
+    const newBlock = { ...shell, MatchTypeV2: matchTypeUiToV2(ui) };
+    const texts = [];
+    const items = [];
+    for (const e of list) {
+      if (e.kind === "text") texts.push(e.raw);
+      else items.push(e.item);
+    }
+    if (texts.length > 0) newBlock["KeywordText"] = texts;
+    if (items.length > 0) newBlock["Items"] = items;
+    splitBlocks.push(newBlock);
+  }
+  return splitBlocks;
+}
 function validateKeywordCore(core, path22, errors, lengthViolations) {
   const trimmed = core.trim();
   if (!trimmed) {
@@ -110221,66 +110296,193 @@ function normalizeKeywordSurface(raw, matchTypeV2) {
   const formatted = formatKeywordTextForMatchType(raw, matchType);
   return { formatted, matchType, inferredMatchType: fromField === null };
 }
-function normalizeKeywordsForBatchJobBlock(block, path22, errors, warnings, lengthViolations) {
-  const texts = block["KeywordText"];
-  if (!Array.isArray(texts)) return;
-  const declaredUi = matchTypeV2ToUi(block["MatchTypeV2"]);
-  if (block["MatchTypeV2"] !== void 0 && declaredUi === null) {
-    errors.push(
-      `${path22}.MatchTypeV2 \u65E0\u6548\uFF08${String(block["MatchTypeV2"])}\uFF09\uFF0C\u5408\u6CD5\u503C\uFF1ABROAD | PHRASE | EXACT`
+function readBlockMatchTypeRaw(block) {
+  if (block["MatchTypeV2"] !== void 0) return block["MatchTypeV2"];
+  if (block["matchTypeV2"] !== void 0) return block["matchTypeV2"];
+  return void 0;
+}
+function readBlockKeywordTextArray(block) {
+  const pascal = block["KeywordText"];
+  if (Array.isArray(pascal)) return pascal;
+  const camel = block["keywordText"];
+  if (Array.isArray(camel)) return camel;
+  return null;
+}
+function readBlockItemsArray(block) {
+  const pascal = block["Items"];
+  if (Array.isArray(pascal)) return pascal;
+  const camel = block["items"];
+  if (Array.isArray(camel)) return camel;
+  return null;
+}
+function readItemText(item) {
+  const t = item["Text"] ?? item["text"];
+  return typeof t === "string" ? t : null;
+}
+function writeItemText(item, formatted) {
+  item["Text"] = formatted;
+  delete item["text"];
+}
+function canonicalizeKeywordBatchBlock(block, resolvedMatchV2, normalizedTexts, hadItems) {
+  if (resolvedMatchV2) block["MatchTypeV2"] = resolvedMatchV2;
+  delete block["matchTypeV2"];
+  if (normalizedTexts !== void 0) {
+    block["KeywordText"] = normalizedTexts;
+    delete block["keywordText"];
+  }
+  if (hadItems) {
+    const items = readBlockItemsArray(block);
+    if (items) {
+      block["Items"] = items;
+      delete block["items"];
+      for (const item of items) {
+        delete item["text"];
+      }
+    }
+  }
+}
+function pushKeywordAutoFixWarning(warnings, path22, fieldLabel, trimmedRaw, formatted, declaredUi, beforeUi, matchType, inferredMatchType) {
+  if (inferredMatchType) {
+    warnings.push(
+      `${path22}.${fieldLabel} \u672A\u6307\u5B9A MatchTypeV2\uFF0C\u5DF2\u6309\u8BCD\u9762\u63A8\u65AD\u4E3A ${matchTypeUiToV2(matchType)}`
+    );
+    return;
+  }
+  if (declaredUi && beforeUi !== declaredUi) {
+    warnings.push(
+      `${path22}.${fieldLabel} MatchTypeV2=${matchTypeUiToV2(declaredUi)} \u4E0E\u8BCD\u9762\u4E0D\u4E00\u81F4\uFF0C\u5DF2\u81EA\u52A8\u4FEE\u590D\u4E3A\uFF1A${formatted}`
     );
     return;
   }
+  if (formatted !== trimmedRaw) {
+    warnings.push(`${path22}.${fieldLabel} \u5DF2\u81EA\u52A8\u4FEE\u590D\u8BCD\u9762\uFF1A${trimmedRaw} \u2192 ${formatted}`);
+  }
+}
+function normalizeKeywordTextList(texts, matchTypeRaw, path22, fieldLabel, errors, warnings, lengthViolations) {
+  const declaredUi = matchTypeV2ToUi(matchTypeRaw);
   const normalized = [];
   const seen = /* @__PURE__ */ new Set();
   let resolvedUi = declaredUi;
   for (let k = 0; k < texts.length; k++) {
     const raw = texts[k];
     if (typeof raw !== "string" || !raw.trim()) {
-      errors.push(`${path22}.KeywordText[${k}] \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32`);
+      errors.push(`${path22}.${fieldLabel}[${k}] \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32`);
       continue;
     }
     const trimmedRaw = collapseDuplicateSpacesInKeywordText(raw.trim());
     const beforeUi = inferMatchTypeFromDisplayText(trimmedRaw);
-    const { formatted, matchType, inferredMatchType } = normalizeKeywordSurface(trimmedRaw, block["MatchTypeV2"]);
-    if (inferredMatchType) {
-      warnings.push(
-        `${path22}.KeywordText[${k}] \u672A\u6307\u5B9A MatchTypeV2\uFF0C\u5DF2\u6309\u8BCD\u9762\u63A8\u65AD\u4E3A ${matchTypeUiToV2(matchType)}`
-      );
-    } else if (declaredUi && beforeUi !== declaredUi) {
-      warnings.push(
-        `${path22}.KeywordText[${k}] MatchTypeV2=${matchTypeUiToV2(declaredUi)} \u4E0E\u8BCD\u9762\u683C\u5F0F\u4E0D\u4E00\u81F4\uFF0C\u5DF2\u89C4\u8303\u4E3A\uFF1A${formatted}`
-      );
-    } else if (formatted !== trimmedRaw) {
-      warnings.push(`${path22}.KeywordText[${k}] \u8BCD\u9762\u5DF2\u89C4\u8303\u5316\uFF1A${trimmedRaw} \u2192 ${formatted}`);
-    }
+    const { formatted, matchType, inferredMatchType } = normalizeKeywordSurface(trimmedRaw, matchTypeRaw);
+    pushKeywordAutoFixWarning(
+      warnings,
+      path22,
+      fieldLabel,
+      trimmedRaw,
+      formatted,
+      declaredUi,
+      beforeUi,
+      matchType,
+      inferredMatchType
+    );
     const core = unwrapKeywordDisplayTextForEdit(formatted);
-    if (!validateKeywordCore(core, `${path22}.KeywordText[${k}]`, errors, lengthViolations))
-      continue;
+    if (!validateKeywordCore(core, `${path22}.${fieldLabel}[${k}]`, errors, lengthViolations)) continue;
     const dedupeKey = `${matchTypeUiToV2(matchType)}:${core.toLowerCase()}`;
     if (seen.has(dedupeKey)) {
-      warnings.push(`${path22}.KeywordText[${k}] \u4E0E\u540C\u7EC4\u91CD\u590D\uFF0C\u5DF2\u8DF3\u8FC7\uFF1A${formatted}`);
+      warnings.push(`${path22}.${fieldLabel}[${k}] \u4E0E\u540C\u7EC4\u91CD\u590D\uFF0C\u5DF2\u8DF3\u8FC7\uFF1A${formatted}`);
       continue;
     }
     seen.add(dedupeKey);
     normalized.push(formatted);
     if (!resolvedUi) resolvedUi = matchType;
   }
-  if (normalized.length === 0 && texts.length > 0) {
-    errors.push(`${path22}.KeywordText \u7ECF\u6821\u9A8C\u540E\u65E0\u6709\u6548\u5173\u952E\u8BCD\uFF0C\u8BF7\u4FEE\u6B63\u8BCD\u9762\u6216 MatchTypeV2`);
+  return { normalized, resolvedUi };
+}
+function normalizeKeywordsForBatchJobBlock(block, path22, errors, warnings, lengthViolations) {
+  const matchTypeRaw = readBlockMatchTypeRaw(block);
+  const declaredUi = matchTypeV2ToUi(matchTypeRaw);
+  if (matchTypeRaw !== void 0 && declaredUi === null) {
+    errors.push(
+      `${path22}.MatchTypeV2 \u65E0\u6548\uFF08${String(matchTypeRaw)}\uFF09\uFF0C\u5408\u6CD5\u503C\uFF1ABROAD | PHRASE | EXACT`
+    );
+    return;
   }
-  block["KeywordText"] = normalized;
-  if (resolvedUi) {
-    block["MatchTypeV2"] = matchTypeUiToV2(resolvedUi);
+  const texts = readBlockKeywordTextArray(block);
+  const items = readBlockItemsArray(block);
+  const hasTexts = Array.isArray(texts) && texts.length > 0;
+  const hasItems = Array.isArray(items) && items.length > 0;
+  if (!hasTexts && !hasItems) return;
+  let resolvedUi = declaredUi;
+  let normalizedTexts;
+  if (hasTexts && texts) {
+    const result = normalizeKeywordTextList(
+      texts,
+      matchTypeRaw,
+      path22,
+      "KeywordText",
+      errors,
+      warnings,
+      lengthViolations
+    );
+    normalizedTexts = result.normalized;
+    if (result.resolvedUi) resolvedUi = result.resolvedUi;
+    if (normalizedTexts.length === 0 && texts.length > 0) {
+      errors.push(`${path22}.KeywordText \u7ECF\u6821\u9A8C\u540E\u65E0\u6709\u6548\u5173\u952E\u8BCD\uFF0C\u8BF7\u4FEE\u6B63\u8BCD\u9762\u6216 MatchTypeV2`);
+    }
   }
+  if (hasItems && items) {
+    const seen = /* @__PURE__ */ new Set();
+    for (let k = 0; k < items.length; k++) {
+      const item = items[k];
+      if (!item || typeof item !== "object") {
+        errors.push(`${path22}.Items[${k}] \u5FC5\u987B\u662F\u5BF9\u8C61`);
+        continue;
+      }
+      const raw = readItemText(item);
+      if (raw === null || !raw.trim()) {
+        errors.push(`${path22}.Items[${k}].Text \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32`);
+        continue;
+      }
+      const trimmedRaw = collapseDuplicateSpacesInKeywordText(raw.trim());
+      const beforeUi = inferMatchTypeFromDisplayText(trimmedRaw);
+      const { formatted, matchType, inferredMatchType } = normalizeKeywordSurface(trimmedRaw, matchTypeRaw);
+      pushKeywordAutoFixWarning(
+        warnings,
+        path22,
+        `Items[${k}].Text`,
+        trimmedRaw,
+        formatted,
+        declaredUi,
+        beforeUi,
+        matchType,
+        inferredMatchType
+      );
+      const core = unwrapKeywordDisplayTextForEdit(formatted);
+      if (!validateKeywordCore(core, `${path22}.Items[${k}].Text`, errors, lengthViolations)) continue;
+      const dedupeKey = `${matchTypeUiToV2(matchType)}:${core.toLowerCase()}`;
+      if (seen.has(dedupeKey)) {
+        warnings.push(`${path22}.Items[${k}].Text \u4E0E\u540C\u7EC4\u91CD\u590D\uFF0C\u5DF2\u8DF3\u8FC7\uFF1A${formatted}`);
+        continue;
+      }
+      seen.add(dedupeKey);
+      writeItemText(item, formatted);
+      if (!resolvedUi) resolvedUi = matchType;
+    }
+  }
+  canonicalizeKeywordBatchBlock(
+    block,
+    resolvedUi ? matchTypeUiToV2(resolvedUi) : void 0,
+    normalizedTexts,
+    !!hasItems
+  );
 }
 function normalizeCampaignKeywordTrees(campaign, errors, warnings, lengthViolations) {
-  const neg = campaign["NegativeKeywordsForBatchJob"];
+  const neg = campaign["NegativeKeywordsForBatchJob"] ?? campaign["negativeKeywordsForBatchJob"];
   if (Array.isArray(neg)) {
+    campaign["NegativeKeywordsForBatchJob"] = neg;
+    delete campaign["negativeKeywordsForBatchJob"];
     for (let i = 0; i < neg.length; i++) {
       const block = neg[i];
       if (block && typeof block === "object") {
-        if (block["MatchTypeV2"] === void 0) block["MatchTypeV2"] = "BROAD";
+        if (readBlockMatchTypeRaw(block) === void 0) block["MatchTypeV2"] = "BROAD";
         normalizeKeywordsForBatchJobBlock(
           block,
           `campaign.NegativeKeywordsForBatchJob[${i}]`,
@@ -110291,23 +110493,32 @@ function normalizeCampaignKeywordTrees(campaign, errors, warnings, lengthViolati
       }
     }
   }
-  const groups = campaign["AdGroupsForBatchJob"];
+  const groups = campaign["AdGroupsForBatchJob"] ?? campaign["adGroupsForBatchJob"];
   if (!Array.isArray(groups)) return;
+  campaign["AdGroupsForBatchJob"] = groups;
+  delete campaign["adGroupsForBatchJob"];
   for (let i = 0; i < groups.length; i++) {
     const g = groups[i];
-    const kws = g?.["KeywordsForBatchJob"];
+    const kws = g?.["KeywordsForBatchJob"] ?? g?.["keywordsForBatchJob"];
     if (!Array.isArray(kws)) continue;
+    delete g["keywordsForBatchJob"];
+    const expandedKws = [];
     for (let j = 0; j < kws.length; j++) {
       const block = kws[j];
-      if (block && typeof block === "object") {
-        normalizeKeywordsForBatchJobBlock(
-          block,
-          `campaign.AdGroupsForBatchJob[${i}].KeywordsForBatchJob[${j}]`,
-          errors,
-          warnings,
-          lengthViolations
-        );
-      }
+      if (!block || typeof block !== "object") continue;
+      const basePath = `campaign.AdGroupsForBatchJob[${i}].KeywordsForBatchJob[${j}]`;
+      const splitBlocks = splitKeywordsForBatchJobBlockIfMixed(block, basePath, warnings);
+      expandedKws.push(...splitBlocks);
+    }
+    g["KeywordsForBatchJob"] = expandedKws;
+    for (let j = 0; j < expandedKws.length; j++) {
+      normalizeKeywordsForBatchJobBlock(
+        expandedKws[j],
+        `campaign.AdGroupsForBatchJob[${i}].KeywordsForBatchJob[${j}]`,
+        errors,
+        warnings,
+        lengthViolations
+      );
     }
   }
 }

package/dist/skill/_meta.json

@@ -1,5 +1,5 @@
 {
   "slug": "siluzan-tso",
-  "version": "1.1.21-beta.1",
-  "publishedAt": 1779419975724
+  "version": "1.1.21-beta.2",
+  "publishedAt": 1779679832469
 }

package/dist/skill/assets/campaign-create-keyword-test.fixed.json

@@ -0,0 +1,218 @@
+{
+  "account": "3206866200",
+  "customerName": "成功易人民币广告搭建测试账户",
+  "name": "Searh_核心中东",
+  "url": "https://www.hy-steelpipe.com/",
+  "locations": [
+    "United States"
+  ],
+  "productWords": [
+    "test",
+    "keyword"
+  ],
+  "googleDataRecordId": null,
+  "draft": false,
+  "campaign": {
+    "Name": "测试修复后的创建配置",
+    "StatusV2": "Enabled",
+    "ChannelTypeV2": "SEARCH",
+    "BiddingStrategyTypeV2": "TARGET_SPEND",
+    "Budget": 50,
+    "BudgetShared": false,
+    "BudgetId": 0,
+    "BudgetBudgetDeliveryMethodV2": "STANDARD",
+    "TargetSpend_BidCeilingAmount": 2,
+    "ManualCpc_EnhancedCpcEnabled": false,
+    "TargetGoogleSearch": true,
+    "TargetSearchNetwork": false,
+    "TargetContentNetwork": false,
+    "TargetPartnerSearchNetwork": false,
+    "PositiveGeoTargetType": 0,
+    "NegativeGeoTargetType": 0,
+    "DSADomainName": "",
+    "DSALanguageCode": "en",
+    "StartTime": "2026-05-25",
+    "EndTime": "2037-12-30",
+    "targetedLocations": [
+      {
+        "id": "2840",
+        "bidModifier": 0,
+        "bidModifierSpecified": false
+      }
+    ],
+    "excludedLocations": [],
+    "excludedIpAddresses": [],
+    "targetedLanguages": [
+      {
+        "id": 1000
+      }
+    ],
+    "targetedPlatforms": [
+      {
+        "id": 30001,
+        "bidModifier": 0
+      },
+      {
+        "id": 30002,
+        "bidModifier": 0
+      },
+      {
+        "id": 30000,
+        "bidModifier": 0
+      }
+    ],
+    "adSchedules": [
+      {
+        "DayOfWeekV2": 2,
+        "startHour": 0,
+        "StartMinuteV2": 2,
+        "endHour": 24,
+        "EndMinuteV2": 2
+      },
+      {
+        "DayOfWeekV2": 3,
+        "startHour": 0,
+        "StartMinuteV2": 2,
+        "endHour": 24,
+        "EndMinuteV2": 2
+      },
+      {
+        "DayOfWeekV2": 4,
+        "startHour": 0,
+        "StartMinuteV2": 2,
+        "endHour": 24,
+        "EndMinuteV2": 2
+      },
+      {
+        "DayOfWeekV2": 5,
+        "startHour": 0,
+        "StartMinuteV2": 2,
+        "endHour": 24,
+        "EndMinuteV2": 2
+      },
+      {
+        "DayOfWeekV2": 6,
+        "startHour": 0,
+        "StartMinuteV2": 2,
+        "endHour": 24,
+        "EndMinuteV2": 2
+      },
+      {
+        "DayOfWeekV2": 7,
+        "startHour": 0,
+        "StartMinuteV2": 2,
+        "endHour": 24,
+        "EndMinuteV2": 2
+      },
+      {
+        "DayOfWeekV2": 8,
+        "startHour": 0,
+        "StartMinuteV2": 2,
+        "endHour": 24,
+        "EndMinuteV2": 2
+      }
+    ],
+    "NegativeKeywordsForBatchJob": [
+      {
+        "KeywordText": [
+          "free sample",
+          "cheap"
+        ],
+        "MatchTypeV2": "BROAD",
+        "FinalURL": ""
+      }
+    ],
+    "ExtensionsForBatchJob": [],
+    "AdGroupsForBatchJob": [
+      {
+        "Name": "AG_Keyword_Normalize_Test",
+        "StatusV2": "Enabled",
+        "TypeV2": "SEARCH_STANDARD",
+        "RotationModeV2": "Unspecified",
+        "MaxCPCAmount": 2,
+        "KeywordsForBatchJob": [
+          {
+            "FinalURL": "https://www.example.com/test-a",
+            "MatchTypeV2": "BROAD",
+            "KeywordText": [
+              "broad match keyword"
+            ]
+          },
+          {
+            "FinalURL": "https://www.example.com/test-a",
+            "MatchTypeV2": "PHRASE",
+            "KeywordText": [
+              "\"phrase match keyword\""
+            ]
+          },
+          {
+            "FinalURL": "https://www.example.com/test-a",
+            "MatchTypeV2": "EXACT",
+            "KeywordText": [
+              "[exact match keyword]"
+            ]
+          },
+          {
+            "FinalURL": "https://www.example.com/test-b",
+            "MatchTypeV2": "BROAD",
+            "KeywordText": [
+              "running shoes broad"
+            ]
+          },
+          {
+            "FinalURL": "https://www.example.com/test-b",
+            "MatchTypeV2": "EXACT",
+            "KeywordText": [
+              "[steel pipe exact]"
+            ]
+          },
+          {
+            "MatchTypeV2": "EXACT",
+            "KeywordText": [
+              "[exact keyword one]",
+              "[exact keyword two]"
+            ],
+            "FinalURL": "https://www.example.com/test-c"
+          },
+          {
+            "MatchTypeV2": "PHRASE",
+            "KeywordText": [
+              "\"phrase keyword only\""
+            ],
+            "FinalURL": "https://www.example.com/test-d"
+          }
+        ],
+        "AdsForBatchJob": [
+          {
+            "TypeV2": "RESPONSIVE_SEARCH_AD",
+            "DestinationUrl": "https://www.example.com/test",
+            "Finalurl": "https://www.example.com/test",
+            "AdTitle": null,
+            "Path1": "test",
+            "Path2": "kw",
+            "headlinePart1": "Keyword Normalize Test H1",
+            "headlinePart2": "Validate Auto Fix Split",
+            "headlinePart3": "Do Not Run Create Yet",
+            "AddtionalHeadlines": [
+              "Headline Four For RSA",
+              "Headline Five For RSA",
+              "Headline Six For RSA",
+              "Headline Seven For RSA",
+              "Headline Eight For RSA",
+              "Headline Nine For RSA",
+              "Headline Ten For RSA",
+              "Headline Eleven RSA",
+              "Headline Twelve RSA"
+            ],
+            "adDescription": "Test ad for keyword validate only. Replace account before create.",
+            "adDescription2": "Second description line for RSA minimum fields.",
+            "AddtionalAdDescriptions": [
+              "Additional description one for responsive search ad.",
+              "Additional description two for responsive search ad."
+            ]
+          }
+        ]
+      }
+    ]
+  }
+}

package/dist/skill/assets/campaign-create-keyword-test.json

@@ -0,0 +1,146 @@
+{
+  "_meta": {
+    "schema": "campaign-create/v2",
+    "purpose": "测试 campaign-validate 关键词自动修复与自动拆块",
+    "howToTest": [
+      "1. 将 account / customerName 替换为 list-accounts 中的真实 Google 账户",
+      "2. cd tso-cli && npm run build",
+      "3. node dist/index.js ad campaign-validate --config-file assets/siluzan-ads/assets/campaign-create-keyword-test.json --write-normalized ./campaign-create-keyword-test.fixed.json",
+      "4. 查看 warnings：应出现「自动拆分」「自动修复」；fixed.json 中 KeywordsForBatchJob 应为多块且词面带 []/\"\""
+    ],
+    "casesInThisFile": {
+      "mixedBlock": "AdGroups[0].Keywords[0]：一块内混 BROAD 裸词 + 词组引号 + 完全方括号 → 应拆成 3 块",
+      "broadWithExactSymbol": "Keywords[1]：MatchTypeV2=BROAD 但含 [exact kw] → 应拆成 BROAD + EXACT 两块",
+      "exactBareOnly": "Keywords[2]：MatchTypeV2=EXACT 全裸词 → 不拆，词面改为 [kw]",
+      "phraseBareOnly": "Keywords[3]：MatchTypeV2=PHRASE 裸词 → 不拆，词面改为 \"kw\""
+    }
+  },
+
+  "account": "4256317784",
+  "customerName": "REPLACE_请改为_list_accounts_返回的_mediaAccountName",
+  "name": "CLI_KeywordFixSplit_Test_2026",
+  "url": "https://www.example.com",
+  "locations": ["United States"],
+  "productWords": ["test", "keyword"],
+  "googleDataRecordId": null,
+  "draft": false,
+
+  "campaign": {
+    "Name": "CLI_KeywordFixSplit_Test_2026",
+    "StatusV2": "Enabled",
+    "ChannelTypeV2": "SEARCH",
+    "BiddingStrategyTypeV2": "TARGET_SPEND",
+    "Budget": 50,
+    "BudgetShared": false,
+    "BudgetId": 0,
+    "BudgetBudgetDeliveryMethodV2": "STANDARD",
+    "TargetSpend_BidCeilingAmount": 2,
+    "ManualCpc_EnhancedCpcEnabled": false,
+    "TargetGoogleSearch": true,
+    "TargetSearchNetwork": false,
+    "TargetContentNetwork": false,
+    "TargetPartnerSearchNetwork": false,
+    "PositiveGeoTargetType": 0,
+    "NegativeGeoTargetType": 0,
+    "DSADomainName": "",
+    "DSALanguageCode": "en",
+    "StartTime": "2026-05-25",
+    "EndTime": "2037-12-30",
+    "targetedLocations": [{ "id": "2840", "bidModifier": 0, "bidModifierSpecified": false }],
+    "excludedLocations": [],
+    "excludedIpAddresses": [],
+    "targetedLanguages": [{ "id": 1000 }],
+    "targetedPlatforms": [
+      { "id": 30001, "bidModifier": 0 },
+      { "id": 30002, "bidModifier": 0 },
+      { "id": 30000, "bidModifier": 0 }
+    ],
+
+    "adSchedules": [
+      { "DayOfWeekV2": 2, "startHour": 0, "StartMinuteV2": 2, "endHour": 24, "EndMinuteV2": 2 },
+      { "DayOfWeekV2": 3, "startHour": 0, "StartMinuteV2": 2, "endHour": 24, "EndMinuteV2": 2 },
+      { "DayOfWeekV2": 4, "startHour": 0, "StartMinuteV2": 2, "endHour": 24, "EndMinuteV2": 2 },
+      { "DayOfWeekV2": 5, "startHour": 0, "StartMinuteV2": 2, "endHour": 24, "EndMinuteV2": 2 },
+      { "DayOfWeekV2": 6, "startHour": 0, "StartMinuteV2": 2, "endHour": 24, "EndMinuteV2": 2 },
+      { "DayOfWeekV2": 7, "startHour": 0, "StartMinuteV2": 2, "endHour": 24, "EndMinuteV2": 2 },
+      { "DayOfWeekV2": 8, "startHour": 0, "StartMinuteV2": 2, "endHour": 24, "EndMinuteV2": 2 }
+    ],
+
+    "NegativeKeywordsForBatchJob": [
+      { "KeywordText": ["free sample", "cheap"], "MatchTypeV2": "BROAD", "FinalURL": "" }
+    ],
+
+    "ExtensionsForBatchJob": [],
+
+    "AdGroupsForBatchJob": [
+      {
+        "Name": "AG_Keyword_Normalize_Test",
+        "StatusV2": "Enabled",
+        "TypeV2": "SEARCH_STANDARD",
+        "RotationModeV2": "Unspecified",
+        "MaxCPCAmount": 2,
+
+        "KeywordsForBatchJob": [
+          {
+            "_comment": "用例 A：未写 MatchTypeV2，三种词面混在一块 → 应自动拆成 3 块",
+            "KeywordText": [
+              "broad match keyword",
+              "\"phrase match keyword\"",
+              "[exact match keyword]"
+            ],
+            "FinalURL": "https://www.example.com/test-a"
+          },
+          {
+            "_comment": "用例 B：块级 BROAD，但含完全匹配方括号词 → 应拆成 2 块",
+            "MatchTypeV2": "BROAD",
+            "KeywordText": ["running shoes broad", "[steel pipe exact]"],
+            "FinalURL": "https://www.example.com/test-b"
+          },
+          {
+            "_comment": "用例 C：块级 EXACT，全裸词 → 不拆，词面应变为 [kw]",
+            "MatchTypeV2": "EXACT",
+            "KeywordText": ["exact keyword one", "exact keyword two"],
+            "FinalURL": "https://www.example.com/test-c"
+          },
+          {
+            "_comment": "用例 D：块级 PHRASE，裸词 → 不拆，词面应变为 \"kw\"",
+            "MatchTypeV2": "PHRASE",
+            "KeywordText": ["phrase keyword only"],
+            "FinalURL": "https://www.example.com/test-d"
+          }
+        ],
+
+        "AdsForBatchJob": [
+          {
+            "TypeV2": "RESPONSIVE_SEARCH_AD",
+            "DestinationUrl": "https://www.example.com/test",
+            "Finalurl": "https://www.example.com/test",
+            "AdTitle": null,
+            "Path1": "test",
+            "Path2": "kw",
+            "headlinePart1": "Keyword Normalize Test H1",
+            "headlinePart2": "Validate Auto Fix Split",
+            "headlinePart3": "Do Not Run Create Yet",
+            "AddtionalHeadlines": [
+              "Headline Four For RSA",
+              "Headline Five For RSA",
+              "Headline Six For RSA",
+              "Headline Seven For RSA",
+              "Headline Eight For RSA",
+              "Headline Nine For RSA",
+              "Headline Ten For RSA",
+              "Headline Eleven RSA",
+              "Headline Twelve RSA"
+            ],
+            "adDescription": "Test ad for keyword validate only. Replace account before create.",
+            "adDescription2": "Second description line for RSA minimum fields.",
+            "AddtionalAdDescriptions": [
+              "Additional description one for responsive search ad.",
+              "Additional description two for responsive search ad."
+            ]
+          }
+        ]
+      }
+    ]
+  }
+}

package/dist/skill/assets/campaign-create-template.md

@@ -2,7 +2,7 @@
 
 `siluzan-tso ad campaign-create` **仅**接受 `--config-file` 指向的 JSON 文件
 
-**JSON 字段名保持 PascalCase**，与后端 `Campaign` / `CampaignCreationRecord` 契约一致；`ad campaign-validate` 阶段**不**改词面与结构。
+**JSON 字段名保持 PascalCase**，与后端 `Campaign` / `CampaignCreationRecord` 契约一致；`ad campaign-validate` 会**就地自动修复**关键词词面（按 `MatchTypeV2` 补全 `"` / `[]`，兼容 `matchTypeV2` / `keywordText` / `Items[]`），可用 `--write-normalized` 落盘修复后的 JSON。
 
 **`ad campaign-create` 提交前**，CLI 在 JSON 原文之外额外处理（不影响 validate 读到的「元」口径）：
 
@@ -202,12 +202,12 @@ siluzan-tso ad batch diff --batch-id <taskId> --config-file ./campaign.json --js
 
 ### 关键词块（`KeywordsForBatchJob[j]`）
 
-每个块描述一组**同匹配类型**的关键词：
+每个块描述一组**同匹配类型**的关键词。若同一块内混用裸词 / `"词组"` / `[完全]`（或与块级 `MatchTypeV2` 冲突的符号），`campaign-validate` 会**自动拆成多个块**（顺序：BROAD → PHRASE → EXACT，与 Web 智投一致），再按块级类型修复词面。
 
 | 字段          | 类型                              | 说明                                                                  |
 | ------------- | --------------------------------- | --------------------------------------------------------------------- |
-| `KeywordText` | string[]                          | 关键词词面数组；PHRASE 应写 `"keyword"`，EXACT 应写 `[keyword]`       |
-| `MatchTypeV2` | "BROAD" \| "PHRASE" \| "EXACT"    | 与词面格式对应                                                        |
+| `KeywordText` | string[]                          | 关键词词面数组；PHRASE 应写 `"keyword"`，EXACT 应写 `[keyword]`（裸词亦可，`campaign-validate` 会按 `MatchTypeV2` **自动修复**） |
+| `MatchTypeV2` | "BROAD" \| "PHRASE" \| "EXACT"    | 与词面格式对应；Google 网关以词面符号为准，CLI 校验时会改写 `KeywordText` 与之对齐 |
 | `FinalURL`    | string                            | 关键词级落地页                                                        |
 
 ### 创意块（`AdsForBatchJob[j]`，RSA）

package/dist/skill/references/keyword-planner-workflows.md

@@ -82,7 +82,7 @@ Google Keyword Planner 的搜索量/CPC 与**目标国家/地区**相关。CLI
 
 常见 ID（与 `ad campaign-create --location-ids` 同源）：美国 `2840`，中国 `2826`。
 
-### ⚠️ 多地区 `--geo`：返回汇总数据，无法按地区拆分
+### 多地区 `--geo`：返回汇总数据，无法按地区拆分
 
 `--geo` 可传多个 ID（逗号分隔，如 `--geo 2840,2826`），网关会把它们一并传给 `keywordidea/google?geoTargetConstantIds=...`。此时 Google Keyword Planner 返回的 `montlySearch`、CPC、竞争度等是**跨所传地区的汇总/合并口径**，**不是**「每个国家各一行」或 JSON 里带 `geoTargetConstantId` 分字段。
 
@@ -150,7 +150,7 @@ siluzan-tso keyword -k "structural adhesive,SG-200,curtain wall bonding" --url "
 2. ```bash
    siluzan-tso keyword -k "<种子>" --url "<竞品或落地页 URL>" --json-out ./snap-kw
    ```
-3. 合并去重、按搜索量/CPC/竞争度排序、截断 Top N、写「词包说明」：**由 AI 对落盘 JSON 处理**（CLI 不内置「相关度 Top 200」参数）。
+3. 合并去重、按搜索量/CPC/竞争度排序、截断 Top N、写「词包说明」（注意通过 google-analysis --sections keywords 获取的账号关键词数据禁止参与合并，因为包含同关键词多个广告系列的表现，一旦合并会导致数据错乱）
 
 ### 2）核心词长尾裂变 + 自定义过滤
 

package/dist/skill/report-templates/google-period-report.md

@@ -17,7 +17,7 @@
 | 4   | 广告系列表现（预算/出价策略/各系列消耗与效果）       | `google-analysis --sections campaigns`         |
 | 5   | 设备分布（PC/移动/平板 消耗/点击/转化）              | `google-analysis --sections devices`           |
 | 6   | 地域分布（国家/地区 消耗占比）                       | `google-analysis --sections geographic`        |
-| 7   | 关键词表现（词/消耗/CTR/CPC 排行）                   | `google-analysis --sections keywords`          |
+| 7   | 关键词表现（词/消耗/CTR/CPC 排行）                   | `google-analysis --sections keywords`（这个命令获取的关键词数据会来自多个系列，不能合并去重）|
 | 8   | 优化建议（根据以上数据给出可执行改进建议）           | 不额外拉数，基于已有数据撰写                   |
 
 **在执行任何数据拉取之前**，先向用户展示以下可选维度，询问是否需要追加：

package/dist/skill/scripts/install.ps1

@@ -9,7 +9,7 @@ $ErrorActionPreference = 'Stop'
 # -- Package info (injected at build time) ------------------------------------
 $PKG_NAME    = 'siluzan-tso-cli'
 # PKG_VERSION 锁定到与本脚本同批构建产物一致的版本，避免与 dist/skill 错位
-$PKG_VERSION = '1.1.21-beta.1'
+$PKG_VERSION = '1.1.21-beta.2'
 $CLI_BIN     = 'siluzan-tso'
 $SKILL_LABEL = 'Siluzan TSO'
 $INSTALL_CMD = 'npm install -g siluzan-tso-cli@beta'

package/dist/skill/scripts/install.sh

@@ -9,7 +9,7 @@ set -euo pipefail
 # -- Package info (injected at build time) ------------------------------------
 readonly PKG_NAME="siluzan-tso-cli"
 # PKG_VERSION 锁定到与本脚本同批构建产物一致的版本，避免与 dist/skill 错位
-readonly PKG_VERSION="1.1.21-beta.1"
+readonly PKG_VERSION="1.1.21-beta.2"
 readonly CLI_BIN="siluzan-tso"
 readonly SKILL_LABEL="Siluzan TSO"
 readonly INSTALL_CMD="npm install -g siluzan-tso-cli@beta"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "siluzan-tso-cli",
-  "version": "1.1.21-beta.1",
+  "version": "1.1.21-beta.2",
   "description": "Siluzan 广告账户管理 CLI — 查询账户、余额、消耗数据，管理绑定关系与充值。",
   "keywords": [
     "ad-account",