tt-help-cli-ycl 1.4.134 → 1.4.135

package/package.json

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

package/scripts/backup-db.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * SQLite 整库备份（WAL 安全）
+ *
+ * 用法:
+ *   node scripts/backup-db.mjs <源.db> [目标.db]
+ *
+ * 默认目标: <源名>-bak-<时间戳>.db（与源同目录）
+ *
+ * 说明:
+ *   - 非只读打开源 → wal_checkpoint(TRUNCATE) 合并 WAL → 物理 cp 主文件
+ *   - 实测 better-sqlite3 的 backup() / VACUUM INTO 在 WAL 模式下会漏掉
+ *     未合并的表（如 tags），唯有物理 cp 主文件可靠（实验验证）
+ *   - 校验用非只读打开目标（readonly 打开会读出不存在的表，造成假象）
+ *     并专项检查 tags 表
+ */
+import fs from "fs";
+import path from "path";
+import Database from "better-sqlite3";
+
+const src = process.argv[2];
+if (!src) {
+  console.error("用法: node scripts/backup-db.mjs <源.db> [目标.db]");
+  process.exit(1);
+}
+const srcPath = path.resolve(src);
+if (!fs.existsSync(srcPath)) {
+  console.error(`源库不存在: ${srcPath}`);
+  process.exit(1);
+}
+const destPath = path.resolve(
+  process.argv[3] ||
+    srcPath.replace(/\.db$/i, `-bak-${Date.now()}.db`),
+);
+fs.mkdirSync(path.dirname(destPath), { recursive: true });
+
+// 1) 非只读打开源 + 强制 WAL checkpoint（把 WAL 合并进主文件）
+const db = new Database(srcPath);
+db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+const srcTables = db
+  .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+  .all()
+  .map((r) => r.name)
+  .sort();
+db.close();
+
+// 2) 物理复制主文件（此时主文件已含全部数据，cp 即一致快照）
+fs.copyFileSync(srcPath, destPath);
+const size = fs.statSync(destPath).size;
+
+// 3) 校验：非只读打开目标（避免 readonly 假象），对比表清单 + 专项查 tags
+const check = new Database(destPath);
+const destTables = check
+  .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+  .all()
+  .map((r) => r.name)
+  .sort();
+const missing = srcTables.filter((t) => !destTables.includes(t));
+const tagsPresent = destTables.includes("tags");
+check.close();
+
+if (missing.length || !tagsPresent) {
+  const errs = [];
+  if (missing.length) errs.push(`缺失表: ${missing.join(", ")}`);
+  if (!tagsPresent) errs.push("tags 表丢失！");
+  console.error(`❌ 备份校验失败: ${errs.join("；")}`);
+  console.error(`   提示: 源库可能正被占用，请确认无写入进程后再试`);
+  process.exitCode = 1;
+} else {
+  console.log(`✅ 备份完成: ${srcPath}`);
+  console.log(`   目标: ${destPath} (${(size / 1024 / 1024).toFixed(1)} MB)`);
+  console.log(`   表清单一致: ${srcTables.length} 张表（含 tags）`);
+}

package/scripts/check-queues.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+# 一键查询远程服务器 TikTok 双队列状态
+# 用法:
+#   ./scripts/check-queues.sh        # 仅输出两个数字: precheck_48h / pending_refresh
+#   ./scripts/check-queues.sh -d     # 额外输出 pending_refresh 按国家分布
+# 口径（jobs 表，14 国含 US）:
+#   precheck_48h = tt_seller=1 AND verified=0 AND (pending_refresh IS NULL OR 0)
+#                  AND COALESCE(refresh_time,1452000000000) < now-48h
+#   pending_refresh = tt_seller=1 AND verified=0 AND pending_refresh=1
+SERVER="http://117.71.53.99:17301"
+TARGETS="'CZ','GR','HU','PT','ES','PL','NL','BE','DE','FR','IT','IE','AT','US'"
+THRESHOLD=$(( $(date +%s)000 - 172800000 ))
+
+enc() { python3 -c "import urllib.parse,sys;print(urllib.parse.quote(sys.argv[1]))" "$1"; }
+cnt() { python3 -c 'import json,sys
+try: print(json.load(sys.stdin)["rows"][0]["cnt"])
+except Exception: print("ERR")'; }
+
+q() { curl -s --max-time 25 "$SERVER/api/db-query?sql=$(enc "$1")"; }
+
+PC=$(q "SELECT COUNT(*) AS cnt FROM jobs WHERE tt_seller=1 AND verified=0 AND (pending_refresh IS NULL OR pending_refresh=0) AND COALESCE(refresh_time,1452000000000) < $THRESHOLD AND location_created IN ($TARGETS)" | cnt)
+PR=$(q "SELECT COUNT(*) AS cnt FROM jobs WHERE tt_seller=1 AND verified=0 AND pending_refresh=1 AND location_created IN ($TARGETS)" | cnt)
+
+echo "precheck_48h=$PC"
+echo "pending_refresh=$PR"
+
+if [ "${1:-}" = "-d" ]; then
+  echo "--- pending_refresh by country ---"
+  q "SELECT location_created AS country, COUNT(*) AS cnt FROM jobs WHERE tt_seller=1 AND verified=0 AND pending_refresh=1 GROUP BY location_created ORDER BY cnt DESC" \
+    | python3 -c 'import json,sys
+try:
+  rows=json.load(sys.stdin)["rows"]
+  for r in rows:
+    print(r["country"], r["cnt"], sep="\t")
+except Exception as e:
+  print("ERR", e)'
+fi

package/scripts/migrate-jobs-done.mjs

@@ -0,0 +1,124 @@
+/**
+ * jobs_done 冷归档迁移脚本
+ *
+ * 将 jobs 表中 status='done' 且非商家（tt_seller IS NULL OR tt_seller != 1）
+ * 的记录分批迁入新建的 jobs_done 表，并从 jobs 删除。
+ *
+ * 幂等：可重复执行；第二次运行无剩余可迁移记录时直接跳过。
+ * 与 db-schema.js 的 migrateDoneToJobsDone() 逻辑一致，本脚本用于
+ * 部署时在停主程序期间手动执行（避免百万级迁移阻塞 watch 启动）。
+ *
+ * 用法：
+ *   node scripts/migrate-jobs-done.mjs --db=/path/to/result.db [--batch=50000]
+ */
+
+import Database from "better-sqlite3";
+import { existsSync } from "fs";
+
+function parseArg(name, def) {
+  const arg = process.argv.find((a) => a.startsWith(`--${name}=`));
+  return arg ? arg.slice(`--${name}=`.length) : def;
+}
+
+const dbPath = parseArg("db", null);
+const BATCH = Math.max(
+  1,
+  Math.min(100000, parseInt(parseArg("batch", "50000")) || 50000),
+);
+
+if (!dbPath) {
+  console.error(
+    "用法: node scripts/migrate-jobs-done.mjs --db=<主库路径> [--batch=50000]",
+  );
+  process.exit(1);
+}
+if (!existsSync(dbPath)) {
+  console.error(`错误: 数据库不存在: ${dbPath}`);
+  process.exit(1);
+}
+
+const db = new Database(dbPath);
+db.pragma("journal_mode = WAL");
+db.pragma("busy_timeout = 10000");
+
+const DONE_NON_SELLER =
+  "j.status = 'done' AND (j.tt_seller IS NULL OR j.tt_seller != 1)";
+
+// 确保 jobs_done 表存在（结构与 jobs 一致）
+const jdExists = db
+  .prepare(
+    "SELECT 1 FROM sqlite_master WHERE type='table' AND name='jobs_done'",
+  )
+  .get();
+if (!jdExists) {
+  console.error("创建 jobs_done 表...");
+  db.exec("CREATE TABLE jobs_done AS SELECT * FROM jobs WHERE 1=0");
+  db.exec(
+    "CREATE UNIQUE INDEX IF NOT EXISTS idx_jobs_done_pk ON jobs_done(unique_id)",
+  );
+}
+// 补索引
+db.exec(
+  "CREATE INDEX IF NOT EXISTS idx_jobs_done_list ON jobs_done(pinned, processed_at, follower_count, unique_id) WHERE status = 'done'",
+);
+db.exec(
+  "CREATE INDEX IF NOT EXISTS idx_jobs_done_loc ON jobs_done(location_created)",
+);
+db.exec(
+  "CREATE INDEX IF NOT EXISTS idx_jobs_done_status_updated ON jobs_done(status, updated_at) WHERE status = 'done' AND (tt_seller IS NULL OR tt_seller != 1)",
+);
+
+const count = (sql) => db.prepare(sql).get()?.c || 0;
+const beforeJobs = count("SELECT COUNT(*) as c FROM jobs");
+const beforeDone = count("SELECT COUNT(*) as c FROM jobs_done");
+
+console.error(`迁移前: jobs=${beforeJobs}, jobs_done=${beforeDone}`);
+
+let total = 0;
+const start = Date.now();
+for (;;) {
+  const inserted = db
+    .prepare(
+      `INSERT OR IGNORE INTO jobs_done
+       SELECT j.* FROM jobs j
+       LEFT JOIN jobs_done jd ON jd.unique_id = j.unique_id
+       WHERE ${DONE_NON_SELLER} AND jd.unique_id IS NULL
+       LIMIT ?`,
+    )
+    .run(BATCH).changes;
+  const deleted = db
+    .prepare(
+      `DELETE FROM jobs WHERE unique_id IN (
+         SELECT j.unique_id FROM jobs j
+         JOIN jobs_done jd ON jd.unique_id = j.unique_id
+         WHERE ${DONE_NON_SELLER}
+         LIMIT ?
+       )`,
+    )
+    .run(BATCH).changes;
+  if (inserted === 0 && deleted === 0) break;
+  total += Math.max(inserted, deleted);
+  console.error(`  已迁移 ${total} 条...`);
+}
+const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+
+const afterJobs = count("SELECT COUNT(*) as c FROM jobs");
+const afterDone = count("SELECT COUNT(*) as c FROM jobs_done");
+
+// 校验：jobs 中不应再有非商家 done
+const residual = count(
+  `SELECT COUNT(*) as c FROM jobs WHERE status='done' AND (tt_seller IS NULL OR tt_seller != 1)`,
+);
+
+console.error(`迁移完成: 共迁移 ${total} 条（耗时 ${elapsed}s）`);
+console.error(`迁移后: jobs=${afterJobs}, jobs_done=${afterDone}`);
+if (residual > 0) {
+  console.error(
+    `⚠️  jobs 中仍有 ${residual} 条非商家 done 残留（可能被其他进程写入）`,
+  );
+  process.exitCode = 2;
+} else {
+  console.error("校验通过: jobs 中无非商家 done 残留");
+}
+
+db.close();

package/scripts/migrate-tags-db.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * 迁移 tag 相关 7 张表到独立 tags.db
+ *
+ * 用法:
+ *   node scripts/migrate-tags-db.mjs [主库.db] [目标tags.db]
+ * 默认: ../newdata/result.db → ../newdata/result-tags.db
+ *
+ * 特性:
+ *   - 主库以只读方式打开，不删除任何数据；主库 tags 表保留作回滚兜底
+ *   - 幂等：以主库为准，目标库对应表先 DROP 再全量重建，可重复执行
+ *   - 通过 ATTACH 一次性复制数据 + 复制普通索引（autoindex 随建表自动生成）
+ *
+ * 迁移的 8 张表:
+ *   tags, tag_directions, tag_experiments, tag_analyst_reports,
+ *   cross_country_learnings, discover_log, reflection_rules, tag_optimize_rounds
+ *
+ * 注意：
+ *   - 主库以 readonly 打开，绝不可能被修改；主库 tags 表保留作回滚兜底
+ *   - 采用双连接流式复制（每批 1000 行事务插入），不用 ATTACH
+ *   - 为何不用 ATTACH：实测 ATTACH 一个 WAL 模式的库作为源，会创建其
+ *     -wal/-shm 并导致 schema 解析不一致，甚至破坏源库（tags 表丢失）
+ *   - 幂等：目标库对应表先 DROP 再全量重建，可重复执行
+ */
+import fs from "fs";
+import path from "path";
+import Database from "better-sqlite3";
+
+const TAG_TABLES = [
+  "tags",
+  "tag_directions",
+  "tag_experiments",
+  "tag_analyst_reports",
+  "cross_country_learnings",
+  "discover_log",
+  "reflection_rules",
+  // 历史遗留表（主库存在、代码不再引用，迁移时一并带走）
+  "tag_optimize_rounds",
+];
+
+const mainPath = path.resolve(process.argv[2] || "../newdata/result.db");
+const tagPath = path.resolve(
+  process.argv[3] || mainPath.replace(/\.db$/i, "-tags.db"),
+);
+
+if (!fs.existsSync(mainPath)) {
+  console.error(`主库不存在: ${mainPath}`);
+  process.exit(1);
+}
+
+// 主库 readonly（绝不修改主库）；目标库可写
+const main = new Database(mainPath, { readonly: true });
+fs.mkdirSync(path.dirname(tagPath), { recursive: true });
+const tag = new Database(tagPath);
+tag.pragma("journal_mode = WAL");
+tag.pragma("busy_timeout = 5000");
+
+const report = [];
+const placeholders = TAG_TABLES.map(() => "?").join(",");
+
+// 批量流式复制辅助：把一列行插入目标表
+function streamCopy(srcTable, destTable) {
+  const cols = main
+    .prepare(`SELECT name FROM pragma_table_info('${srcTable}')`)
+    .all()
+    .map((c) => c.name);
+  const colList = cols.join(", ");
+  const stmt = tag.prepare(
+    `INSERT INTO ${destTable} (${colList}) VALUES (${cols.map(() => "?").join(", ")})`,
+  );
+  const insertAll = tag.transaction((rows) => {
+    for (const r of rows) stmt.run(cols.map((c) => r[c]));
+  });
+  const select = main.prepare(`SELECT * FROM ${srcTable}`);
+  let batch = [];
+  let inserted = 0;
+  for (const row of select.iterate()) {
+    batch.push(row);
+    if (batch.length >= 1000) {
+      insertAll(batch);
+      inserted += batch.length;
+      batch = [];
+    }
+  }
+  if (batch.length) {
+    insertAll(batch);
+    inserted += batch.length;
+  }
+  return inserted;
+}
+
+try {
+  // 1) 逐表迁移（目标表先 DROP 再重建，保证幂等）
+  for (const t of TAG_TABLES) {
+    const meta = main
+      .prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name = ?")
+      .get(t);
+    if (!meta || !meta.sql) {
+      report.push(`⚠️  ${t}: 主库不存在，跳过`);
+      continue;
+    }
+    tag.exec(`DROP TABLE IF EXISTS ${t}`);
+    tag.exec(meta.sql);
+    const inserted = streamCopy(t, t);
+    const mainCnt = main.prepare(`SELECT COUNT(*) as c FROM ${t}`).get().c;
+    const tagCnt = tag.prepare(`SELECT COUNT(*) as c FROM ${t}`).get().c;
+    const ok = mainCnt === tagCnt && inserted === mainCnt;
+    report.push(
+      `${ok ? "✅" : "❌"} ${t}: 主库=${mainCnt} 行 / tags.db=${tagCnt} 行 / 迁移=${inserted}${ok ? "" : "  ← 不一致！"}`,
+    );
+  }
+
+  // 2) 复制普通索引（autoindex 由建表 SQL 自动重建，无需复制）
+  const idxRows = main
+    .prepare(
+      `SELECT sql, name FROM sqlite_master
+       WHERE type='index' AND tbl_name IN (${placeholders}) AND sql IS NOT NULL`,
+    )
+    .all(...TAG_TABLES);
+  for (const r of idxRows) {
+    try {
+      tag.exec(r.sql);
+    } catch (e) {
+      report.push(`⚠️  索引 ${r.name} 建立失败: ${e.message}`);
+    }
+  }
+  report.push(`已复制普通索引 ${idxRows.length} 个`);
+
+  // 3) 校验目标库表完整性（只校验主库存在的表，主库不存在的遗留表不报缺失）
+  const missing = [];
+  for (const t of TAG_TABLES) {
+    const inMain = main
+      .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name = ?")
+      .get(t);
+    if (!inMain) continue;
+    if (
+      !tag
+        .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?")
+        .get(t)
+    ) {
+      missing.push(t);
+    }
+  }
+  const checkedCount = TAG_TABLES.length - missing.length;
+  report.push(
+    missing.length
+      ? `❌ 目标库缺失表: ${missing.join(", ")}`
+      : `✅ 目标库校验通过（${checkedCount} 张主库存在的表齐全）`,
+  );
+
+  tag.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+} catch (e) {
+  console.error(`❌ 迁移失败: ${e.message}`);
+  process.exitCode = 1;
+} finally {
+  main.close();
+  tag.close();
+}
+
+console.log(`\n主库: ${mainPath}`);
+console.log(`tags.db: ${tagPath}`);
+console.log("----");
+console.log(report.join("\n"));

package/src/cli/tag.js

@@ -1,6 +1,7 @@
 import { writeFileSync, unlinkSync } from "fs";
 import { randomUUID } from "crypto";
 import { execSync } from "child_process";
+import http from "http";
 import os from "os";
 import path from "path";
 import readline from "readline";
@@ -66,6 +67,38 @@ function isBrowserDisconnected(browser, e) {
   return false;
 }
 
+/**
+ * 探测端口是否已被监听（CDP /json 端点）。
+ * 与 cdp.js 的 checkCDPPort 等价，但 tag.js 独立实现，不依赖未导出的内部函数。
+ * 用于端口池挑选时跳过被占用端口、以及关闭旧浏览器后确认端口已释放。
+ */
+function checkPortListening(port) {
+  return new Promise((resolve) => {
+    const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
+      res.on("data", () => {});
+      res.on("end", () => resolve(res.statusCode === 200));
+    });
+    req.on("error", () => resolve(false));
+    req.setTimeout(2000, () => {
+      resolve(false);
+      req.destroy();
+    });
+  });
+}
+
+/**
+ * 等待端口不再被监听（浏览器进程真正退出、端口释放）。
+ * @returns {Promise<boolean>} 端口已释放返回 true
+ */
+async function waitForPortReleased(port, timeoutMs = 10000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!(await checkPortListening(port))) return true;
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return !(await checkPortListening(port));
+}
+
 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`;
 }
@@ -927,6 +960,9 @@ export async function handleScoreAll(parsed) {
 
   await setupPageRequestBlocking(page);
 
+  // 运行期用过的所有 CDP 端口（含换端口历史），退出时统一清理，防止旧浏览器窗口残留
+  const usedPorts = new Set([cdpPort]);
+
   // 端口池起始以 CLI --port / 环境变量 / 默认 7222 为准
   const portPoolStart = cdpPort;
   const portPoolSize = Math.max(
@@ -934,14 +970,21 @@ export async function handleScoreAll(parsed) {
     parseInt(process.env.TAG_SCOREALL_PORT_POOL_SIZE || "10", 10) || 10,
   );
 
-  function pickNextPort(currentPort) {
+  async function pickNextPort(currentPort) {
     const candidates = [];
     for (let i = 0; i < portPoolSize; i++) {
       const p = portPoolStart + i;
       if (p !== currentPort) candidates.push(p);
     }
-    if (candidates.length === 0) return currentPort;
-    return candidates[Math.floor(Math.random() * candidates.length)];
+    // 跳过已被监听的端口（其他 score-all/attach 等程序的浏览器），
+    // 避免 attach 到别人的实例、后续 close/kill 时互相干扰导致浏览器多开
+    const freePorts = [];
+    for (const p of candidates) {
+      if (!(await checkPortListening(p))) freePorts.push(p);
+    }
+    const pool = freePorts.length > 0 ? freePorts : candidates;
+    if (pool.length === 0) return currentPort;
+    return pool[Math.floor(Math.random() * pool.length)];
   }
 
   // ── 内存回收配置 ──
@@ -996,9 +1039,10 @@ export async function handleScoreAll(parsed) {
     const oldPort = cdpPort;
     const shouldSwitch = switchPort && RECYCLE_CONFIG.switchPortOnRecycle;
     if (shouldSwitch) {
-      cdpPort = pickNextPort(cdpPort);
+      cdpPort = await pickNextPort(cdpPort);
       cdpOpts.port = cdpPort;
       clientMeta.port = cdpPort;
+      usedPorts.add(cdpPort);
     }
     const portHint =
       oldPort === cdpPort ? `port=${cdpPort}` : `port ${oldPort}→${cdpPort}`;
@@ -1007,10 +1051,21 @@ export async function handleScoreAll(parsed) {
       await page.close().catch(() => {});
       page = null;
     }
-    await browser.close().catch(() => {});
+    // CDP 模式下 browser.close() 只断开连接不杀进程，必须显式 kill 旧端口实例；
+    // kill 后确认端口已释放，再启动新实例，防止旧浏览器窗口残留（多开）
     if (oldPort !== cdpPort) {
       await killEdgeProcesses(null, oldPort).catch(() => {});
+      if (!(await waitForPortReleased(oldPort))) {
+        log(`  ⚠️ 旧端口 ${oldPort} 未释放，再次尝试关闭...`);
+        await killEdgeProcesses(null, oldPort).catch(() => {});
+        if (!(await waitForPortReleased(oldPort, 5000))) {
+          log(
+            `  ⚠️ 旧端口 ${oldPort} 仍未释放，继续使用新端口（旧浏览器窗口可能残留，退出时会统一清理）`,
+          );
+        }
+      }
     }
+    await browser.close().catch(() => {});
     browser = await ensureBrowserReady(cdpOpts);
     page = await getOrCreatePage(browser);
     await setupPageRequestBlocking(page);
@@ -1103,10 +1158,14 @@ export async function handleScoreAll(parsed) {
     if (enrichScraper) await enrichScraper.close().catch(() => {});
     log("正在关闭 CDP 浏览器...");
     try {
-      await Promise.race([
-        killEdgeProcesses(null, cdpPort),
-        new Promise((r) => setTimeout(r, 5000)),
-      ]);
+      // 逐个关闭运行期用过的所有端口（含换端口历史），防止旧浏览器窗口残留
+      const ports = [...new Set([...usedPorts, cdpPort])];
+      for (const p of ports) {
+        await Promise.race([
+          killEdgeProcesses(null, p),
+          new Promise((r) => setTimeout(r, 5000)),
+        ]).catch(() => {});
+      }
       log("浏览器已关闭");
     } catch (e) {
       log(`关闭浏览器失败: ${e.message}`);

package/src/lib/tag-discover.js

@@ -253,6 +253,27 @@ async function discoverTagsForCountryCli(
   process.stderr.write(
     `  [LLM] 正在生成标签 (国家: ${country}, 语言: ${getLang(country)}, 目标: ${count} 个, temp=${temperature}, health=${health?.healthStatus || "unknown"})...\n`,
   );
+  // 如果服务商被设置为 none，则跳过 LLM 调用并返回空结果
+  try {
+    const { getLlmConfig } = await import("../watch/llm-config.js");
+    const cfg = getLlmConfig();
+    if (cfg.provider === "none") {
+      process.stderr.write(`  [LLM] 已禁用（provider=none），跳过生成\n`);
+      return {
+        country,
+        tags: [],
+        niche: null,
+        health: health || null,
+        autoNiche: null,
+        temperature,
+        hardRulesInjected: hardRules.length,
+        reflection: null,
+      };
+    }
+  } catch (e) {
+    // ignore, proceed to call LLM
+  }
+
   const content = await callLLM(prompt, temperature);
   const parsed = parseDiscoverResponse(content);
   const tags = parsed.tags || parseTagsFromResponse(content);