tt-help-cli-ycl 1.4.2 → 1.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {

package/src/cli/tag.js

@@ -1,5 +1,7 @@
 import { writeFileSync } from "fs";
 import { randomUUID } from "crypto";
+import { execSync } from "child_process";
+import os from "os";
 import readline from "readline";
 import { fetchTagData, enrichVideosWithLocation } from "../lib/tag-fetcher.js";
 import { killEdgeProcesses, ensureBrowserReady } from "../lib/browser/cdp.js";
@@ -42,6 +44,46 @@ function formatMemoryUsage(mem = process.memoryUsage()) {
   return `rss:${(mem.rss / 1024 / 1024).toFixed(0)}MB heap:${(mem.heapUsed / 1024 / 1024).toFixed(0)}MB ext:${(mem.external / 1024 / 1024).toFixed(0)}MB ab:${(mem.arrayBuffers / 1024 / 1024).toFixed(0)}MB`;
 }
 
+/**
+ * 获取 Edge 浏览器进程的内存占用（macOS/Linux）
+ */
+function getBrowserMemory(port = null) {
+  try {
+    const platform = os.platform();
+    let cmd;
+    if (platform === "darwin") {
+      // 按端口筛选：匹配 --remote-debugging-port=PORT 的进程
+      if (port) {
+        cmd = `ps aux | grep "[M]icrosoft Edge" | grep "remote-debugging-port=${port}" | awk '{sum += $6} END {printf "%d", sum/1024}'`;
+      } else {
+        cmd =
+          'ps aux | grep "[M]icrosoft Edge" | awk \'{sum += $6} END {printf "%d", sum/1024}\'';
+      }
+    } else if (platform === "linux") {
+      if (port) {
+        cmd = `ps aux | grep "[m]sedge" | grep "remote-debugging-port=${port}" | awk '{sum += $6} END {printf "%d", sum/1024}'`;
+      } else {
+        cmd =
+          'ps aux | grep "[m]sedge" | awk \'{sum += $6} END {printf "%d", sum/1024}\'';
+      }
+    } else {
+      return null;
+    }
+    const result = execSync(cmd, { timeout: 3000 }).toString().trim();
+    const mb = parseInt(result, 10);
+    return mb > 0 ? mb : null;
+  } catch {
+    return null;
+  }
+}
+
+function formatMemoryWithBrowser(port = null) {
+  const nodeMem = formatMemoryUsage();
+  const browserMB = getBrowserMemory(port);
+  const portLabel = port ? `:${port}` : "";
+  return browserMB ? `${nodeMem} edge${portLabel}:${browserMB}MB` : nodeMem;
+}
+
 // 构建带客户端追踪 header 的 fetch 封装
 function buildClientHeaders(clientId, meta, extra = {}) {
   return {
@@ -576,13 +618,7 @@ async function reportToServer(baseUrl, result, clientId, meta) {
 
 export async function handleScoreAll(parsed) {
   const { tagScoreAll } = parsed;
-  let {
-    countries,
-    serverUrl,
-    autoDiscover,
-    port,
-    proxy: cliProxy,
-  } = tagScoreAll || {};
+  let { countries, serverUrl, port, proxy: cliProxy } = tagScoreAll || {};
 
   const baseUrl = serverUrl || DEFAULT_SERVER;
   const defaultScoreAllPort =
@@ -603,10 +639,14 @@ export async function handleScoreAll(parsed) {
       cdpPort +
       (effectiveProxy ? "  代理: " + effectiveProxy : ""),
   );
-  if (autoDiscover) log("║  自动发现: 开启");
+  log("║  发现: 服务端定时自动（无需 --auto-discover）");
   log("╚══════════════════════════════════════════╝");
   log("");
 
+  // 启动时显示内存状态
+  log(`📊 启动内存: ${formatMemoryWithBrowser(cdpPort)}`);
+  log("");
+
   // 连接 CDP 浏览器
   const cdpOpts = { port: cdpPort };
   if (effectiveProxy) cdpOpts.proxyServer = effectiveProxy;
@@ -635,8 +675,6 @@ export async function handleScoreAll(parsed) {
     2,
     parseInt(process.env.TAG_SCOREALL_PORT_POOL_SIZE || "10", 10) || 10,
   );
-  const switchPortOnRecycle =
-    String(process.env.TAG_SCOREALL_SWITCH_PORT_ON_RECYCLE || "1") !== "0";
 
   function pickNextPort(currentPort) {
     const candidates = [];
@@ -648,26 +686,35 @@ export async function handleScoreAll(parsed) {
     return candidates[Math.floor(Math.random() * candidates.length)];
   }
 
-  const memRssRecycleMb = Math.max(
-    256,
-    parseInt(process.env.TAG_SCOREALL_RECYCLE_RSS_MB || "900", 10) || 900,
-  );
-  const memHeapRecycleMb = Math.max(
-    128,
-    parseInt(process.env.TAG_SCOREALL_RECYCLE_HEAP_MB || "512", 10) || 512,
-  );
-  const recycleCooldownMs = Math.max(
-    0,
-    parseInt(process.env.TAG_SCOREALL_RECYCLE_COOLDOWN_MS || "180000", 10) ||
-      180000,
-  );
-  // 默认关闭按固定轮次重建，仅在高内存时触发；需要可通过环境变量开启。
-  const periodicRecycleEvery = Math.max(
-    0,
-    parseInt(process.env.TAG_SCOREALL_PERIODIC_RECYCLE_EVERY || "0", 10) || 0,
-  );
+  // ── 内存回收配置 ──
+  const RECYCLE_CONFIG = {
+    nodeRssMb: Math.max(
+      256,
+      parseInt(process.env.TAG_SCOREALL_RECYCLE_RSS_MB || "900", 10) || 900,
+    ),
+    nodeHeapMb: Math.max(
+      128,
+      parseInt(process.env.TAG_SCOREALL_RECYCLE_HEAP_MB || "512", 10) || 512,
+    ),
+    edgeMb: Math.max(
+      500,
+      parseInt(process.env.TAG_SCOREALL_RECYCLE_EDGE_MB || "2000", 10) || 2000,
+    ),
+    cooldownMs: Math.max(
+      0,
+      parseInt(process.env.TAG_SCOREALL_RECYCLE_COOLDOWN_MS || "180000", 10) ||
+        180000,
+    ),
+    periodicEvery: Math.max(
+      0,
+      parseInt(process.env.TAG_SCOREALL_PERIODIC_RECYCLE_EVERY || "0", 10) || 0,
+    ),
+    switchPortOnRecycle:
+      String(process.env.TAG_SCOREALL_SWITCH_PORT_ON_RECYCLE || "1") !== "0",
+  };
   let lastRecycleAt = 0;
 
+  // ── 轻量回收：只清空当前 tab ──
   async function recyclePage() {
     if (!page || page.isClosed()) {
       page = await getOrCreatePage(browser);
@@ -680,23 +727,24 @@ export async function handleScoreAll(parsed) {
         timeout: 5000,
       });
     } catch {
-      // 页面状态异常时回退到重建 tab
       await page.close().catch(() => {});
       page = await getOrCreatePage(browser);
       await setupPageRequestBlocking(page);
     }
   }
 
+  // ── 深度回收：关闭浏览器 + 可选切换端口 ──
   async function recycleCdpSession(reason, { switchPort = true } = {}) {
     const oldPort = cdpPort;
-    if (switchPort && switchPortOnRecycle) {
+    const shouldSwitch = switchPort && RECYCLE_CONFIG.switchPortOnRecycle;
+    if (shouldSwitch) {
       cdpPort = pickNextPort(cdpPort);
       cdpOpts.port = cdpPort;
       clientMeta.port = cdpPort;
     }
-    const switchHint =
-      oldPort === cdpPort ? `port=${cdpPort}` : `port ${oldPort} -> ${cdpPort}`;
-    log(`  ♻️ 重建 CDP 会话 (${reason}; ${switchHint})...`);
+    const portHint =
+      oldPort === cdpPort ? `port=${cdpPort}` : `port ${oldPort}→${cdpPort}`;
+    log(`  ♻️ 重建 CDP 会话 (${reason}; ${portHint})...`);
     if (page) {
       await page.close().catch(() => {});
       page = null;
@@ -711,34 +759,57 @@ export async function handleScoreAll(parsed) {
     lastRecycleAt = Date.now();
   }
 
+  // ── 内存检查 + 自动回收 ──
+  // 策略：Node.js 内存超阈值 → 不换端口（只重建连接）
+  //        Edge 内存超阈值 → 换端口（杀旧浏览器 + 启新实例，彻底释放）
+  //        定期轮次         → 不换端口
   async function maybeRecycleForMemory() {
     const mem = process.memoryUsage();
     const rssMB = mem.rss / 1024 / 1024;
     const heapMB = mem.heapUsed / 1024 / 1024;
-    if (rssMB >= memRssRecycleMb || heapMB >= memHeapRecycleMb) {
-      const now = Date.now();
-      if (recycleCooldownMs > 0 && now - lastRecycleAt < recycleCooldownMs) {
+    const edgeMB = getBrowserMemory(cdpPort);
+
+    const nodeOver =
+      rssMB >= RECYCLE_CONFIG.nodeRssMb || heapMB >= RECYCLE_CONFIG.nodeHeapMb;
+    const edgeOver = edgeMB !== null && edgeMB >= RECYCLE_CONFIG.edgeMb;
+
+    if (nodeOver || edgeOver) {
+      // 冷却期内跳过
+      if (
+        RECYCLE_CONFIG.cooldownMs > 0 &&
+        Date.now() - lastRecycleAt < RECYCLE_CONFIG.cooldownMs
+      )
         return;
-      }
-      await recycleCdpSession(
-        `mem rss=${rssMB.toFixed(0)}MB heap=${heapMB.toFixed(0)}MB (threshold rss=${memRssRecycleMb} heap=${memHeapRecycleMb})`,
-        { switchPort: false },
-      );
+
+      const parts = [];
+      if (rssMB >= RECYCLE_CONFIG.nodeRssMb)
+        parts.push(`rss=${rssMB.toFixed(0)}≥${RECYCLE_CONFIG.nodeRssMb}`);
+      if (heapMB >= RECYCLE_CONFIG.nodeHeapMb)
+        parts.push(`heap=${heapMB.toFixed(0)}≥${RECYCLE_CONFIG.nodeHeapMb}`);
+      if (edgeOver)
+        parts.push(`edge:${cdpPort}=${edgeMB}≥${RECYCLE_CONFIG.edgeMb}`);
+
+      await recycleCdpSession(`mem ${parts.join("+")}`, {
+        switchPort: edgeOver,
+      });
       return;
     }
+
+    // 定期轮次回收（默认关闭）
     if (
-      periodicRecycleEvery > 0 &&
+      RECYCLE_CONFIG.periodicEvery > 0 &&
       totalScored > 0 &&
-      totalScored % periodicRecycleEvery === 0
+      totalScored % RECYCLE_CONFIG.periodicEvery === 0
     ) {
-      await recycleCdpSession(`periodic every ${totalScored} tasks`, { switchPort: false });
+      await recycleCdpSession(`periodic #${totalScored}`, {
+        switchPort: false,
+      });
     }
   }
 
   let totalScored = 0;
   let emptyRounds = 0; // 连续无任务的轮数
   let consecutive403 = 0; // 连续 HTTP 403 次数，达 3 次认为被封
-  const DISCOVER_AFTER_EMPTY = 3; // 连续 3 轮无任务时触发 discover
   const CONSECUTIVE_403_BLOCKED = 3; // 连续 3 次 403 认为账号被封
 
   // 生成客户端 ID，用于服务端追踪
@@ -767,36 +838,22 @@ export async function handleScoreAll(parsed) {
   try {
     while (true) {
       try {
-        // 从服务端取下一个 new 标签
+        // 从服务端取下一个 new 标签（同时查剩余数量）
         const tagsRes = await fetch(`${baseUrl}/api/tags?status=new&limit=1`, {
           headers: buildClientHeaders(clientId, clientMeta),
         });
         const tagsData = await tagsRes.json();
+
         if (!tagsData.tags || tagsData.tags.length === 0) {
           emptyRounds++;
 
-          // 自动发现：连续 N 轮无任务时自动生成标签
-          if (autoDiscover && emptyRounds >= DISCOVER_AFTER_EMPTY) {
+          // 服务端定时发现会自动补充标签，客户端只需等待
+          if (emptyRounds >= 5) {
             log(
-              `🔍 连续 ${emptyRounds} 轮无待打分标签，自动为 ${targetCountries.length} 个国家生成标签...`,
+              `⏳ 连续 ${emptyRounds} 轮无标签，等待服务端发现补充（30 秒后重试）...`,
             );
-            for (const country of targetCountries) {
-              try {
-                const discRes = await fetch(
-                  `${baseUrl}/api/tags/discover?country=${country}&count=5`,
-                  { headers: buildClientHeaders(clientId, clientMeta) },
-                );
-                const discData = await discRes.json();
-                if (discData.inserted) {
-                  log(`  ${country}: 新增 ${discData.inserted} 个`);
-                }
-              } catch (e) {
-                log(`  ${country}: 请求失败 (${e.message})`);
-              }
-            }
-            emptyRounds = 0; // 重置计数器
-            // 等 3 秒让服务端处理完
-            await new Promise((r) => setTimeout(r, 3000));
+            await new Promise((r) => setTimeout(r, 30000));
+            emptyRounds = 0;
             continue;
           }
           log(`⏳ 暂无待打分标签（连续 ${emptyRounds} 轮），10 秒后重试...`);
@@ -875,7 +932,7 @@ export async function handleScoreAll(parsed) {
         if (!videos || videos.length === 0) {
           const deadSec = ((Date.now() - fetchStart) / 1000).toFixed(1);
           log(
-            `  ⚠️ 无视频 (${deadSec}s) mem=${formatMemoryUsage()}，标记 dead`,
+            `  ⚠️ 无视频 (${deadSec}s) mem=${formatMemoryWithBrowser(cdpPort)}，标记 dead`,
           );
           result.status = "dead";
           result.error = "no videos found";
@@ -953,12 +1010,18 @@ export async function handleScoreAll(parsed) {
         const mc = result.matchedCountries
           .map((c) => `${c.c}:${c.n}`)
           .join(" ");
-        const memStr = ` mem=${formatMemoryUsage()}`;
+        const memStr = ` mem=${formatMemoryWithBrowser(cdpPort)}`;
         log(
           `  ${icon} ${result.status} score=${result.score} authors=${result.authorCount} matched=${result.matchedAuthors} (${elapsed}s)${mc ? "  " + mc : ""}${memStr}`,
         );
         log("");
         consecutive403 = 0; // 成功完成，重置 403 计数器
+        // 每 10 个标签输出一次内存汇总
+        if (totalScored % 10 === 0) {
+          log(
+            `📊 [${totalScored}] 内存汇总: ${formatMemoryWithBrowser(cdpPort)}`,
+          );
+        }
         await recyclePage();
         await maybeRecycleForMemory();
         await randomDelay(3000, 7000);

package/src/lib/args.js

@@ -735,7 +735,6 @@ function parseTagArgs(args) {
   let discoverCountries = [];
   let discoverCount = 4;
   let discoverPrompt = null;
-  let autoDiscover = false;
   let isDiscover = false;
   let isScore = false;
   let isScoreAll = false;
@@ -779,8 +778,6 @@ function parseTagArgs(args) {
       }
     } else if (arg === "--count") {
       discoverCount = parseInt(args[++i]) || 4;
-    } else if (arg === "--auto-discover") {
-      autoDiscover = true;
     } else if (arg === "--countries") {
       scoreCountries = args[++i]
         .split(",")
@@ -878,7 +875,6 @@ function parseTagArgs(args) {
       tagScoreAll: {
         countries: scoreCountries,
         serverUrl,
-        autoDiscover,
         port: scoreAllPort,
         proxy: scoreProxy,
       },

package/src/lib/constants.js

@@ -261,7 +261,8 @@ const HELP_TEXT = [
   "      --countries <CSV>         目标国家，逗号分隔（默认 13 个欧洲国家）",
   "      -s, --server <URL>        服务端地址（默认 http://127.0.0.1:3000）",
   "      --port <N>                起始 CDP 端口，端口池默认为 N~N+9（默认 7222）",
-  "      --discover                开启自动发现：连续 3 轮无新标签时自动生成",
+  "      --discover                开启自动发现：剩余 new 标签 < 5 时后台异步生成，连续 3 轮空兜底",
+  "      --discover-count <N>      每次发现每个国家生成标签数（默认 10，上限 20）",
   "    行为:",
   "      连续 3 次 HTTP 403 → 判断账号被封 → 等 2 分钟后自动切换到池中另一端口",
   "    环境变量:",

package/src/lib/tag-discover.js

@@ -3,6 +3,7 @@
  *
  * 使用 tag-service 的公共函数（LLM 调用、prompt 组装、解析）。
  * 历史 tag 数据通过 API 从服务端获取，不再读写 productive-tags.json。
+ * 自闭环：从服务端获取健康数据 → 自动 niche 切换 → 动态温度调整
  */
 import {
   COUNTRY_LANG,
@@ -10,7 +11,9 @@ import {
   callLLM,
   normalizeTag,
   parseTagsFromResponse,
+  parseDiscoverResponse,
   buildDiscoverPrompt,
+  reflectAndLearn,
 } from "../watch/tag-service.js";
 
 const DEFAULT_SERVER = "http://127.0.0.1:3000";
@@ -52,7 +55,87 @@ async function fetchTagHistory(serverUrl, country) {
 }
 
 /**
- * 为单个国家生成 tag（CLI 模式，通过 API 获取历史数据）
+ * 从服务端获取某国的 tag 健康指标
+ */
+async function fetchCountryHealth(serverUrl, country) {
+  const baseUrl = serverUrl || DEFAULT_SERVER;
+  try {
+    const res = await fetch(`${baseUrl}/api/tags/health?country=${country}`);
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 从服务端触发数据清理（自闭环）
+ */
+async function triggerCleanup(serverUrl, actions = {}) {
+  const baseUrl = serverUrl || DEFAULT_SERVER;
+  try {
+    const res = await fetch(`${baseUrl}/api/tags/cleanup`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(actions),
+    });
+    if (!res.ok) return {};
+    return await res.json();
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * 从服务端获取某国的活跃反思规则
+ */
+async function fetchActiveRules(serverUrl, country) {
+  const baseUrl = serverUrl || DEFAULT_SERVER;
+  try {
+    const res = await fetch(`${baseUrl}/api/tags/rules?country=${country}`);
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.rules || [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 从服务端触发反思（自闭环）
+ */
+async function triggerReflection(serverUrl, country) {
+  const baseUrl = serverUrl || DEFAULT_SERVER;
+  try {
+    const res = await fetch(`${baseUrl}/api/tags/reflect?country=${country}`, {
+      method: "POST",
+    });
+    if (!res.ok) return { reflected: false, error: `HTTP ${res.status}` };
+    return await res.json();
+  } catch (e) {
+    return { reflected: false, error: e.message };
+  }
+}
+
+/**
+ * 从服务端获取最近生成的标签（去重）
+ */
+async function fetchRecentGenerated(serverUrl, country, lookback = 10) {
+  const baseUrl = serverUrl || DEFAULT_SERVER;
+  try {
+    const res = await fetch(
+      `${baseUrl}/api/tags/recent-generated?country=${country}&lookback=${lookback}`,
+    );
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.tags || [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 为单个国家生成 tag（CLI 模式，通过 API 获取历史数据 + 自闭环）
  */
 async function discoverTagsForCountryCli(
   country,
@@ -64,24 +147,112 @@ async function discoverTagsForCountryCli(
     return { country, error: `不支持的国家代码: ${country}` };
   }
 
+  // ====== 自闭环 Step 1: 获取健康数据 ======
+  const health = await fetchCountryHealth(serverUrl, country);
+  let nicheRecommendation = null;
+  let autoNichePrompt = null;
+  let temperature = 0.7;
+
+  if (health) {
+    process.stderr.write(
+      `  🏥 ${country} health: ${health.healthStatus} | deadRatio=${health.deadRatio}% | productiveRatio=${health.productiveRatio}% | saturation=${health.saturation}%\n`,
+    );
+
+    // 动态温度调整
+    if (health.healthStatus === "critical") {
+      temperature = 0.3;
+    } else if (health.healthStatus === "warning") {
+      temperature = 0.5;
+    }
+
+    // 自动 niche 切换
+    nicheRecommendation = health.nicheRecommendation;
+    if (
+      health.healthStatus !== "healthy" &&
+      nicheRecommendation &&
+      nicheRecommendation.uncovered &&
+      nicheRecommendation.uncovered.length > 0
+    ) {
+      const targetNiche = nicheRecommendation.uncovered[0];
+      const nicheDescriptions = {
+        fashion:
+          "clothing, shoes, accessories, vintage fashion, secondhand clothes",
+        food: "bakery, food delivery, local food, restaurant, cooking supplies",
+        handmade_crafts:
+          "handmade items, DIY crafts, ceramics, candles, resin art",
+        home_living:
+          "home decoration, furniture, interior design, cleaning services",
+        electronics_tech:
+          "electronics, gadgets, phones, computers, tech accessories",
+        pets_animals: "pet supplies, dog accessories, cat food, animal care",
+        beauty_health:
+          "beauty products, cosmetics, skincare, hair care, wellness",
+        books_collectibles:
+          "books, collectibles, vinyl records, trading cards, antiques",
+        services_professional:
+          "professional services, repair, cleaning, photography, florist",
+        marketplace_local:
+          "local market, marketplace, shop, boutique, online store",
+      };
+      autoNichePrompt = `Focus on the "${targetNiche.niche}" niche: ${nicheDescriptions[targetNiche.niche] || targetNiche.niche}. We have only ${targetNiche.currentCoverage} productive tags in this category — explore more hashtags in this direction.`;
+      process.stderr.write(
+        `  🎯 ${country} auto niche switch → ${targetNiche.niche} (coverage: ${targetNiche.currentCoverage})\n`,
+      );
+    }
+
+    // 触发服务端数据清理
+    const cleanupActions = {};
+    if (health.lowScored > health.productive * 2) {
+      cleanupActions.lowScoredCleanup = true;
+    }
+    cleanupActions.staleScoringReset = true;
+    cleanupActions.errorReset = true;
+
+    const cleanupResult = await triggerCleanup(serverUrl, cleanupActions);
+    if (cleanupResult && Object.keys(cleanupResult).length > 0) {
+      process.stderr.write(`  🧹 Cleanup: ${JSON.stringify(cleanupResult)}\n`);
+    }
+  }
+
+  // 合并用户 prompt 和自动 niche prompt
+  const effectiveUserPrompt = autoNichePrompt || userPrompt;
+
+  // ====== 原有 discover 流程 ======
   // 从服务端获取历史 tag
   const history = await fetchTagHistory(serverUrl, country);
   const { productive, dead, allExisting: existingSet } = history;
   const existingArr = Array.isArray(existingSet) ? existingSet : [];
 
-  // 使用统一的 prompt 组装（不传 allExisting，由应用层去重）
+  // 获取最近生成的标签（用于检测重复）
+  const recentGenerated = await fetchRecentGenerated(serverUrl, country);
+
+  // ====== 自闭环 Step 4: 获取硬规则（反思产出） ======
+  const hardRules = await fetchActiveRules(serverUrl, country);
+  if (hardRules.length > 0) {
+    process.stderr.write(
+      `  ⛔ ${country} 注入 ${hardRules.length} 条硬规则到 prompt\n`,
+    );
+  }
+
+  // 使用统一的 prompt 组装（加入健康指标、niche 推荐、硬规则）
   const prompt = buildDiscoverPrompt(
     country,
     count,
-    { productive, dead },
-    userPrompt,
+    { productive, dead, recentGenerated },
+    effectiveUserPrompt,
+    null, // pastStrategies（CLI 模式暂不传）
+    health,
+    nicheRecommendation,
+    hardRules,
   );
 
   process.stderr.write(
-    `  [LLM] 正在生成标签 (国家: ${country}, 语言: ${getLang(country)}, 目标: ${count} 个)...\n`,
+    `  [LLM] 正在生成标签 (国家: ${country}, 语言: ${getLang(country)}, 目标: ${count} 个, temp=${temperature}, health=${health?.healthStatus || "unknown"})...\n`,
   );
-  const content = await callLLM(prompt);
-  const tags = parseTagsFromResponse(content);
+  const content = await callLLM(prompt, temperature);
+  const parsed = parseDiscoverResponse(content);
+  const tags = parsed.tags || parseTagsFromResponse(content);
+  const niche = parsed.niche || null;
   // 两阶段筛选：先内部去重，再过滤已存在，最后取 count 个
   const unique = [...new Set(tags)]
     .filter((t) => !existingArr.includes(t))
@@ -90,7 +261,42 @@ async function discoverTagsForCountryCli(
   process.stderr.write(
     `  [LLM] 生成 ${unique.length} 个标签: ${unique.join(", ")}\n`,
   );
-  return unique;
+  if (niche) {
+    process.stderr.write(`  [LLM] niche focus: ${niche}\n`);
+  }
+
+  // ====== 自闭环 Step 5: 反思触发（本轮结束后检查） ======
+  let reflectionResult = null;
+  try {
+    reflectionResult = await triggerReflection(serverUrl, country);
+    if (reflectionResult.reflected) {
+      process.stderr.write(
+        `  🔄 ${country} 反思完成: 新增 ${reflectionResult.rulesAdded} 条规则\n`,
+      );
+    }
+  } catch (e) {
+    process.stderr.write(`  反思异常: ${e.message}\n`);
+    reflectionResult = { reflected: false, error: e.message };
+  }
+
+  return {
+    country,
+    tags: unique,
+    niche,
+    health: health
+      ? {
+          status: health.healthStatus,
+          deadRatio: health.deadRatio,
+          productiveRatio: health.productiveRatio,
+          saturation: health.saturation,
+          issues: health.issues || [],
+        }
+      : null,
+    autoNiche: autoNichePrompt ? nicheRecommendation.uncovered[0].niche : null,
+    temperature,
+    hardRulesInjected: hardRules.length,
+    reflection: reflectionResult,
+  };
 }
 
 /**
@@ -108,13 +314,15 @@ export async function discoverTags(countries, options = {}) {
   const allTags = [];
 
   for (const country of countryList) {
-    const tags = await discoverTagsForCountryCli(
+    const result = await discoverTagsForCountryCli(
       country,
       count,
       userPrompt,
       serverUrl,
     );
-    allTags.push(...tags);
+    if (result.tags) {
+      allTags.push(...result.tags);
+    }
   }
 
   return allTags;