siluzan-tso-cli 1.1.37-beta.4 → 1.1.37-beta.5

package/README.md

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

package/dist/index.js

@@ -111582,6 +111582,52 @@ function pushErr2(errors, msg) {
 function pushWarn2(warnings, msg) {
   warnings.push(msg);
 }
+function readLocationId(loc) {
+  return loc["id"] !== void 0 ? loc["id"] : loc["Id"];
+}
+function validateLocationsFidelity(cfg, campaign, errors) {
+  const targetedLocations = campaign["targetedLocations"];
+  if (!Array.isArray(targetedLocations) || targetedLocations.length === 0) {
+    pushErr2(
+      errors,
+      "campaign.targetedLocations \u4E0D\u80FD\u4E3A\u7A7A\uFF0C\u8BF7\u5148\u6267\u884C\uFF1Asiluzan-tso ad geo search -a <accountId> -q <\u5730\u533A\u540D>"
+    );
+    return;
+  }
+  for (let i = 0; i < targetedLocations.length; i++) {
+    const loc = targetedLocations[i];
+    if (!loc || typeof loc !== "object") {
+      pushErr2(errors, `campaign.targetedLocations[${i}] \u5FC5\u987B\u662F\u5BF9\u8C61`);
+      continue;
+    }
+    const id = readLocationId(loc);
+    if (id === void 0 || id === null || String(id).trim() === "") {
+      pushErr2(errors, `campaign.targetedLocations[${i}] \u7F3A\u5C11 id \u5B57\u6BB5`);
+      continue;
+    }
+    const idStr = String(id).trim();
+    if (!/^\d{3,10}$/.test(idStr)) {
+      pushErr2(
+        errors,
+        `campaign.targetedLocations[${i}].id="${idStr}" \u4E0D\u662F\u5408\u6CD5\u7684 Google \u5730\u7406\u4F4D\u7F6E\u6570\u5B57 ID\uFF1B\u8BF7\u7528 siluzan-tso ad geo search -a <accountId> -q <\u5730\u533A\u540D> \u83B7\u53D6\uFF0C\u7981\u6B62\u7F16\u9020/ISO \u5FC3\u7B97`
+      );
+    }
+  }
+  const locations = cfg.locations;
+  if (Array.isArray(locations) && locations.length > 0) {
+    if (locations.length !== targetedLocations.length) {
+      pushErr2(
+        errors,
+        `\u5916\u5C42 locations\uFF08${locations.length}\uFF09\u4E0E campaign.targetedLocations\uFF08${targetedLocations.length}\uFF09\u6570\u91CF\u4E0D\u4E00\u81F4\uFF1B\u987B\u540C\u5E8F\u540C\u91CF\uFF08\u6BCF\u4E2A\u5C55\u793A\u540D\u5BF9\u5E94\u4E00\u6B21 ad geo search \u53D6\u5230\u7684 id\uFF09\u3002\u89C1 google-ads-plan-source-fidelity.md`
+      );
+    }
+    for (let i = 0; i < locations.length; i++) {
+      if (typeof locations[i] !== "string" || !locations[i].trim()) {
+        pushErr2(errors, `locations[${i}] \u4E0D\u80FD\u4E3A\u7A7A\u5B57\u7B26\u4E32`);
+      }
+    }
+  }
+}
 function calcGoogleCharLength(text) {
   let len = 0;
   for (const ch of text) {
@@ -111867,20 +111913,7 @@ function validateCampaignCreateConfigCore(cfg) {
       }
     }
   }
-  const targetedLocations = campaign["targetedLocations"];
-  if (!Array.isArray(targetedLocations) || targetedLocations.length === 0) {
-    pushErr2(
-      errors,
-      "campaign.targetedLocations \u4E0D\u80FD\u4E3A\u7A7A\uFF0C\u8BF7\u5148\u6267\u884C\uFF1Asiluzan-tso ad geo search -a <accountId> -q <\u5730\u533A\u540D>"
-    );
-  } else {
-    for (let i = 0; i < targetedLocations.length; i++) {
-      const loc = targetedLocations[i];
-      if (!loc || loc["id"] === void 0 && loc["Id"] === void 0) {
-        pushErr2(errors, `campaign.targetedLocations[${i}] \u7F3A\u5C11 id \u5B57\u6BB5`);
-      }
-    }
-  }
+  validateLocationsFidelity(cfg, campaign, errors);
   const targetedLanguages = campaign["targetedLanguages"];
   if (!Array.isArray(targetedLanguages) || targetedLanguages.length === 0) {
     pushErr2(errors, "campaign.targetedLanguages \u4E0D\u80FD\u4E3A\u7A7A\uFF08\u82F1\u8BED id=1000\uFF0C\u4E2D\u6587 id=1017\uFF09");
@@ -113872,6 +113905,7 @@ async function runAdSearchTerms(opts) {
 
 // src/commands/ad/geo.ts
 init_auth();
+import { readFileSync as readFileSync9 } from "fs";
 init_cli_json_snapshot();
 init_strip_legacy_google_fields();
 
@@ -114119,20 +114153,48 @@ async function runAdDeviceBidSet(opts) {
 }
 
 // src/commands/ad/geo.ts
+async function fetchGeoLocationCandidates(googleApiUrl, account, query, config, verbose) {
+  const url = `${googleApiUrl}/campaignmanagement/geolocations/${account}/${encodeURIComponent(query)}`;
+  const data = await apiFetch2(url, config, {}, verbose);
+  return Array.isArray(data) ? data : data.data ?? [];
+}
+function geoItemDisplayName(item) {
+  return String(item["locationName"] ?? item["canonicalName"] ?? item["name"] ?? "");
+}
+function geoItemType(item) {
+  return String(item["targetType"] ?? item["typeV2"] ?? "");
+}
+function pickGeoResolveCandidate(query, items2) {
+  if (items2.length === 0) return null;
+  const q = query.trim().toLowerCase();
+  const isCountry = (it) => /country/i.test(geoItemType(it)) || geoItemType(it).toUpperCase() === "COUNTRY";
+  const nameEq = (it) => geoItemDisplayName(it).trim().toLowerCase() === q;
+  const exactCountry = items2.find((it) => isCountry(it) && nameEq(it));
+  if (exactCountry) return exactCountry;
+  const anyCountry = items2.find((it) => isCountry(it));
+  if (anyCountry) return anyCountry;
+  const exactAny = items2.find((it) => nameEq(it));
+  if (exactAny) return exactAny;
+  return items2[0] ?? null;
+}
 async function runAdGeoSearch(opts) {
   const config = loadConfig(opts.token);
   const googleApiUrl = requireGoogleApi(config);
-  const url = `${googleApiUrl}/campaignmanagement/geolocations/${opts.account}/${encodeURIComponent(opts.query)}`;
-  let data;
+  let items2;
   try {
-    data = await apiFetch2(url, config, {}, opts.verbose);
+    items2 = await fetchGeoLocationCandidates(
+      googleApiUrl,
+      opts.account,
+      opts.query,
+      config,
+      opts.verbose
+    );
   } catch (err) {
     console.error(`
 \u274C \u641C\u7D22\u5730\u7406\u4F4D\u7F6E\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}
 `);
     process.exit(1);
   }
-  const items2 = Array.isArray(data) ? data : data.data ?? [];
   console.log(`
 \u5730\u7406\u4F4D\u7F6E\u641C\u7D22\u7ED3\u679C\u300C${opts.query}\u300D\uFF08\u5171 ${items2.length} \u6761\uFF09
 `);
@@ -114142,12 +114204,162 @@ async function runAdGeoSearch(opts) {
   }
   for (const item of items2) {
     const id = String(item["id"] ?? "");
-    const name2 = String(item["locationName"] ?? item["canonicalName"] ?? item["name"] ?? "");
-    const type = String(item["targetType"] ?? item["typeV2"] ?? "");
+    const name2 = geoItemDisplayName(item);
+    const type = geoItemType(item);
     console.log(`  id:${id}  ${name2}  [${type}]`);
   }
   console.log();
 }
+function parseGeoResolveQueries(opts) {
+  const out = [];
+  if (opts.fromFile) {
+    const raw = readFileSync9(opts.fromFile, "utf8").trim();
+    if (raw.startsWith("[")) {
+      const arr = JSON.parse(raw);
+      if (!Array.isArray(arr)) {
+        throw new Error(`--from-file JSON \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4\uFF1A${opts.fromFile}`);
+      }
+      for (const x of arr) {
+        if (typeof x === "string" && x.trim()) out.push(x.trim());
+        else if (x && typeof x === "object" && typeof x.name === "string") {
+          const n = x.name.trim();
+          if (n) out.push(n);
+        }
+      }
+    } else {
+      for (const line of raw.split(/\r?\n/)) {
+        const t = line.trim();
+        if (t && !t.startsWith("#")) out.push(t);
+      }
+    }
+  }
+  if (opts.queries) {
+    for (const part of opts.queries.split(",")) {
+      const t = part.trim();
+      if (t) out.push(t);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const q of out) {
+    const key = q.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(q);
+  }
+  return unique;
+}
+async function runAdGeoResolve(opts) {
+  let queries;
+  try {
+    queries = parseGeoResolveQueries(opts);
+  } catch (err) {
+    console.error(`
+\u274C ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  }
+  if (queries.length === 0) {
+    console.error(
+      '\n\u274C \u8BF7\u63D0\u4F9B --queries "Peru,Chile,..." \u6216 --from-file <names.txt|names.json>\n'
+    );
+    process.exit(1);
+  }
+  const config = loadConfig(opts.token);
+  const googleApiUrl = requireGoogleApi(config);
+  const rows = [];
+  for (const query of queries) {
+    let items2 = [];
+    try {
+      items2 = await fetchGeoLocationCandidates(
+        googleApiUrl,
+        opts.account,
+        query,
+        config,
+        opts.verbose
+      );
+    } catch (err) {
+      console.error(
+        `
+\u274C \u89E3\u6790\u300C${query}\u300D\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}
+`
+      );
+      process.exit(1);
+    }
+    const picked = pickGeoResolveCandidate(query, items2);
+    if (!picked) {
+      rows.push({
+        query,
+        id: null,
+        name: null,
+        targetType: null,
+        status: "not_found",
+        candidates: 0
+      });
+      continue;
+    }
+    rows.push({
+      query,
+      id: String(picked["id"] ?? "") || null,
+      name: geoItemDisplayName(picked) || null,
+      targetType: geoItemType(picked) || null,
+      status: items2.length > 1 ? "ambiguous_ok" : "ok",
+      candidates: items2.length
+    });
+  }
+  const failed = rows.filter((r) => !r.id);
+  const locations = rows.filter((r) => r.id).map((r) => r.query);
+  const targetedLocations = rows.filter((r) => r.id).map((r) => ({ id: r.id }));
+  const payload = {
+    account: opts.account,
+    resolved: rows.filter((r) => r.id).length,
+    failed: failed.length,
+    rows,
+    /** 可直接写入 campaign-create JSON */
+    locations,
+    targetedLocations,
+    nameToId: Object.fromEntries(
+      rows.filter((r) => r.id).map((r) => [r.query, r.id])
+    )
+  };
+  if (await emitCliJsonOrSnapshot(
+    { jsonOut: opts.jsonOut },
+    {
+      section: `ad-geo-resolve-${opts.account}`,
+      commandLabel: "ad geo resolve",
+      commandHint: opts.account,
+      payload,
+      idSuffix: opts.account
+    }
+  )) {
+    if (failed.length > 0 && !opts.allowPartial) process.exit(1);
+    return;
+  }
+  console.log(`
+\u5730\u7406\u4F4D\u7F6E\u6279\u91CF\u89E3\u6790\uFF08${opts.account}\uFF09\uFF1A\u6210\u529F ${payload.resolved} / \u5931\u8D25 ${failed.length}
+`);
+  for (const r of rows) {
+    if (r.id) {
+      console.log(`  \u2705 ${r.query} \u2192 id:${r.id}  ${r.name ?? ""}  [${r.targetType ?? ""}]`);
+    } else {
+      console.log(`  \u274C ${r.query} \u2192 \u672A\u627E\u5230`);
+    }
+  }
+  if (failed.length > 0) {
+    console.error(
+      `
+\u274C ${failed.length} \u4E2A\u5730\u540D\u672A\u89E3\u6790\uFF1B\u8BF7\u6539\u540D\u540E\u91CD\u8BD5\uFF0C\u6216\u68C0\u67E5\u62FC\u5199\uFF08\u52FF\u7F16\u9020 id\uFF09\u3002
+`
+    );
+    if (!opts.allowPartial) process.exit(1);
+  } else {
+    console.log(
+      `
+\u63D0\u793A\uFF1A--json-out \u843D\u76D8\u540E\u53EF\u8BFB locations / targetedLocations / nameToId\uFF0C\u76F4\u63A5\u5199\u5165 campaign-create JSON\u3002
+`
+    );
+  }
+}
 async function runAdGeoList(opts) {
   const config = loadConfig(opts.token);
   const googleApiUrl = requireGoogleApi(config);
@@ -115915,7 +116127,7 @@ async function runPmaxImageValidation(configFile, cfg) {
 // src/commands/ad/pmax-image-resolve.ts
 init_auth();
 import { basename as basename4, dirname as dirname8, isAbsolute as isAbsolute3, resolve as resolve7 } from "path";
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 
 // src/commands/ad/pmax-urls.ts
 function pmaxChannelTypesUrl(googleApiUrl) {
@@ -116078,7 +116290,7 @@ async function uploadPmaxImageFileBase64(config, googleApiUrl, accountId, absIma
 async function uploadPmaxImageFile(config, googleApiUrl, accountId, absImagePath, name2, verbose) {
   const fileName = basename4(absImagePath);
   const assetName = (name2 ?? fileName).trim() || fileName;
-  const fileBuffer = readFileSync9(absImagePath);
+  const fileBuffer = readFileSync10(absImagePath);
   if (fileBuffer.length <= MAX_BASE64_UPLOAD_BYTES) {
     return uploadPmaxImageFileBase64(
       config,
@@ -116164,7 +116376,7 @@ function assertPmaxImageSlotsResolved(slots, requiredKinds = ["marketing", "squa
 }
 
 // src/commands/ad/pmax-load.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 
 // src/commands/ad/pmax-campaign-extensions.ts
 init_auth();
@@ -116794,7 +117006,7 @@ function detectDeprecatedPmaxVideoKeys(raw) {
 function tryLoadPmaxCreateConfig(configFile) {
   let raw;
   try {
-    raw = JSON.parse(readFileSync10(configFile, "utf8"));
+    raw = JSON.parse(readFileSync11(configFile, "utf8"));
   } catch {
     return null;
   }
@@ -116802,7 +117014,7 @@ function tryLoadPmaxCreateConfig(configFile) {
 }
 function loadPmaxCreateConfigRaw(configFile) {
   try {
-    const raw = JSON.parse(readFileSync10(configFile, "utf8"));
+    const raw = JSON.parse(readFileSync11(configFile, "utf8"));
     return stripMetaKeys(raw);
   } catch {
     return null;
@@ -116853,19 +117065,19 @@ function buildPmaxCreateUrl(googleApiUrl, accountId) {
 }
 
 // src/commands/ad/pmax-video-upload.ts
-import { existsSync as existsSync3, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync13 } from "fs";
 import { basename as basename5, dirname as dirname10, isAbsolute as isAbsolute5, resolve as resolve9 } from "path";
 
 // src/commands/ad/pmax-shared.ts
 init_auth();
 init_cli_json_snapshot();
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 import { dirname as dirname9, isAbsolute as isAbsolute4, resolve as resolve8 } from "path";
 var PMAX_MONEY_KEYS = /* @__PURE__ */ new Set(["budget", "targetCpa_BidingAmount"]);
 function loadPmaxJsonFile(configFile) {
   let raw;
   try {
-    raw = JSON.parse(readFileSync11(configFile, "utf8"));
+    raw = JSON.parse(readFileSync12(configFile, "utf8"));
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     console.error(`
@@ -117065,7 +117277,7 @@ function runPmaxVideoValidation(configFile, cfg) {
     return { errors, warnings };
   }
   try {
-    const buf = readFileSync12(abs);
+    const buf = readFileSync13(abs);
     if (buf.length === 0) errors.push(`videoPath \u4E3A\u7A7A\u6587\u4EF6\uFF1A${abs}`);
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
@@ -117128,7 +117340,7 @@ async function uploadPmaxLocalVideo(opts) {
   const fileName = basename5(opts.absVideoPath);
   const title = (opts.title ?? fileName).trim() || fileName;
   const description = (opts.description ?? "Uploaded via siluzan-tso PMax video upload").trim() || "Uploaded via siluzan-tso";
-  const fileBuffer = readFileSync12(opts.absVideoPath);
+  const fileBuffer = readFileSync13(opts.absVideoPath);
   const form = new FormData();
   form.append("media_account_id", opts.accountId.replace(/-/g, ""));
   form.append("title", title);
@@ -117186,7 +117398,7 @@ function validatePmaxVideoPathQuick(absPath) {
     return `\u89C6\u9891\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${absPath}`;
   }
   try {
-    if (readFileSync12(absPath).length === 0) return `\u89C6\u9891\u6587\u4EF6\u4E3A\u7A7A\uFF1A${absPath}`;
+    if (readFileSync13(absPath).length === 0) return `\u89C6\u9891\u6587\u4EF6\u4E3A\u7A7A\uFF1A${absPath}`;
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     return `\u65E0\u6CD5\u8BFB\u53D6\u89C6\u9891\u6587\u4EF6\uFF08${absPath}\uFF09\uFF1A${msg}`;
@@ -118589,7 +118801,7 @@ async function runAdCampaignValidate(opts) {
 }
 
 // src/commands/ad/pmax-image-convert.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync5, readFileSync as readFileSync13, existsSync as existsSync4 } from "fs";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync5, readFileSync as readFileSync14, existsSync as existsSync4 } from "fs";
 import { resolve as resolve10, dirname as dirname11, basename as basename7, extname } from "path";
 var SPECS = [
   { kind: "marketing", width: 1200, height: 628, fit: "cover", suffix: "_marketing" },
@@ -118678,7 +118890,7 @@ async function runAdPmaxImageConvert(opts) {
   if (opts.updateConfig) {
     const configPath = resolve10(opts.updateConfig);
     try {
-      const raw = JSON.parse(readFileSync13(configPath, "utf8"));
+      const raw = JSON.parse(readFileSync14(configPath, "utf8"));
       const imgPaths = raw["imagePaths"] ?? {};
       if (outputPaths.marketing) imgPaths["marketing"] = outputPaths.marketing;
       if (outputPaths.square) imgPaths["square"] = outputPaths.square;
@@ -119888,6 +120100,28 @@ function register20(program2) {
       verbose: opts.verbose
     });
   });
+  geoCmd.command("resolve").description(
+    "\u6279\u91CF\u89E3\u6790\u5730\u540D\u2192locationId\uFF08\u6295\u653E\u65B9\u6848\u56FD\u5BB6\u5217\u8868\uFF09\uFF1B\u8F93\u51FA locations / targetedLocations / nameToId\uFF0C\u4F9B campaign-create JSON \u76F4\u63A5\u5199\u5165"
+  ).requiredOption("-a, --account <id>", "Google \u8D26\u6237 mediaCustomerId").option("-q, --queries <text>", "\u9017\u53F7\u5206\u9694\u5730\u540D\uFF0C\u5982 Peru,Chile,Kenya").option(
+    "--from-file <path>",
+    "\u5730\u540D\u6587\u4EF6\uFF1A\u6BCF\u884C\u4E00\u4E2A\uFF0C\u6216 JSON \u5B57\u7B26\u4E32\u6570\u7EC4\uFF08\u5982 plan-extract.json \u7684 locations\uFF09"
+  ).option("--allow-partial", "\u5141\u8BB8\u90E8\u5206\u5931\u8D25\u4ECD exit 0\uFF08\u9ED8\u8BA4\u4EFB\u4E00\u672A\u89E3\u6790\u5219 exit 1\uFF09", false).option("-t, --token <token>", "Auth Token").option(
+    "--json-out <path>",
+    "\u843D\u76D8\uFF08\u76EE\u5F55\u6216 *.json\uFF09\uFF1Bstdout \u4E00\u884C\u6458\u8981\uFF1B\u8BFB payload.locations / targetedLocations / nameToId",
+    void 0
+  ).option("--verbose", "\u8BE6\u7EC6\u9519\u8BEF\u4FE1\u606F", false).action(
+    async (opts) => {
+      await runAdGeoResolve({
+        token: opts.token,
+        account: opts.account,
+        queries: opts.queries,
+        fromFile: opts.fromFile,
+        allowPartial: opts.allowPartial,
+        jsonOut: opts.jsonOut,
+        verbose: opts.verbose
+      });
+    }
+  );
   geoCmd.command("list").description(
     "\u67E5\u8BE2\u5730\u7406\u4F4D\u7F6E\u5B9A\u5411\u5217\u8868\uFF08targeted = \u5DF2\u5B9A\u4F4D\uFF1Bexcluded = \u5DF2\u6392\u9664\uFF1Breport = \u6D88\u8017\u62A5\u544A\uFF0C\u53EF\u9009\u6309\u5E7F\u544A\u7CFB\u5217\u8FC7\u6EE4\uFF09"
   ).requiredOption("-a, --account <id>", "Google \u8D26\u6237 mediaCustomerId").option("--mode <mode>", "\u5217\u8868\u7C7B\u578B\uFF1Atargeted | excluded | report\uFF08\u9ED8\u8BA4 targeted\uFF09", "targeted").option("--campaign-id <id>", "\u53EF\u9009\uFF1A\u6309\u5E7F\u544A\u7CFB\u5217 ID \u8FC7\u6EE4\u7ED3\u679C\uFF08\u6765\u81EA ad campaigns\uFF09").option("--start <date>", "\u5F00\u59CB\u65E5\u671F YYYY-MM-DD\uFF08\u9ED8\u8BA4 30 \u5929\u524D\uFF0C\u6240\u6709\u6A21\u5F0F\u751F\u6548\uFF09").option("--end <date>", "\u7ED3\u675F\u65E5\u671F YYYY-MM-DD\uFF08\u9ED8\u8BA4\u4ECA\u5929\uFF0C\u6240\u6709\u6A21\u5F0F\u751F\u6548\uFF09").option("-t, --token <token>", "Auth Token").option(

package/dist/skill/SKILL.md

@@ -82,7 +82,7 @@ siluzan-tso -h   # 查看帮助
 
 | 用户意图（关键词） | 工作流 | 必读文档 |
 | ------------------ | ------ | -------- |
-| 新建搜索系列 / 出投放方案 / **根据官网·网站·URL 生成 Google 搜索广告** / 搜索广告文案·关键词·**表格** / 写搜索广告计划 | **W3** | `references/google-ads/google-ads-campaign-plan.md` + **`assets/campaign-create-template.json`**（结构真相源，先 Read）+ `assets/campaign-create-template.md`（字段说明）；表格交付读 `references/google-ads/rules/google-ads-launch-plan-template.md`。**≠ P8 网站诊断 / ≠ P9 市场分析 / ≠ W5 仅拓词** |
+| 新建搜索系列 / 出投放方案 / **按 Excel·xlsx·表格投放方案创建广告** / **根据官网·网站·URL 生成 Google 搜索广告** / 搜索广告文案·关键词·**表格** / 写搜索广告计划 | **W3** | `references/google-ads/google-ads-campaign-plan.md` + **`assets/campaign-create-template.json`**（先 Read）+ `assets/campaign-create-template.md`；**有方案文件时必读** `references/google-ads/rules/google-ads-plan-source-fidelity.md`（`plan-extract` → **`ad geo resolve`** → assemble 脚本，禁止对话手填 JSON）；表格交付读 `references/google-ads/rules/google-ads-launch-plan-template.md`。**≠ P8 / ≠ P9 / ≠ W5** |
 | 广告系列/组/广告/关键词 CRUD / 拒审 | W3 | `references/google-ads/google-ads.md` |
 | PMax 系列 | W3 | **`assets/pmax-create-template.json`**（先 Read）+ `assets/pmax-create-template.md` + `references/google-ads/pmax-api.md` |
 | AI 智投草稿 list/get/update/publish | W4 | `references/google-ads/google-ads.md`（§ ad batch） |

package/dist/skill/_meta.json

@@ -1,5 +1,5 @@
 {
   "slug": "siluzan-tso",
-  "version": "1.1.37-beta.4",
-  "publishedAt": 1783934085806
+  "version": "1.1.37-beta.5",
+  "publishedAt": 1784079896188
 }

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

@@ -8,6 +8,8 @@
       "campaign-validate 推荐 --json-out ",
       "否词只写 campaign.NegativeKeywordsForBatchJob，禁止把 free/jobs/tutorial 等否词抄进 AdGroupsForBatchJob[].KeywordsForBatchJob",
       "KeywordText 是 JSON 字符串数组，空格多词合法（如 how to make）；禁止因多词省略否词或让用户去后台手补",
+      "Excel/表格方案：plan-extract.json → ad geo resolve --json-out → assemble-campaign-from-plan.mjs；禁止对话手填完整 JSON、禁止编造 geo id",
+      "Excel/表格方案：中间件 keyword 带 matchType；组装脚本分 EXACT/PHRASE/BROAD 块；有方案源时勿压成一律 BROAD",
       "RSA 须同时写 DestinationUrl 与 Finalurl（后端必填 Finalurl；仅有 DestinationUrl 时 validate 可能仍通过）",
       "SITELINK 须写 AssetFieldType: SITELINK（与 typeV2 一致）",
       "提交前：ad campaign-validate → 用户确认 → ad campaign-create（勿对 validate 加 --json-out）"

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

@@ -31,6 +31,16 @@ JSON 模板：同目录 [`campaign-create-template.json`](campaign-create-templa
 **禁止**：把方案 Markdown「否定词表」里的 `free` / `jobs` / `tutorial` 等抄进 `KeywordsForBatchJob`——那会**主动购买**这些流量。  
 **正确**：否词只写 `NegativeKeywordsForBatchJob`；`ad campaign-validate` 会对误填给出 **warnings**（常见否词词根 / 与否词块重复）。
 
+### Excel / 表格方案保真（地域 + 匹配类型）
+
+用户给了投放方案文件时，**必读** `references/google-ads/rules/google-ads-plan-source-fidelity.md`，并遵守：
+
+| 坑 | 正确做法 |
+| -- | -------- |
+| 编造 `targetedLocations[].id` 或对 30 国逐条 `geo search` | **一次** `ad geo resolve --from-file … --json-out`；见 `google-ads-plan-source-fidelity.md` |
+| 对话里手写完整 campaign JSON | 抽取 `plan-extract.json` → geo resolve → `assemble-campaign-from-plan.mjs` |
+| 方案有 Exact/Phrase，JSON 却一律 `BROAD` | 中间件 keyword 带 `matchType`；组装脚本自动分块 |
+
 **多词短语（与 `keyword-negative-create` 同类误判）**：`KeywordText` 是 **JSON 字符串数组**，**空格多词完全合法**（如 `"how to make"`、`"home cooking"`）。PHRASE 写 `"\"vegan recipe\""` 或裸词 + `MatchTypeV2: "PHRASE"`（validate 会补引号）。**禁止**因「多词」就省略否词或让用户去 Google Ads 后台手补——那是 Agent 误判，不是 `campaign-create` 限制。
 
 投放方案 Markdown 中 §3.3 关键词矩阵 → `KeywordsForBatchJob`；§3.3 系列级否定词 / §3.4 账户级否定词 → `NegativeKeywordsForBatchJob`（账户级列表仍须在 Google 后台单独应用）。
@@ -113,7 +123,7 @@ siluzan-tso ad batch diff --batch-id <taskId> --config-file ./campaign.json --js
 | `customerName`       | string         |      | 展示/智投用客户名；**可省略**——`campaign-create` / `batch publish` 会按 `account` 调 `list-accounts` 自动填入 `mediaCustomerName`。若填写则须与之一致，否则提交时 CLI 自动更正 |
 | `name`               | string         |      | 智投 `campaignName`；缺省取 `campaign.Name`；账户内不得与已有在投/暂停系列重名，否则 BatchJob 系列创建失败                                                                     |
 | `url`                | string         |      | 智投展示用 URL；后端只读，用于回显                                                                                                                                             |
-| `locations`          | string[]       |      | 展示用地区名（后端只读，可空数组）                                                                                                                                             |
+| `locations`          | string[]       |      | 展示用地区名（后端只读，可空数组）；**若填写非空**则长度须与 `campaign.targetedLocations` 一致（validate 硬校验）                                                              |
 | `productWords`       | string[]       |      | 智投/推荐用产品核心词                                                                                                                                                          |
 | `googleDataRecordId` | string \| null |      | 智投记录 ID；省略时提交 `""`（CLI 默认）                                                                                                                                       |
 | `draft`              | boolean        |      | `false`（默认）立即发布到 Google；`true` 仅保存草稿，需后续 `ad batch publish`                                                                                                 |
@@ -163,7 +173,7 @@ siluzan-tso ad batch diff --batch-id <taskId> --config-file ./campaign.json --js
 
 | 字段                    | 类型                                     | 必填 | 说明                                                            |
 | ----------------------- | ---------------------------------------- | :--: | --------------------------------------------------------------- |
-| `targetedLocations`     | `{ id: string, bidModifier?: number }[]` |  ✅  | 至少 1 个；先 `siluzan-tso ad geo search -a <acct> -q <地区名>` |
+| `targetedLocations`     | `{ id: string, bidModifier?: number }[]` |  ✅  | 至少 1 个；**id 必须来自** `siluzan-tso ad geo search -a <acct> -q <地区名>`（禁止编造） |
 | `excludedLocations`     | 同上                                     |      | 排除地区                                                        |
 | `targetedLanguages`     | `{ id: number }[]`                       |  ✅  | 英语 1000，中文 1017                                            |
 | `targetedPlatforms`     | `{ id: number, bidModifier?: number }[]` |      | 30001 桌面 / 30002 平板 / 30000 移动                            |
@@ -247,6 +257,7 @@ siluzan-tso ad batch diff --batch-id <taskId> --config-file ./campaign.json --js
 | 规则                    | 说明                                                                                                                           |
 | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
 | 基础                    | `customerName` / `campaign` 非空；`Budget > 0`；地理/语言至少 1 项                                                             |
+| 地域一致性              | 外层 `locations` 非空时，长度须等于 `targetedLocations`；每个 location `id` 须为数字字符串                                       |
 | 网络                    | `TargetPartnerSearchNetwork` 须 false；不可同时关闭 Google 搜索与搜索网络                                                      |
 | RSA / 关键词 / 附加信息 | 标题 **15** 条、描述 **4** 条（须写满）；字符上限、词面非空；RSA `Path1`/`Path2` 必填；SITELINK 行长度限制                     |
 | 否词误填                | `KeywordsForBatchJob` 含常见否词词根或与 `NegativeKeywordsForBatchJob` 重复 → **warnings**（不阻断，须 Agent 修正后再 create） |

package/dist/skill/assets/plan-extract.example.json

@@ -0,0 +1,74 @@
+{
+  "_comment": "Excel/表格抽取的中间件（非 campaign-create 契约）。Agent 抽取脚本输出此形状；再用 ad geo resolve + assemble-campaign-from-plan.mjs 生成最终 JSON。",
+  "account": "REPLACE_mediaCustomerId",
+  "customerName": "REPLACE_from_list_accounts",
+  "name": "Search_Brand_US_2026",
+  "url": "https://www.example.com",
+  "budget": 100,
+  "biddingStrategyTypeV2": "MANUAL_CPC",
+  "manualCpcEnhancedCpcEnabled": false,
+  "maxCpcDefault": 5,
+  "languageId": 1000,
+  "startTime": "2026-07-15",
+  "endTime": "2037-12-30",
+  "locations": ["United States", "Canada"],
+  "productWords": ["brand", "product"],
+  "adGroups": [
+    {
+      "name": "Core_Brand_Keywords",
+      "maxCpc": 5,
+      "finalUrl": "https://www.example.com/products",
+      "keywords": [
+        { "text": "brand name product", "matchType": "EXACT" },
+        { "text": "brand name product", "matchType": "PHRASE" },
+        { "text": "buy brand product online", "matchType": "BROAD" }
+      ],
+      "rsa": {
+        "path1": "products",
+        "path2": "brand",
+        "headlines": [
+          "Brand Name Official Store",
+          "Quality Products You Trust",
+          "Shop Direct From Brand",
+          "Headline 4",
+          "Headline 5",
+          "Headline 6",
+          "Headline 7",
+          "Headline 8",
+          "Headline 9",
+          "Headline 10",
+          "Headline 11",
+          "Headline 12",
+          "Headline 13",
+          "Headline 14",
+          "Headline 15"
+        ],
+        "descriptions": [
+          "Description line one for the brand.",
+          "Description line two for the brand.",
+          "Description line three for the brand.",
+          "Description line four for the brand."
+        ]
+      }
+    }
+  ],
+  "negativeKeywords": [
+    { "text": "free", "matchType": "BROAD" },
+    { "text": "cheap", "matchType": "BROAD" }
+  ],
+  "extensions": {
+    "sitelinks": [
+      {
+        "text": "About Us",
+        "line2": "Company Info",
+        "line3": "Learn More",
+        "url": "https://www.example.com/about"
+      }
+    ],
+    "callouts": ["Free Shipping", "Official Store"],
+    "structuredSnippet": {
+      "header": "Types",
+      "values": ["Product A", "Product B", "Product C", "Product D"]
+    }
+  }
+}

package/dist/skill/assets/scripts/assemble-campaign-from-plan.mjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+/**
+ * 将 plan-extract.json + ad geo resolve 落盘 JSON → campaign-create 配置。
+ *
+ * 用法：
+ *   node assemble-campaign-from-plan.mjs \
+ *     --plan ./plan-extract.json \
+ *     --geo ./snap-geo/ad-geo-resolve-123.json \
+ *     --template ./campaign-create-template.json \
+ *     --out ./campaign.json
+ *
+ * 匹配类型与 geo id 只来自输入文件，不在此脚本内猜测。
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+function arg(name, fallback) {
+  const i = process.argv.indexOf(name);
+  if (i === -1) return fallback;
+  return process.argv[i + 1];
+}
+
+function die(msg) {
+  console.error(`❌ ${msg}`);
+  process.exit(1);
+}
+
+function stripMeta(value) {
+  if (Array.isArray(value)) return value.map(stripMeta);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (k.startsWith("_")) continue;
+      out[k] = stripMeta(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+function normalizeMatchType(raw) {
+  const u = String(raw ?? "BROAD").trim().toUpperCase();
+  if (u === "EXACT" || u === "完全匹配" || u === "精确匹配") return "EXACT";
+  if (u === "PHRASE" || u === "词组匹配" || u === "短语匹配") return "PHRASE";
+  if (u === "BROAD" || u === "广泛匹配") return "BROAD";
+  die(`未知 matchType: ${raw}`);
+}
+
+function formatKeyword(text, matchType) {
+  const core = String(text ?? "")
+    .trim()
+    .replace(/^\[|\]$/g, "")
+    .replace(/^"|"$/g, "");
+  if (!core) die("关键词 text 为空");
+  if (matchType === "EXACT") return `[${core}]`;
+  if (matchType === "PHRASE") return `"${core}"`;
+  return core;
+}
+
+function readJsonFile(path) {
+  const raw = readFileSync(path, "utf8").replace(/^\uFEFF/, "");
+  return JSON.parse(raw);
+}
+
+function loadGeoPayload(geoPath) {
+  const geo = readJsonFile(geoPath);
+  // 兼容 --json-out 包一层 / 直接 payload
+  const payload = geo.targetedLocations ? geo : (geo.data ?? geo.payload ?? geo);
+  if (!Array.isArray(payload.locations) || !Array.isArray(payload.targetedLocations)) {
+    die(`geo 文件缺少 locations / targetedLocations：${geoPath}`);
+  }
+  if (payload.locations.length !== payload.targetedLocations.length) {
+    die("geo 文件 locations 与 targetedLocations 数量不一致");
+  }
+  if (payload.failed > 0) {
+    die(`geo resolve 仍有 ${payload.failed} 个失败项，请先修好再组装`);
+  }
+  return payload;
+}
+
+function buildKeywordBlocks(keywords, finalUrl) {
+  const buckets = { EXACT: [], PHRASE: [], BROAD: [] };
+  for (const kw of keywords ?? []) {
+    const mt = normalizeMatchType(kw.matchType);
+    buckets[mt].push(formatKeyword(kw.text, mt));
+  }
+  const order = ["EXACT", "PHRASE", "BROAD"];
+  return order
+    .filter((mt) => buckets[mt].length > 0)
+    .map((mt) => ({
+      KeywordText: buckets[mt],
+      MatchTypeV2: mt,
+      FinalURL: finalUrl,
+    }));
+}
+
+function buildRsa(rsa, fallbackUrl) {
+  const headlines = rsa?.headlines ?? [];
+  const descriptions = rsa?.descriptions ?? [];
+  if (headlines.length !== 15) {
+    die(`RSA headlines 须为 15 条，当前 ${headlines.length}`);
+  }
+  if (descriptions.length !== 4) {
+    die(`RSA descriptions 须为 4 条，当前 ${descriptions.length}`);
+  }
+  const url = rsa.finalUrl ?? fallbackUrl;
+  return {
+    TypeV2: "RESPONSIVE_SEARCH_AD",
+    DestinationUrl: url,
+    Finalurl: url,
+    AdTitle: null,
+    Path1: rsa.path1 ?? "",
+    Path2: rsa.path2 ?? "",
+    headlinePart1: headlines[0],
+    headlinePart2: headlines[1],
+    headlinePart3: headlines[2],
+    AddtionalHeadlines: headlines.slice(3),
+    adDescription: descriptions[0],
+    adDescription2: descriptions[1],
+    AddtionalAdDescriptions: descriptions.slice(2),
+  };
+}
+
+function buildExtensions(ext, defaultUrl) {
+  const out = [];
+  for (const s of ext?.sitelinks ?? []) {
+    out.push({
+      level: "Campaign",
+      typeV2: "SITELINK",
+      AssetFieldType: "SITELINK",
+      Properties: {
+        Text: s.text,
+        Line2: s.line2 ?? s.text,
+        Line3: s.line3 ?? s.line2 ?? s.text,
+        DestinationUrl: s.url ?? defaultUrl,
+      },
+    });
+  }
+  for (const c of ext?.callouts ?? []) {
+    out.push({
+      level: "Campaign",
+      typeV2: "CALLOUT",
+      AssetFieldType: "CALLOUT",
+      Properties: { Text: c },
+    });
+  }
+  const sn = ext?.structuredSnippet;
+  if (sn?.header && Array.isArray(sn.values) && sn.values.length > 0) {
+    out.push({
+      level: "Campaign",
+      typeV2: "STRUCTURED_SNIPPET",
+      AssetFieldType: "STRUCTURED_SNIPPET",
+      StructuredSnippetHeaderValue: { Key: sn.header, Value: sn.values },
+    });
+  }
+  return out;
+}
+
+const planPath = arg("--plan");
+const geoPath = arg("--geo");
+const templatePath = arg("--template");
+const outPath = arg("--out", "./campaign.json");
+
+if (!planPath || !geoPath || !templatePath) {
+  die(
+    "用法: node assemble-campaign-from-plan.mjs --plan <plan-extract.json> --geo <geo-resolve.json> --template <campaign-create-template.json> [--out campaign.json]",
+  );
+}
+
+const plan = stripMeta(readJsonFile(resolve(planPath)));
+const geo = loadGeoPayload(resolve(geoPath));
+const template = stripMeta(readJsonFile(resolve(templatePath)));
+
+const url = plan.url ?? template.url ?? "";
+const name = plan.name ?? template.name;
+const defaultMaxCpc = Number(plan.maxCpcDefault ?? 5);
+
+const negBlocks = (() => {
+  const buckets = { EXACT: [], PHRASE: [], BROAD: [] };
+  for (const kw of plan.negativeKeywords ?? []) {
+    const mt = normalizeMatchType(kw.matchType ?? "BROAD");
+    buckets[mt].push(formatKeyword(kw.text, mt));
+  }
+  return ["BROAD", "PHRASE", "EXACT"]
+    .filter((mt) => buckets[mt].length > 0)
+    .map((mt) => ({ KeywordText: buckets[mt], MatchTypeV2: mt, FinalURL: "" }));
+})();
+
+const adGroups = (plan.adGroups ?? []).map((g) => {
+  const finalUrl = g.finalUrl ?? url;
+  return {
+    Name: g.name,
+    StatusV2: "Enabled",
+    TypeV2: "SEARCH_STANDARD",
+    RotationModeV2: "Unspecified",
+    MaxCPCAmount: Number(g.maxCpc ?? defaultMaxCpc),
+    KeywordsForBatchJob: buildKeywordBlocks(g.keywords, finalUrl),
+    AdsForBatchJob: [buildRsa(g.rsa ?? {}, finalUrl)],
+  };
+});
+
+if (adGroups.length === 0) die("plan.adGroups 不能为空");
+
+let exact = 0;
+let phrase = 0;
+let broad = 0;
+for (const g of plan.adGroups ?? []) {
+  for (const kw of g.keywords ?? []) {
+    const mt = normalizeMatchType(kw.matchType);
+    if (mt === "EXACT") exact++;
+    else if (mt === "PHRASE") phrase++;
+    else broad++;
+  }
+}
+
+const campaign = {
+  ...(template.campaign ?? {}),
+  Name: name,
+  StatusV2: "Enabled",
+  ChannelTypeV2: "SEARCH",
+  BiddingStrategyTypeV2: plan.biddingStrategyTypeV2 ?? "MANUAL_CPC",
+  Budget: Number(plan.budget ?? template.campaign?.Budget ?? 0),
+  BudgetShared: false,
+  BudgetId: 0,
+  BudgetBudgetDeliveryMethodV2: "STANDARD",
+  ManualCpc_EnhancedCpcEnabled: Boolean(plan.manualCpcEnhancedCpcEnabled ?? false),
+  TargetGoogleSearch: true,
+  TargetSearchNetwork: false,
+  TargetContentNetwork: false,
+  TargetPartnerSearchNetwork: false,
+  StartTime: plan.startTime ?? template.campaign?.StartTime,
+  EndTime: plan.endTime ?? template.campaign?.EndTime,
+  targetedLocations: geo.targetedLocations,
+  excludedLocations: [],
+  excludedIpAddresses: [],
+  targetedLanguages: [{ id: Number(plan.languageId ?? 1000) }],
+  NegativeKeywordsForBatchJob: negBlocks,
+  ExtensionsForBatchJob: buildExtensions(plan.extensions, url),
+  AdGroupsForBatchJob: adGroups,
+};
+
+// MANUAL_CPC 不需要 TargetSpend 字段
+if (campaign.BiddingStrategyTypeV2 === "MANUAL_CPC") {
+  delete campaign.TargetSpend_BidCeilingAmount;
+} else if (
+  campaign.BiddingStrategyTypeV2 === "TARGET_SPEND" &&
+  campaign.TargetSpend_BidCeilingAmount == null
+) {
+  campaign.TargetSpend_BidCeilingAmount = defaultMaxCpc;
+}
+
+const out = {
+  account: String(plan.account ?? template.account),
+  customerName: plan.customerName ?? template.customerName ?? "",
+  name,
+  url,
+  locations: geo.locations,
+  productWords: plan.productWords ?? [],
+  googleDataRecordId: null,
+  draft: false,
+  campaign,
+};
+
+writeFileSync(resolve(outPath), JSON.stringify(out, null, 2) + "\n", "utf8");
+console.log(
+  JSON.stringify(
+    {
+      out: resolve(outPath),
+      locations: geo.locations.length,
+      adGroups: adGroups.length,
+      keywords: { exact, phrase, broad, total: exact + phrase + broad },
+      next: `siluzan-tso ad campaign-validate --config-file ${outPath}`,
+    },
+    null,
+    2,
+  ),
+);

package/dist/skill/references/core/agent-conventions.md

@@ -122,6 +122,7 @@
   - 当前凭据未返回手机号且用户指定了手机号 → 视同未校验通过，引导重新用手机号登录。
 - **Google 新建搜索系列**：流程在 `references/google-ads/google-ads-campaign-plan.md`；填 JSON 前**必须先 Read** `assets/campaign-create-template.json`，再 Read `assets/campaign-create-template.md`。**禁止**只读 `.md` 手写 JSON。
 - **「根据官网生成 Google 搜索广告 / 表格格式」**：仍属新建搜索系列 → **W3 + 本文件上条**；用户要的「表格」是 `google-ads-launch-plan-template.md` 对 JSON 的投影，**不是**可跳过 JSON/`campaign-validate` 的独立交付物。**禁止**与 P8 网站诊断、P9 市场分析、W5 仅拓词混用。
+- **Excel/表格投放方案 → 创建广告**：必读 `references/google-ads/rules/google-ads-plan-source-fidelity.md`。最短路径：`plan-extract.json` → **`ad geo resolve`** → `assemble-campaign-from-plan.mjs` → validate。**禁止**对话手填完整 campaign JSON、**禁止**编造 geo id、**禁止**一律 BROAD。
 - **「行业分析 / 行业分析报告 / 生成 XX 行业报告」**（例：「帮我生成一份电商行业的行业分析报告」）→ **P9 战略市场分析**。**必须**先 `siluzan-tso market-analysis collect … --json-out`，再 WebSearch 补数据、写 `market-report.json`，最后 `market-analysis render` 出 HTML。**禁止**不调用 CLI、仅在对话里用 WebSearch 写 Markdown 充当终稿。**不是** `google-analysis`、**不是** P8 网站诊断。
 - **开户首次响应**：对话内首次进入开户话题时，**必须先**按 `references/accounts/open-account-by-media.md` §「首次响应硬规范」输出**完整必填清单**（未指明媒体则列全平台六表），再收集资料；**禁止**未列清单就执行 `open-account` 或零散追问。
 - **Google 开户**：`open-account google-wizard` 仅限真实 TTY；Agent/自动化用非交互 `open-account google ...`，审核进度用 `account-history`。

package/dist/skill/references/core/workflows.md

@@ -55,23 +55,29 @@
 
 ## W3 · Google 广告创建与精细管理
 
-- **触发**：新建搜索系列、出投放方案、**根据官网/网站/URL 生成 Google 搜索广告（含「表格格式」）**、搜索广告文案/关键词/计划表、系列/组/广告/关键词 CRUD、PMax、拒审处理、日常调价/启停。
+- **触发**：新建搜索系列、出投放方案、**按 Excel/表格投放方案创建**、**根据官网/网站/URL 生成 Google 搜索广告（含「表格格式」）**、搜索广告文案/关键词/计划表、系列/组/广告/关键词 CRUD、PMax、拒审处理、日常调价/启停。
 - **勿误判**：仅给官网 URL 且目标是「写/生成搜索广告」→ **本卡片（W3）**，不是 P8 网站诊断、不是 P9 市场分析；若用户只要拓词无系列结构 → **W5**。
-- **必读**：方案与门禁 `references/google-ads/google-ads-campaign-plan.md` + **`assets/campaign-create-template.json`**（先 Read）+ `assets/campaign-create-template.md`；命令参数 `references/google-ads/google-ads.md`；PMax 加 **`assets/pmax-create-template.json`** + `assets/pmax-create-template.md` + `references/google-ads/pmax-api.md`。
+- **必读**：方案与门禁 `references/google-ads/google-ads-campaign-plan.md` + **`assets/campaign-create-template.json`**（先 Read）+ `assets/campaign-create-template.md`；**有 Excel/表格方案时另读** `references/google-ads/rules/google-ads-plan-source-fidelity.md`；命令参数 `references/google-ads/google-ads.md`；PMax 加 **`assets/pmax-create-template.json`** + `assets/pmax-create-template.md` + `references/google-ads/pmax-api.md`。
 - **创建路径选择**：
   - 已有 AI 智投草稿 → 走 **W4**。
   - **PMax 出方案/创建** → **`assets/pmax-create-template.json`**（先 Read）+ `pmax-create-template.md` + `pmax-api.md`：`pmax-validate` → 用户确认 → `pmax-create`（**勿**用 Search `campaign-create`）。
-  - 搜索系列出方案 → `google-ads-campaign-plan.md`：JSON → `campaign-validate` → 用户确认 → `campaign-create`。
+  - **用户给了 Excel/表格方案** → **方案源轨（三步）**：见 `google-ads-plan-source-fidelity.md`：`plan-extract.json` → **`ad geo resolve`** → `assemble-campaign-from-plan.mjs` → validate → 确认 → create（**禁止**对话手填完整 campaign JSON）。
+  - 搜索系列从零出方案 → `google-ads-campaign-plan.md`：JSON → `campaign-validate` → 用户确认 → `campaign-create`。
   - 已有完整结构化 JSON → 对应 validate → create。
 - **步骤（PMax 方案 → 创建）**：
   1. 账户：`list-accounts -m Google -k <id>`；落地页与品牌从官网/RAG 归纳。
-  2. 地域/语言：`ad geo search` 取 location id；语言 id 写入 JSON。
+  2. 地域/语言：多国用 `ad geo resolve`，单国用 `ad geo search`；语言 id 写入 JSON。
   3. 复制 `pmax-create-template.json` 填文案/预算/图片；**必须**含 `campaignExtensions`（至少 callouts + structuredSnippets）；**Lead Gen/B2B 默认** `campaignExtensions.leadForm`（方案 Markdown 须单列表单节）。
   4. 门禁：`ad pmax-validate --config-file ./pmax.json --json-out ./snap-pmax`。
   5. 输出 JSON + Markdown 方案 → 用户确认 → `ad pmax-create --commit "…"`。
   6. 复核：`ad campaigns` / `ad pmax-get`；缺表单时 `ad extension lead-form` 补挂。
-- **步骤（Search 一体化创建）**：
-  1. 地域 ID：`ad geo search -a <id> -q "United States"` 写入 `campaign.targetedLocations[].id`。
+- **步骤（Search · 方案文件 → 创建，最短稳妥）**：
+  1. 抽取脚本 → `plan-extract.json`（形状见 `assets/plan-extract.example.json`；关键词带 `matchType`）。
+  2. `ad geo resolve -a <id> --from-file ./locations.json --json-out ./snap-geo`（**一次**批量取 id）。
+  3. `node …/assemble-campaign-from-plan.mjs --plan … --geo … --template … --out ./campaign.json`。
+  4. `ad campaign-validate` → 确认摘要（国家↔id + Exact/Phrase/Broad 计数）→ `campaign-create` → `batch get` / `batch diff` / 自动补扩展。
+- **步骤（Search 一体化创建，无现成方案文件）**：
+  1. 地域：多国 `ad geo resolve`；单国 `ad geo search -a <id> -q "United States"`（仍禁止编造）。
   2. 门禁：`ad campaign-validate --config-file ./campaign.json`（必跑）。
   3. 用户确认后创建：`ad campaign-create --config-file ./campaign.json`，记录返回 taskId。
   4. 轮询：`ad batch get --id <taskId>` 直至非 Creating。

package/dist/skill/references/google-ads/google-ads-campaign-plan.md

@@ -9,6 +9,7 @@
 | 用户说法（示例）                                  | 正确工作流                                                                                       | **禁止**                                    |
 | ------------------------------------------------- | ------------------------------------------------------------------------------------------------ | ------------------------------------------- |
 | 「根据 www.example.com 官网生成 Google 搜索广告」 | **W3 · 本文件标准流水线**                                                                        | 只输出一张手写关键词/RSA 表；走 P8 网站诊断 |
+| 「按这份 Excel / 投放方案创建广告」               | **方案源轨**（下表）+ **必读** `rules/google-ads-plan-source-fidelity.md`                          | 猜 geo id；关键词一律 BROAD；跳过 validate  |
 | 「要表格格式 / 表格给我」                         | 先 JSON → `campaign-validate` → 再按 `google-ads-launch-plan-template.md` **投影 Markdown 表格** | 跳过 JSON 直接填表；把表格当唯一交付物      |
 | 「帮我写搜索广告文案/关键词」且未指定已有系列     | **W3**（含官网/RAG 归纳背景）                                                                    | 与 W5 纯拓词混淆（W5 无系列/组/RSA 结构）   |
 | 「分析这个网站能不能投广告」                      | **P8** 网站诊断                                                                                  | 本文件建户方案                              |
@@ -17,18 +18,22 @@
 
 ---
 
-| 轨           | 条件                                     | 动作                                                                     |
-| ------------ | ---------------------------------------- | ------------------------------------------------------------------------ |
-| **直读直写** | 用户已给账户/预算/组/词/RSA 等结构化数据 | 通过代码转换为 campaign-create直接可用的 JSON → validate → 确认 → create |
-| **方案先行** | 无完整结构，或要求「先出方案」           | 读本文件 + 必读规则 → 生成 JSON → validate → Markdown → 确认 → create    |
+| 轨             | 条件                                                              | 动作                                                                                                                                      |
+| -------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
+| **方案源轨**   | 用户已给 Excel/表格/结构化投放方案（含地域、词、匹配类型等）      | **先 Read** `rules/google-ads-plan-source-fidelity.md` → 抽取 `plan-extract.json` → **`ad geo resolve`** → `assemble-campaign-from-plan.mjs` → validate → 确认 → create |
+| **直读直写**   | 用户已给账户/预算/组/词/RSA 等结构化数据（非文件，或已是 JSON）    | 通过代码转换为 campaign-create 直接可用的 JSON → validate → 确认 → create                                                                   |
+| **方案先行**   | 无完整结构，或要求「先出方案」                                    | 读本文件 + 必读规则 → 生成 JSON → validate → Markdown → 确认 → create                                                                     |
 
 **硬约束**
 
 - 可执行真相只有 **JSON**（`assets/campaign-create-template.json` 同构）；Markdown 只读投影。
 - **Agent Read 顺序（建系列前必做）**：① `assets/campaign-create-template.json`（复制/改写的结构真相源）→ ② `assets/campaign-create-template.md`（字段说明与踩坑）。**禁止**只读 `.md` 凭印象拼 JSON。
-- 改需求 **只改 JSON**，再 `campaign-validate`，再刷新 Markdown。
+- **方案文件（Excel 等）额外必读**：`references/google-ads/rules/google-ads-plan-source-fidelity.md`（**三步**：plan-extract → `ad geo resolve` → assemble 脚本；禁止对话手填完整 campaign JSON）。
+- 改需求 **只改中间件/脚本再组装**，再 `campaign-validate`，再刷新 Markdown。
 - **PMax 系列创建**走独立流水线（勿用本文件 JSON 模板）：**先 Read `assets/pmax-create-template.json`** + `assets/pmax-create-template.md` + `ad pmax-validate` / `ad pmax-create`；**Lead Gen/B2B 方案默认含 `campaignExtensions.leadForm`**（方案 Markdown 须单列表单）；运营诊断见 `references/google-ads/rules/google-ads-pmax-guide.md`。
 - 搜索网络：仅 Google 搜索（`TargetSearchNetwork`/`TargetContentNetwork`/`TargetPartnerSearchNetwork` 均为 false）。
+- **地域 id**：多国用 **`ad geo resolve`**（单国可用 `ad geo search`）；**禁止**编造 / ISO 心算。外层 `locations` 与 `targetedLocations` 数量必须一致（validate 硬校验）。
+- **匹配类型**：在 `plan-extract.json` 的每条 keyword 上带 `matchType`，由组装脚本分块写入 EXACT/PHRASE/BROAD（有方案源时勿压成一律 BROAD）。
 
 ---
 
@@ -36,16 +41,18 @@
 
 | 步  | 动作                                                                                                                                                                 | 文档/命令                                                                         |
 | --- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
+| 0   | **方案源轨**：抽取脚本 → `plan-extract.json` → **`ad geo resolve --json-out`** → `assemble-campaign-from-plan.mjs` → `campaign.json`（**勿**对话手填） | **`rules/google-ads-plan-source-fidelity.md`** + `assets/plan-extract.example.json` |
 | 1   | `list-accounts` 锁定 `account` / `customerName` / 币种                                                                                                               | `references/accounts/currency.md`                                                 |
-| 2   | 可选 `rag query`；`keyword` / `keyword geo-list` 拓词                                                                                                                | `references/analytics/keyword-planner-workflows.md`                               |
-| 3   | 按分层规则写入 `KeywordsForBatchJob`（Exact/Phrase/Broad）；**否词单独写** `NegativeKeywordsForBatchJob`（勿与正向词混放）                                           | `references/google-ads/rules/google-ads-keyword-taxonomy.md`（参考，非 CLI 强制） |
-| 4   | 复制 `campaign-create-template.json` 并填 `campaign`（预算/出价/地域/否词≥20/RSA/附加信息）                                                                          | **`assets/campaign-create-template.json`** + `assets/campaign-create-template.md` |
-| 5   | **`ad campaign-validate --config-file <json>`**（失败只改 JSON；超长见下文「超长人工确认」）                                                                         | 下文「校验」                                                                      |
-| 6   | 输出：**JSON 代码块** → **Markdown**（`google-ads-launch-plan-template.md` 正文）→ 待确认                                                                            | —                                                                                 |
-| 7   | 用户确认后 **`ad campaign-create`**                                                                                                                                  | `references/google-ads/google-ads.md`                                             |
-| 8   | 每隔5s 获取创建结果                                                                                                                                                  | `ad batch get --id <taskId> --config-file ./campaign.json`                        |
-| 9   | 成功或部分成功后 **`ad batch diff`** 对照 JSON 与账户实况                                                                                                              |                                                                                   |
-| 10  | **自动补建缺失项**（见下文「batch diff 后自动补建」）：附加信息（Sitelink/Callout 等）**直接**执行 `ad extension *`；组/词/RSA 用对应 create 命令。**勿**仅汇报失败并反问用户是否补建 | `references/google-ads/google-ads.md` § batch diff 后自动补建                     |
+| 2   | 可选 `rag query`；无现成词表时再 `keyword` / `keyword geo-list` 拓词                                                                                                  | `references/analytics/keyword-planner-workflows.md`                               |
+| 3   | 无方案文件时：多国 **`ad geo resolve`**（或单国 `ad geo search`）写入 `locations` + `targetedLocations`                                                              | **禁止编造 id**                                                                   |
+| 4   | 无方案文件时：按分层写入 `KeywordsForBatchJob`（EXACT/PHRASE/BROAD）；否词进 `NegativeKeywordsForBatchJob`                                                             | 参考 `google-ads-keyword-taxonomy.md`；有方案源则走步骤 0 组装脚本                 |
+| 5   | 复制/组装得到 `campaign-create` JSON                                                                                                                                  | **`assets/campaign-create-template.json`** + assemble 脚本                        |
+| 6   | **`ad campaign-validate --config-file <json>`**（失败改中间件/脚本再组装；超长见下文）                                                                                | 下文「校验」                                                                      |
+| 7   | 给人看：**国家↔id** + **匹配类型条数** + 可选 Markdown 投影；**勿**贴整份 JSON 当主交付                                                                               | `google-ads-launch-plan-template.md`                                              |
+| 8   | 用户确认后 **`ad campaign-create`**                                                                                                                                  | `references/google-ads/google-ads.md`                                             |
+| 9   | 每隔5s 获取创建结果                                                                                                                                                  | `ad batch get --id <taskId> --config-file ./campaign.json`                        |
+| 10  | 成功或部分成功后 **`ad batch diff`** 对照 JSON 与账户实况                                                                                                              |                                                                                   |
+| 11  | **自动补建缺失项**（见下文「batch diff 后自动补建」）：附加信息（Sitelink/Callout 等）**直接**执行 `ad extension *`；组/词/RSA 用对应 create 命令。**勿**仅汇报失败并反问用户是否补建 | `references/google-ads/google-ads.md` § batch diff 后自动补建                     |
 
 多系列：每系列一个 JSON；可选 `campaign-manifest.json`（`role: brand|competitor|generic`）仅作文件组织参考。
 
@@ -57,7 +64,8 @@
 
 | 文档                                                                              | 用途                                                            |
 | --------------------------------------------------------------------------------- | --------------------------------------------------------------- |
-| `references/google-ads/rules/google-ads-keyword-taxonomy.md`                      | 核心/长尾与匹配块**建议**（Agent 参考，CLI 不强制）             |
+| `references/google-ads/rules/google-ads-plan-source-fidelity.md`                  | **有 Excel/表格方案时必读**：地域 geo search、匹配类型分块保真  |
+| `references/google-ads/rules/google-ads-keyword-taxonomy.md`                      | 无方案源时的核心/长尾与匹配块**建议**                           |
 | `references/google-ads/rules/google-ads-compliance.md`                            | 词与文案合规                                                    |
 | `references/google-ads/rules/sensitive-industries.md`                             | 敏感行业（若相关）                                              |
 | `references/google-ads/rules/google-ads-launch-plan-template.md`                  | 用户可见 Markdown 结构与 RSA/否词表                             |
@@ -90,10 +98,11 @@ siluzan-tso ad campaign-validate --config-file ./campaign.json [--json-out ./sna
 siluzan-tso ad campaign-create --config-file ./campaign.json
 siluzan-tso ad batch get --id <taskId> --config-file ./campaign.json
 siluzan-tso ad batch diff --batch-id <taskId> --config-file ./campaign.json
-siluzan-tso ad geo search
+siluzan-tso ad geo resolve -a <accountId> --from-file ./locations.json --json-out ./snap-geo
+siluzan-tso ad geo search -a <accountId> -q "United States"
 ```
 
-validate 与 create **共用** `runCampaignCreateValidation`：词面规范化 + 后端/Google 硬约束（预算、RSA、匹配符号与 `MatchTypeV2` 对齐、搜索网络等）。**不含**关键词分层数量、匹配占比、否词条数下限。
+validate 与 create **共用** `runCampaignCreateValidation`：词面规范化 + 后端/Google 硬约束（预算、RSA、匹配符号与 `MatchTypeV2` 对齐、搜索网络、`locations`/`targetedLocations` 数量一致等）。**不含**关键词分层数量建议、否词条数下限（策略表仍见 taxonomy）。
 
 ### 超长内容：禁止 Agent 自动截断
 

package/dist/skill/references/google-ads/google-ads.md

@@ -37,7 +37,7 @@
 | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | 模板         | 复制 `assets/pmax-create-template.json`，字段见 `assets/pmax-create-template.md`                                                                                                                                   |
 | **素材转换** | `siluzan-tso ad pmax-image-convert --input ./banner.jpg --output-dir ./assets --prefix <name> [--update-config ./pmax.json]`                                                                                       |
-| 地理 ID      | `siluzan-tso ad geo search -a <accountId> -q "<地区名>"`                                                                                                                                                           |
+| 地理 ID      | 多国：`ad geo resolve -a <accountId> --from-file ./locations.json --json-out ./snap-geo`；单国：`ad geo search -a <accountId> -q "<地区名>"`                                                                         |
 | 校验         | `siluzan-tso ad pmax-validate --config-file ./pmax.json [--json-out ./snap-pmax]`（图片规格 + 文案超长 `lengthViolations`；超长勿自动截断，见 `references/google-ads/google-ads-campaign-plan.md` § 超长人工确认） |
 | 创建         | `siluzan-tso ad pmax-create --config-file ./pmax.json [--json-out ./snap-pmax]`                                                                                                                                    |
 | 复核         | `siluzan-tso ad campaigns -a <accountId> --json-out ./snap` → `channelTypeV2` 为 `PERFORMANCE_MAX`                                                                                                                 |
@@ -606,9 +606,13 @@ siluzan-tso ad search-terms -a <accountId> [--start/--end YYYY-MM-DD] [--json-ou
 ## ad geo — 地理位置定向管理
 
 ```bash
-# 搜索 locationId
+# 搜索 locationId（单国）
 siluzan-tso ad geo search -a <accountId> -q <地名>
 
+# 批量解析地名→id（投放方案多国；落盘含 locations / targetedLocations / nameToId）
+siluzan-tso ad geo resolve -a <accountId> --from-file ./locations.json --json-out ./snap-geo
+siluzan-tso ad geo resolve -a <accountId> -q "Peru,Chile,Kenya" --json-out ./snap-geo
+
 # 查询已定向
 siluzan-tso ad geo list -a <accountId> --mode targeted|excluded|report [--start/--end <date>]
 

package/dist/skill/references/google-ads/rules/README.md

@@ -9,6 +9,7 @@
 | `google-ads-keyword-strategy.md`                    | 关键词策略规划                                         |
 | `google-ads-keyword-optimization.md`                | 关键词出价/否定/扩词优化                               |
 | `google-ads-keyword-taxonomy.md`                    | 词类分层与命名                                         |
+| `google-ads-plan-source-fidelity.md`                | **Excel/表格方案 → JSON**：地域 geo search、匹配类型保真（有方案文件时必读） |
 | `google-ads-creative-optimization.md`               | 创意/文案优化                                          |
 | `google-ads-audience-strategy.md`                   | 受众策略                                               |
 | `google-ads-pmax-guide.md`                          | PMax 运营指南（配合 `assets/pmax-create-template.md`） |

package/dist/skill/references/google-ads/rules/google-ads-launch-plan-template.md

@@ -40,7 +40,7 @@
 | 系列名称               | `name`（外层展示用） / `campaign.Name`（内层）                                                                                      |
 | 日预算                 | `campaign.Budget`（**元**，CLI 内部 ×100 转分）                                                                                     |
 | 出价策略 / 上限 / tCPA | `campaign.BiddingStrategyTypeV2`、`campaign.TargetSpend_BidCeilingAmount`、`campaign.TargetCpa_BidingAmount`、`campaign.TargetRoas` |
-| 投放地域               | `campaign.targetedLocations: [{ id: "<geoId>" }]`（先 `ad geo search` 取 id）、外层 `locations`（展示名，可选）                     |
+| 投放地域               | `campaign.targetedLocations: [{ id: "<geoId>" }]`（**必须**先 `ad geo search` 取 id，禁止编造）、外层 `locations`（与 targetedLocations 同序同量） |
 | 语言                   | `campaign.targetedLanguages: [{ id: 1000 }]`（英语 1000 / 中文 1017）                                                               |
 | 起止日期               | `campaign.StartTime`、`campaign.EndTime`（YYYY-MM-DD）                                                                              |
 | 落地页                 | 外层 `url`；广告组级 `KeywordsForBatchJob[].FinalURL`、创意级 `AdsForBatchJob[].Finalurl`                                           |
@@ -51,7 +51,8 @@
 | 仅保存草稿             | `draft: true` → 确认后 `ad batch publish`                                                                                           |
 | 立即创建               | `draft: false`（默认）                                                                                                              |
 
-关键词匹配（在 `KeywordsForBatchJob` 块中以 `MatchTypeV2` 区分；同一块同匹配类型）：`词`→广泛、`"词"`→词组、`[词]`→完全。
+关键词匹配（在 `KeywordsForBatchJob` 块中以 `MatchTypeV2` 区分；同一块同匹配类型）：`词`→广泛、`"词"`→词组、`[词]`→完全。  
+从 Excel/表格方案导入时须保真匹配类型与地域 id，见 `google-ads-plan-source-fidelity.md`。
 
 ---
 

package/dist/skill/references/google-ads/rules/google-ads-plan-source-fidelity.md

@@ -0,0 +1,131 @@
+# 方案源 → campaign-create：Agent 最短稳妥路径
+
+> **设计原则（按智能体真实能力）**：少靠对话纪律，多靠 **落盘中间件 + CLI + 脚本**。LLM 只做「认列」和「写抽取脚本」；**匹配类型与 geo id 一律由代码/CLI 决定**，禁止在对话里手填。
+>
+> Excel 版式不固定 → **不**做通用 Excel 解析器；固定的是中间清单 `plan-extract.json` 的形状。
+
+---
+
+## 为什么不能「读 Excel → 直接写 campaign.json」
+
+| 易错点 | 对话里手填时会发生什么 | 稳妥做法 |
+| ------ | ---------------------- | -------- |
+| 30 国 geo id | 编造 / 记错 / CriterionError | **一次** `ad geo resolve` |
+| Exact/Phrase | 图省事全写成 BROAD | 抽取时带上 `matchType`，组装脚本分块 |
+| 大 JSON | 上下文截断、漏字段 | 脚本写文件，Agent 只读 validate 摘要 |
+| 版式差异 | 猜 Sheet 名失败就瞎补 | 只写「本文件专用」抽取脚本，输出固定中间件 |
+
+---
+
+## 三步闭环（推荐，最快且最稳）
+
+```text
+Excel/表格 ──① 抽取脚本──► plan-extract.json
+                              │
+                              ├─ locations[] ──② ad geo resolve --json-out──► geo-map.json
+                              │
+                              └─ + geo-map + 账户 ──③ 组装脚本──► campaign.json
+                                                                      │
+                                                         ad campaign-validate
+                                                                      │
+                                                         用户确认摘要 → campaign-create
+```
+
+Agent **对话内只做**：认列写①③脚本、跑 CLI、把 validate 错误修回脚本/中间件、给用户看「国家↔id + 匹配类型计数」。
+
+---
+
+### ① 抽取 → `plan-extract.json`（唯一允许「认版式」的一步）
+
+复制形状：`assets/plan-extract.example.json`。
+
+用 **Python openpyxl / Node** 读**全部 Sheet**，只输出中间件，**不要**在这一步写 `targetedLocations` id，**不要**写最终 campaign JSON。
+
+关键词行必须带匹配类型（列优先，否则看词面 `[ ]` / `" "`）：
+
+```json
+{ "text": "compactor garbage truck for sale", "matchType": "EXACT" }
+```
+
+`matchType` ∈ `EXACT` | `PHRASE` | `BROAD`。组装脚本再加 `[]` / `""`。
+
+### ② 批量地域 → `geo-map.json`（禁止逐国 search、禁止编造）
+
+```bash
+# 从中间件抽出 locations 数组文件，或直接 --queries
+siluzan-tso ad geo resolve -a <mediaCustomerId> \
+  --from-file ./locations.json \
+  --json-out ./snap-geo
+```
+
+落盘 payload 已含可直写字段：
+
+- `locations` / `targetedLocations` / `nameToId`
+
+任一地名失败 → CLI **exit 1**（改拼写重跑；**禁止**跳过或心算 id）。
+
+### ③ 组装 → `campaign.json`（纯代码，零 LLM 填 id/匹配类型）
+
+推荐直接跑 Skill 自带脚手架（按中间件 + geo-map 填模板）：
+
+```bash
+node <skill>/assets/scripts/assemble-campaign-from-plan.mjs \
+  --plan ./plan-extract.json \
+  --geo ./snap-geo/ad-geo-resolve-<account>.json \
+  --template <skill>/assets/campaign-create-template.json \
+  --out ./campaign.json
+```
+
+脚本职责（Agent 勿手改输出里的这两块）：
+
+- 拷贝 `locations` + `targetedLocations`（来自 geo-map，同序）
+- 按广告组把 keywords **分块**为 EXACT / PHRASE / BROAD `KeywordsForBatchJob`
+- 否词 → `NegativeKeywordsForBatchJob`；RSA / Extensions 从中间件映射
+
+然后：
+
+```bash
+siluzan-tso ad campaign-validate --config-file ./campaign.json --json-out ./snap-campaign
+```
+
+确认摘要（给用户，勿贴整份 JSON）：
+
+1. 国家名 → id（来自 geo-map `rows`）
+2. Exact / Phrase / Broad **条数**（来自 plan-extract 统计，须与 validate 后一致）
+3. 预算 / 组数 / 否词数
+
+用户确认 → `ad campaign-create` → `batch get` / `batch diff`。
+
+---
+
+## CLI 硬门禁（第二道保险）
+
+| 条件 | `campaign-validate` |
+| ---- | ------------------- |
+| `locations.length ≠ targetedLocations.length` | error |
+| location id 非数字 | error |
+
+匹配类型保真靠中间件 `matchType` + 组装脚本，不靠 CLI 禁止「全 BROAD」。
+
+---
+
+## Agent 禁令（高优先级）
+
+1. **禁止**在对话里手写 / 粘贴完整 `campaign.json`（用脚本 `--out`）。
+2. **禁止**对 30 国循环口述 `ad geo search`；用 **`ad geo resolve`**。
+3. **禁止**编造 geo id（含 ISO、`2000+ISO` 心算）。
+4. **禁止**把方案里的 Exact/Phrase 压成一律 BROAD。
+5. **禁止**跳过 `plan-extract.json` 直接从 Excel「脑补」进 create。
+
+---
+
+## 与其它文档的关系
+
+| 文档 | 何时 |
+| ---- | ---- |
+| 本文件 | 有 Excel/表格方案 → 创建 |
+| `google-ads-campaign-plan.md` | W3 总流程；方案源轨指向本文件 |
+| `assets/campaign-create-template.json` | 组装目标结构（先 Read） |
+| `google-ads-launch-plan-template.md` | 可选：validate 后投影 Markdown 给人看 |
+
+无方案文件、从零出方案时：仍走 campaign-plan「方案先行」；地域仍优先 `ad geo resolve`（多国）或单次 `ad geo search`（单国）。

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.37-beta.4'
+$PKG_VERSION = '1.1.37-beta.5'
 $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.37-beta.4"
+readonly PKG_VERSION="1.1.37-beta.5"
 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.37-beta.4",
+  "version": "1.1.37-beta.5",
   "description": "Siluzan 广告账户管理 CLI — 查询账户、余额、消耗数据，管理绑定关系与充值。",
   "keywords": [
     "ad-account",