tt-help-cli-ycl 1.4.167 → 1.4.169

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.167",
+  "version": "1.4.169",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {
@@ -48,4 +48,4 @@
   "devDependencies": {
     "better-sqlite3": "^12.10.0"
   }
-}
+}

package/scripts/diag-claim-branches.js

@@ -0,0 +1,72 @@
+// 只读诊断：201 本机实测 claimNextJob 各分支 SQL 耗时（readonly，不动生产数据）
+// 用完即删
+import path from "path";
+import Database from "file://D:/tiktok/tiktok-cli/node_modules/better-sqlite3/lib/index.js";
+const db = new Database(path.join("D:", "tiktok", "data", "result.db"), {
+  readonly: true,
+  timeout: 600000,
+});
+
+function t(name, sql, args = []) {
+  const stmt = db.prepare(sql);
+  const t0 = Date.now();
+  const r = stmt.get(...args);
+  console.log(
+    `${String(Date.now() - t0).padStart(6)}ms  ${r ? "HIT " : "MISS"}  ${name}`,
+  );
+}
+
+const ORDER = "ORDER BY follower_count DESC, created_at ASC, unique_id ASC LIMIT 1";
+const SC = "(status_code IS NULL OR status_code = 0 OR status_code = 209002)";
+
+console.log("=== A. pinned 分支（池当前为空）===");
+t(
+  "pinned+video",
+  `SELECT unique_id FROM task_queue WHERE status='pending' AND pinned=1 AND video_count>0 AND ${SC} ${ORDER}`,
+);
+t(
+  "pinned",
+  `SELECT unique_id FROM task_queue WHERE status='pending' AND pinned=1 AND ${SC} ${ORDER}`,
+);
+
+console.log("=== B. seed 级首国分支（MX）：OR 空位置 原版形态 ===");
+t(
+  "seed MX OR-empty (原版)",
+  `SELECT unique_id FROM task_queue WHERE status='pending' AND pinned=0 AND instr(COALESCE(sources,''), '"seed"') > 0 AND video_count > 0 AND (UPPER(COALESCE(guessed_location,'')) IN ('MX') OR COALESCE(guessed_location,'') = '') AND ${SC} ${ORDER}`,
+);
+
+console.log("=== C. 拆分形态：单值 IN 点查 ===");
+t(
+  "seed MX only",
+  `SELECT unique_id FROM task_queue WHERE status='pending' AND pinned=0 AND instr(COALESCE(sources,''), '"seed"') > 0 AND video_count > 0 AND UPPER(COALESCE(guessed_location,'')) IN ('MX') AND ${SC} ${ORDER}`,
+);
+t(
+  "seed empty-loc only",
+  `SELECT unique_id FROM task_queue WHERE status='pending' AND pinned=0 AND instr(COALESCE(sources,''), '"seed"') > 0 AND video_count > 0 AND UPPER(COALESCE(guessed_location,'')) = '' AND ${SC} ${ORDER}`,
+);
+t(
+  "seed ID only (最大池 10.8万)",
+  `SELECT unique_id FROM task_queue WHERE status='pending' AND pinned=0 AND instr(COALESCE(sources,''), '"seed"') > 0 AND video_count > 0 AND UPPER(COALESCE(guessed_location,'')) IN ('ID') AND ${SC} ${ORDER}`,
+);
+
+console.log("=== D. seller/follow/other 级抽测（MX 单值）===");
+t(
+  "seller MX hasVideo",
+  `SELECT unique_id FROM task_queue WHERE status='pending' AND pinned=0 AND tt_seller=1 AND verified=0 AND video_count>0 AND UPPER(COALESCE(guessed_location,'')) IN ('MX') AND ${SC} ${ORDER}`,
+);
+t(
+  "follow MX hasVideo",
+  `SELECT unique_id FROM task_queue WHERE status='pending' AND pinned=0 AND (instr(COALESCE(sources,''), '"following"') > 0 OR instr(COALESCE(sources,''), '"follower"') > 0 OR instr(COALESCE(sources,''), '"comment"') > 0) AND video_count>0 AND UPPER(COALESCE(guessed_location,'')) IN ('MX') AND ${SC} ${ORDER}`,
+);
+t(
+  "other MX hasVideo",
+  `SELECT unique_id FROM task_queue WHERE status='pending' AND pinned=0 AND video_count>0 AND UPPER(COALESCE(guessed_location,'')) IN ('MX') AND ${SC} ${ORDER}`,
+);
+console.log("=== E. NOT IN 24国兜底分支 ===");
+t(
+  "other NOT-IN fallback",
+  `SELECT unique_id FROM task_queue WHERE status='pending' AND pinned=0 AND video_count>0 AND UPPER(COALESCE(guessed_location,'')) NOT IN ('MX','JP','BR','SG','ID','VN','PH','PL','NL','BE','US','TH','MY','AT','CZ','HU','GR','PT','DE','FR','IT','IE','ES','GB') AND ${SC} ${ORDER}`,
+);
+db.close();
+console.log("done");
+

package/scripts/test-claim-fix.mjs

@@ -0,0 +1,216 @@
+// claimNextJob 修复验证：功能语义 + 性能（合成 32 万行模拟生产行数）
+// 用完即删
+import fs from "fs";
+import { createStore } from "../src/watch/data-store.js";
+import { getDb } from "../src/watch/db-schema.js";
+
+const TMP = "/tmp/tiktok-claim-test";
+fs.rmSync(TMP, { recursive: true, force: true });
+fs.mkdirSync(TMP, { recursive: true });
+
+function freshStore(name) {
+  const p = `${TMP}/${name}.db`;
+  const store = createStore(p, {});
+  return { store, db: getDb(), path: p };
+}
+
+function insertRows(db, rows) {
+  const stmt = db.prepare(`
+    INSERT OR REPLACE INTO task_queue
+      (unique_id, status, guessed_location, video_count, follower_count,
+       tt_seller, verified, status_code, pinned, sources, created_at, claimed_at, claimed_by)
+    VALUES
+      (@unique_id, @status, @guessed_location, @video_count, @follower_count,
+       @tt_seller, @verified, @status_code, @pinned, @sources, @created_at, @claimed_at, @claimed_by)
+  `);
+  const tx = db.transaction((list) => {
+    for (const r of list) stmt.run(r);
+  });
+  tx(rows);
+}
+
+const baseRow = {
+  status: "pending",
+  guessed_location: "",
+  video_count: 5,
+  follower_count: 1000,
+  tt_seller: 0,
+  verified: 0,
+  status_code: null,
+  pinned: 0,
+  sources: '["explore"]',
+  created_at: "2026-01-01T00:00:00Z",
+  claimed_at: null,
+  claimed_by: null,
+};
+const row = (over) => ({ ...baseRow, unique_id: `u_${Math.random().toString(36).slice(2, 9)}`, ...over });
+
+let pass = 0, fail = 0;
+function check(name, cond, detail = "") {
+  if (cond) { pass++; console.log(`  ✅ ${name}${detail ? "  " + detail : ""}`); }
+  else { fail++; console.log(`  ❌ ${name}${detail ? "  " + detail : ""}`); }
+}
+
+// ───────── B. 功能语义（小数据集，各用独立库） ─────────
+console.log("\n== B1. 首国等值严格优先于空位置（即使空位置粉丝更高）==");
+{
+  const { store, db } = freshStore("b1");
+  insertRows(db, [
+    row({ unique_id: "empty-high", guessed_location: "", follower_count: 9999 }),
+    row({ unique_id: "mx-low", guessed_location: "mx", follower_count: 100 }),
+  ]);
+  const j = await store.claimNextJob("c1", 5 * 60 * 1000, ["MX", "BR"], true);
+  check("领到 mx-low", j?.uniqueId === "mx-low", `got=${j?.uniqueId}`);
+}
+
+console.log("== B2. 首国无候选时空位置可领 ==");
+{
+  const { store, db } = freshStore("b2");
+  insertRows(db, [row({ unique_id: "only-empty", guessed_location: "" })]);
+  const j = await store.claimNextJob("c1", 5 * 60 * 1000, ["MX", "BR"], true);
+  check("领到 only-empty", j?.uniqueId === "only-empty", `got=${j?.uniqueId}`);
+}
+
+console.log("== B3. hasVideo 层整体优先于 noVideoReq 层（含空位置）==");
+{
+  const { store, db } = freshStore("b3");
+  insertRows(db, [
+    row({ unique_id: "mx-novideo", guessed_location: "mx", video_count: 0, follower_count: 5000 }),
+    row({ unique_id: "br-video", guessed_location: "br", video_count: 3, follower_count: 100 }),
+  ]);
+  const j = await store.claimNextJob("c1", 5 * 60 * 1000, ["MX", "BR"], true);
+  check("mx-noVideo 优先于 br-video（与原版层级一致）", j?.uniqueId === "mx-novideo", `got=${j?.uniqueId}`);
+}
+
+console.log("== B4. 国家顺序优先：MX 行优先于 BR 行 ==");
+{
+  const { store, db } = freshStore("b4");
+  insertRows(db, [
+    row({ unique_id: "br-high", guessed_location: "br", follower_count: 9999 }),
+    row({ unique_id: "mx-low", guessed_location: "mx", follower_count: 10 }),
+  ]);
+  const j = await store.claimNextJob("c1", 5 * 60 * 1000, ["MX", "BR"], true);
+  check("领到 mx-low", j?.uniqueId === "mx-low", `got=${j?.uniqueId}`);
+}
+
+console.log("== B5. pinned：空池记忆后 pin 立即可领（缓存失效生效）==");
+{
+  const { store, db } = freshStore("b5");
+  insertRows(db, [
+    row({ unique_id: "plain", guessed_location: "mx", follower_count: 100 }),
+    row({ unique_id: "pinned-later", guessed_location: "br", follower_count: 50 }),
+  ]);
+  // 第一次领取：pinned 分支执行且 miss → 写入空池记忆
+  const j1 = await store.claimNextJob("c1", 5 * 60 * 1000, ["MX", "BR"], true);
+  check("第一次领到 plain", j1?.uniqueId === "plain", `got=${j1?.uniqueId}`);
+  // pin 一个低优先级任务
+  const pinRet = store.togglePin("pinned-later");
+  check("togglePin 成功", pinRet?.saved === true);
+  // 立即换客户端领取：应直接领到 pinned 任务（不受空池记忆影响）
+  const j2 = await store.claimNextJob("c2", 5 * 60 * 1000, ["MX", "BR"], true);
+  check("pin 后立即领到 pinned-later", j2?.uniqueId === "pinned-later", `got=${j2?.uniqueId}`);
+}
+
+console.log("== B6. 未登录客户端不领商家 ==");
+{
+  const { store, db } = freshStore("b6");
+  insertRows(db, [row({ unique_id: "seller-only", guessed_location: "mx", tt_seller: 1 })]);
+  const jOut = await store.claimNextJob("c1", 5 * 60 * 1000, ["MX"], false);
+  check("未登录领不到", jOut === null, `got=${jOut?.uniqueId}`);
+  const jIn = await store.claimNextJob("c2", 5 * 60 * 1000, ["MX"], true);
+  check("登录可领", jIn?.uniqueId === "seller-only", `got=${jIn?.uniqueId}`);
+}
+
+console.log("== B7. status_code=209002 仅登录客户端可领 ==");
+{
+  const { store, db } = freshStore("b7");
+  insertRows(db, [row({ unique_id: "code-209002", guessed_location: "mx", status_code: 209002 })]);
+  const jOut = await store.claimNextJob("c1", 5 * 60 * 1000, ["MX"], false);
+  check("未登录领不到", jOut === null, `got=${jOut?.uniqueId}`);
+  const jIn = await store.claimNextJob("c2", 5 * 60 * 1000, ["MX"], true);
+  check("登录可领", jIn?.uniqueId === "code-209002", `got=${jIn?.uniqueId}`);
+}
+
+console.log("== B8. 超时 processing 回收优先 ==");
+{
+  const { store, db } = freshStore("b8");
+  const now = Date.now();
+  insertRows(db, [
+    row({ unique_id: "stale", guessed_location: "mx", status: "processing", claimed_at: now - 10 * 60 * 1000, claimed_by: "dead-client" }),
+    row({ unique_id: "fresh", guessed_location: "mx", follower_count: 99999 }),
+  ]);
+  const j = await store.claimNextJob("c1", 5 * 60 * 1000, ["MX"], true);
+  check("回收的 stale 优先于高粉丝 fresh", j?.uniqueId === "stale", `got=${j?.uniqueId}`);
+}
+
+console.log("== B9. 商家任意国家兜底（sellerAnyCountry）==");
+{
+  const { store, db } = freshStore("b9");
+  insertRows(db, [
+    row({ unique_id: "zz-seller", guessed_location: "zz", tt_seller: 1, verified: 0, follower_count: 10 }),
+    row({ unique_id: "mx-normal", guessed_location: "mx", follower_count: 9999 }),
+  ]);
+  const j = await store.claimNextJob("c1", 5 * 60 * 1000, ["MX"], true);
+  check("商家级高于 other 级：zz-seller 先领", j?.uniqueId === "zz-seller", `got=${j?.uniqueId}`);
+}
+
+console.log("== B10. seed 级优先于 follow/other ==");
+{
+  const { store, db } = freshStore("b10");
+  insertRows(db, [
+    row({ unique_id: "mx-seed", guessed_location: "mx", sources: '["explore"]', follower_count: 10 }),
+    row({ unique_id: "br-seed", guessed_location: "br", sources: '["seed"]', follower_count: 20 }),
+  ]);
+  const j = await store.claimNextJob("c1", 5 * 60 * 1000, ["MX", "BR"], true);
+  check("seed 级 br-seed 胜过 other 级 mx（国家级让位于来源级）", j?.uniqueId === "br-seed", `got=${j?.uniqueId}`);
+}
+
+// ───────── A. 性能（32 万行）─────────
+console.log("\n== A. 性能：320,600 行 pending，候选国家池全空，模拟生产全 miss 场景 ==");
+{
+  const { store, db } = freshStore("perf");
+  // 32 万行：位置全 ZZ（配置外），含 3000 个高粉丝商家（seller any-country 分支秒命中用）
+  db.exec(`
+    WITH RECURSIVE seq(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM seq WHERE i < 320600)
+    INSERT INTO task_queue
+      (unique_id, status, guessed_location, video_count, follower_count, tt_seller, verified, status_code, pinned, sources, created_at)
+    SELECT
+      'bulk_' || i,
+      'pending',
+      'zz',
+      CASE WHEN i % 3 = 0 THEN 5 ELSE 0 END,
+      (i * 7919) % 1000000,
+      CASE WHEN i <= 3000 THEN 1 ELSE 0 END,
+      0,
+      NULL,
+      0,
+      '["explore"]',
+      '2026-01-01T00:00:00Z'
+    FROM seq
+  `);
+  // 保证 3 个最高粉丝都是商家 → seller any-country 命中不扫表
+  db.exec(`UPDATE task_queue SET follower_count = 100000000 + CAST(unique_id AS INTEGER) % 1000 WHERE tt_seller = 1 AND CAST(REPLACE(unique_id,'bulk_','') AS INTEGER) <= 3`);
+
+  const t1 = Date.now();
+  const j1 = await store.claimNextJob("perf-c1", 5 * 60 * 1000, ["MX", "BR"], true);
+  const t1ms = Date.now() - t1;
+  check("首领成功（命中商家兜底）", j1?.uniqueId?.startsWith("bulk_"), `got=${j1?.uniqueId} ${t1ms}ms`);
+
+  const t2 = Date.now();
+  const j2 = await store.claimNextJob("perf-c2", 5 * 60 * 1000, ["MX", "BR"], true);
+  const t2ms = Date.now() - t2;
+  check("次领成功", j2?.uniqueId?.startsWith("bulk_"), `got=${j2?.uniqueId} ${t2ms}ms`);
+  check("次领显著快于首领（pinned/seed 空池缓存生效）", t2ms < t1ms, `t1=${t1ms}ms t2=${t2ms}ms`);
+  check("次领 < 150ms", t2ms < 150, `${t2ms}ms`);
+
+  // EXPLAIN：确认单国等值分支走 fast 索引
+  const plan = db
+    .prepare(`EXPLAIN QUERY PLAN SELECT unique_id FROM task_queue WHERE status='pending' AND pinned=0 AND video_count > 0 AND UPPER(COALESCE(guessed_location, '')) IN ('MX') AND (status_code IS NULL OR status_code = 0 OR status_code = 209002) ORDER BY follower_count DESC, created_at ASC, unique_id ASC LIMIT 1`)
+    .all();
+  const detail = plan.map((r) => r.detail).join(" | ");
+  check("单国分支走 idx_tq_claim_fast", detail.includes("idx_tq_claim_fast"), detail);
+}
+
+console.log(`\n===== 结果: ${pass} passed, ${fail} failed =====`);
+fs.rmSync(TMP, { recursive: true, force: true });
+process.exit(fail > 0 ? 1 : 0);

package/scripts/test-precise-index.mjs

@@ -0,0 +1,114 @@
+// 验证 idx_jobs_precise_merchants 部分覆盖索引：EXPLAIN 命中 + A/B 耗时
+// 用完即删
+import fs from "fs";
+import { createStore } from "../src/watch/data-store.js";
+import { getDb } from "../src/watch/db-schema.js";
+
+const TMP = "/tmp/tiktok-precise-idx-test";
+fs.rmSync(TMP, { recursive: true, force: true });
+fs.mkdirSync(TMP, { recursive: true });
+
+const store = createStore(`${TMP}/t.db`, {});
+const db = getDb();
+
+const IDX_SQL =
+  "CREATE INDEX IF NOT EXISTS idx_jobs_precise_merchants ON jobs(location_created, product_sold_count DESC, unique_id) WHERE tt_seller = 1 AND verified = 0 AND top_video_seo_url IS NOT NULL AND top_video_seo_url != '' AND product_review_count = 0 AND product_sold_count > 10 AND recent_ec_videos IS NOT NULL AND recent_ec_videos != ''";
+
+// 与 data-store.js getPreciseMerchantsFromDb 逐词一致的查询（loc 参数化）
+const COUNT_SQL = (ph) =>
+  `SELECT COUNT(*) AS n FROM jobs WHERE tt_seller = 1 AND verified = 0 AND location_created IN (${ph}) AND top_video_seo_url IS NOT NULL AND top_video_seo_url != '' AND product_review_count = 0 AND product_sold_count > 10 AND recent_ec_videos IS NOT NULL AND recent_ec_videos != '' AND EXISTS (SELECT 1 FROM json_each(recent_ec_videos) WHERE CAST(json_extract(value, '$.playCount') AS INTEGER) > 1000)`;
+
+const LOCS = ["MX", "BR", "DE", "US", "TH"];
+const ph = LOCS.map(() => "?").join(", ");
+
+// ── 造数：30 万商家（大部分不满足便宜条件）+ 500 行满足 + 1 万非商家 ──
+console.log("造数 31 万行...");
+db.exec(`
+  WITH RECURSIVE seq(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM seq WHERE i < 300000)
+  INSERT INTO jobs
+    (unique_id, status, tt_seller, verified, location_created,
+     top_video_seo_url, product_review_count, product_sold_count,
+     recent_ec_videos, follower_count)
+  SELECT
+    's_' || i, 'done', 1, 0,
+    CASE (i % 5) WHEN 0 THEN 'MX' WHEN 1 THEN 'BR' WHEN 2 THEN 'DE' WHEN 3 THEN 'US' ELSE 'TH' END,
+    NULL, 5, 3, NULL, 1000
+  FROM seq
+`);
+db.exec(`
+  WITH RECURSIVE seq(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM seq WHERE i < 500)
+  INSERT INTO jobs
+    (unique_id, status, tt_seller, verified, location_created,
+     top_video_seo_url, product_review_count, product_sold_count,
+     recent_ec_videos, follower_count)
+  SELECT
+    'hit_' || i, 'done', 1, 0,
+    CASE (i % 5) WHEN 0 THEN 'MX' WHEN 1 THEN 'BR' WHEN 2 THEN 'DE' WHEN 3 THEN 'US' ELSE 'TH' END,
+    '/shop/xxx-' || i, 0, 20 + (i % 100),
+    '[{"playCount":' || (2000 + i) || '}]', 5000
+  FROM seq
+`);
+db.exec(`
+  INSERT INTO jobs
+    (unique_id, status, tt_seller, verified, location_created,
+     top_video_seo_url, product_review_count, product_sold_count, recent_ec_videos, follower_count)
+  SELECT 'ns_' || i, 'done', 0, 0, 'MX', '/x', 0, 20, '[{"playCount":3000}]', 100
+  FROM (WITH RECURSIVE seq(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM seq WHERE i < 10000) SELECT i FROM seq)
+`);
+
+const args = [...LOCS];
+
+// ── A/B：无新索引 vs 有新索引 ──
+function bench(label) {
+  const t0 = Date.now();
+  const n = db.prepare(COUNT_SQL(ph)).get(...args).n;
+  const ms = Date.now() - t0;
+  console.log(`  ${label}: COUNT=${n} ${ms}ms`);
+  return { n, ms };
+}
+
+console.log("\n== A/B 耗时（30.6 万行）==");
+const before = bench("无新索引");
+db.exec(IDX_SQL);
+const after = bench("有新索引");
+
+console.log("\n== EXPLAIN：COUNT 与 LIST 查询计划 ==");
+const planCount = db.prepare(`EXPLAIN QUERY PLAN ${COUNT_SQL(ph)}`).all(...args);
+console.log("COUNT :", planCount.map((r) => r.detail).join(" | "));
+const LIST_SQL = `SELECT unique_id, product_sold_count FROM jobs WHERE tt_seller = 1 AND verified = 0 AND location_created IN (${ph}) AND top_video_seo_url IS NOT NULL AND top_video_seo_url != '' AND product_review_count = 0 AND product_sold_count > 10 AND recent_ec_videos IS NOT NULL AND recent_ec_videos != '' AND EXISTS (SELECT 1 FROM json_each(recent_ec_videos) WHERE CAST(json_extract(value, '$.playCount') AS INTEGER) > 1000) ORDER BY product_sold_count DESC, unique_id ASC LIMIT 100 OFFSET 0`;
+const planList = db.prepare(`EXPLAIN QUERY PLAN ${LIST_SQL}`).all(...args);
+console.log("LIST  :", planList.map((r) => r.detail).join(" | "));
+
+const COUNT_IDX = `SELECT COUNT(*) AS n FROM jobs INDEXED BY idx_jobs_precise_merchants WHERE tt_seller = 1 AND verified = 0 AND location_created IN (${ph}) AND top_video_seo_url IS NOT NULL AND top_video_seo_url != '' AND product_review_count = 0 AND product_sold_count > 10 AND recent_ec_videos IS NOT NULL AND recent_ec_videos != '' AND EXISTS (SELECT 1 FROM json_each(recent_ec_videos) WHERE CAST(json_extract(value, '$.playCount') AS INTEGER) > 1000)`;
+const planIdx = db.prepare(`EXPLAIN QUERY PLAN ${COUNT_IDX}`).all(...args);
+const nIdx = db.prepare(COUNT_IDX).get(...args).n;
+
+let pass = 0, fail = 0;
+const check = (name, cond, detail = "") => {
+  if (cond) { pass++; console.log(`  ✅ ${name}${detail ? "  " + detail : ""}`); }
+  else { fail++; console.log(`  ❌ ${name}${detail ? "  " + detail : ""}`); }
+};
+
+console.log("\n== 断言 ==");
+check("COUNT 结果一致（500）", after.n === 500 && before.n === 500, `n=${after.n}`);
+check("INDEXED BY 结果一致", nIdx === 500, `n=${nIdx}`);
+check("优化器自发命中 partial index（小库可自发选中）",
+  planCount.some((r) => r.detail.includes("idx_jobs_precise_merchants")),
+  planCount.map((r) => r.detail).join(" | ").slice(0, 120));
+check("INDEXED BY 强制命中 partial index", planIdx.some((r) => r.detail.includes("idx_jobs_precise_merchants")));
+
+// 回退：drop 索引后 INDEXED BY 应报 no such index（业务层 catch 后走普通查询）
+db.exec("DROP INDEX idx_jobs_precise_merchants");
+let fellBack = false;
+try {
+  db.prepare(COUNT_IDX).get(...args);
+} catch (e) {
+  fellBack = /no such index/i.test(e.message);
+}
+check("索引缺失时抛 no such index（业务层回退依赖此错误）", fellBack);
+const nPlainAfterDrop = db.prepare(COUNT_SQL(ph)).get(...args).n;
+check("普通查询不受影响", nPlainAfterDrop === 500, `n=${nPlainAfterDrop}`);
+
+console.log(`\n===== 结果: ${pass} passed, ${fail} failed =====`);
+fs.rmSync(TMP, { recursive: true, force: true });
+process.exit(fail > 0 ? 1 : 0);

package/scripts/test-stats-smoke.mjs

@@ -0,0 +1,43 @@
+// /api/stats 冒烟：fast 组直接含 targetUsers/preciseMerchants（烟花 30s 级）
+// 用完即删
+import fs from "fs";
+import { createStore } from "../src/watch/data-store.js";
+import { getDb } from "../src/watch/db-schema.js";
+import { startWatchServer } from "../src/watch/server.js";
+
+const TMP = "/tmp/tk-stats-smoke";
+fs.rmSync(TMP, { recursive: true, force: true });
+fs.mkdirSync(TMP, { recursive: true });
+const DB = `${TMP}/t.db`;
+const PORT = 3199;
+
+const store = createStore(DB, {});
+const db = getDb();
+db.exec("ALTER TABLE jobs ADD COLUMN product_skus TEXT");
+db.exec(`INSERT INTO jobs (unique_id, status, tt_seller, verified, location_created,
+  top_video_seo_url, product_review_count, product_sold_count, recent_ec_videos, follower_count)
+  VALUES ('m1','done',1,0,'DE','/x',0,20,'[{"playCount":3000}]',100)`);
+db.exec(`INSERT INTO jobs (unique_id, status, tt_seller, verified, location_created, follower_count)
+  VALUES ('plain','done',1,0,'BR',50)`);
+
+await startWatchServer(DB, PORT, store, { llmDiscover: false }, null);
+
+let ok = false;
+for (let i = 0; i < 20 && !ok; i++) {
+  await new Promise((r) => setTimeout(r, 500));
+  try {
+    const res = await fetch(`http://127.0.0.1:${PORT}/api/stats`);
+    const s = await res.json();
+    if (s && typeof s.targetUsers !== "undefined") {
+      ok = true;
+      console.log("targetUsers     =", s.targetUsers, s.targetUsers === 1 ? "✅" : "❌ 应为 1");
+      console.log("preciseMerchants=", s.preciseMerchants, s.preciseMerchants === 1 ? "✅" : "❌ 应为 1");
+      console.log("processedUsers  =", s.processedUsers, "(slow 组 jobsAgg 未就绪时可为 0，5 分钟内后台补全)");
+      const pass = s.targetUsers === 1 && s.preciseMerchants === 1;
+      console.log(pass ? "SMOKE PASS" : "SMOKE FAIL");
+      process.exit(pass ? 0 : 1);
+    }
+  } catch {}
+}
+console.log("SMOKE FAIL: /api/stats 未响应");
+process.exit(1);

package/src/clash/checker.js

@@ -5,7 +5,7 @@
  *   1. 检测 Clash Verge 进程/API 存活（跨平台 mac/win）
  *   2. 自动发现代理端口（GET /configs → mixed-port）
  *   3. 节点健康检测（curl 穿透代理请求 TikTok）
- *   4. 国家过滤（按节点名 emoji 匹配）
+ *   4. 国家过滤（全词文本 + emoji 国旗 + 单字方言三层匹配）
  *   5. 健康节点列表持久化 + 故障切换
  *   6. CLI 入口硬门控预检
  */
@@ -311,18 +311,95 @@ export function normalizeCountries(v) {
   return [];
 }
 
-/** 把国家过滤值归一化为匹配模式数组（多国取并集），未知国家自动忽略 */
-function getCountryPatterns(country) {
-  const pats = normalizeCountries(country)
-    .map((c) => COUNTRY_PATTERNS[c])
-    .filter(Boolean);
-  return pats.length ? pats : null;
+// ── 层2：emoji 国旗（全局启用）──
+// 国旗是 regional indicator 成对编码（🇩🇪 = U+1F1E9 U+1F1EA），无歧义，
+// 比节点名文本更可靠。7899/topman 类机场节点名只有国旗或单字缩写
+// （S德🇩🇪56、🇭🇰261008节点、S0港🇭🇰4），全词文本模式全部落空（实测 0/20）。
+// 偏召回设计：公告伪节点误认由 delay 初测淘汰，漏检则永远进不了候选集。
+const FLAG_RE = /[\u{1F1E6}-\u{1F1FF}]{2}/u;
+const FLAG_OFFSET = 0x1f1e6 - 65; // regional indicator → 大写字母
+
+/** emoji 国旗 → ISO 国家码，无旗返回 null */
+export function matchCountryByEmoji(name) {
+  const m = String(name || "").match(FLAG_RE);
+  if (!m) return null;
+  const [a, b] = [...m[0]].map((ch) => ch.codePointAt(0) - FLAG_OFFSET);
+  return String.fromCharCode(a, b);
+}
+
+// ── 层3：单字缩写（按方言门控）──
+// 误伤半径大，仅在检测到方言命名风格的订阅上启用（见 detectSingleCharDialect）。
+// 刻意不含 新/加/印/台/澳 等高歧义单字（新节点/加速器/打印/平台/澳门）
+const SINGLE_CHAR_PATTERNS = {
+  美: "US",
+  英: "GB",
+  法: "FR",
+  德: "DE",
+  日: "JP",
+  韩: "KR",
+  港: "HK",
+  俄: "RU",
+};
+
+// 单字边界：前后不得紧邻其他汉字 —— 放行 "S美🇺🇸86"/"S0港4"/"TEST日🇯🵵10"，
+// 排除全词（"美国"/"香港"，层1已覆盖）与嵌字（"完美网络"不含国家义）
+const SINGLE_CHAR_BOUNDARY_RE = /(^|[^一-鿿])[美德日韩港英法俄](?![一-鿿])/;
+
+// 预编译：国家码 → 单字边界正则数组
+const SINGLE_CHAR_RES = {};
+for (const [ch, c] of Object.entries(SINGLE_CHAR_PATTERNS)) {
+  (SINGLE_CHAR_RES[c] ??= []).push(
+    new RegExp(`(^|[^一-鿿])${ch}(?![一-鿿])`),
+  );
+}
+
+// "仅靠 emoji 可识别（全词文本不命中）"的节点占比 ≥ 阈值 → emoji/单字方言机场。
+// 老机场命名带全词（"🇺🇸美国HY1"）文本层即可命中，占比≈0；topman 类占比 >0.6
+const DIALECT_MIN_RATIO = 0.3;
+const DIALECT_MIN_SAMPLE = 5; // 样本太少不判定，避免小列表误翻转
+
+/**
+ * 方言探测：该订阅是否属于 emoji/单字命名风格（决定单字层是否启用）。
+ * 两路信号取大者：① 仅靠 emoji 可识别（全词文本不命中）占比 —— topman 类；
+ * ② 单字边界风格占比 —— 兼顾无 emoji 纯单字缩写的机场。
+ * 老机场（"🇺🇸美国HY1"）两路占比均≈0，单字层不启用、行为与旧版一致
+ * @param {string[]} nodes 全量节点名
+ */
+function detectSingleCharDialect(nodes) {
+  const usable = (Array.isArray(nodes) ? nodes : []).filter(isUsableProxyNode);
+  if (usable.length < DIALECT_MIN_SAMPLE) return false;
+  let emojiOnly = 0;
+  let singleCharStyle = 0;
+  for (const n of usable) {
+    const code = matchCountryByEmoji(n);
+    const pat = code && COUNTRY_PATTERNS[code];
+    if (pat && !pat.test(n)) emojiOnly++;
+    if (SINGLE_CHAR_BOUNDARY_RE.test(n)) singleCharStyle++;
+  }
+  const ratio = Math.max(emojiOnly, singleCharStyle) / usable.length;
+  return ratio >= DIALECT_MIN_RATIO;
+}
+
+/** 单节点是否命中指定国家的任一匹配层（emoji / 全词文本 / 单字方言） */
+function matchNodeCountry(name, code, useSingleChar) {
+  if (matchCountryByEmoji(name) === code) return true;
+  const pat = COUNTRY_PATTERNS[code];
+  if (pat && pat.test(name)) return true;
+  if (useSingleChar) {
+    for (const re of SINGLE_CHAR_RES[code] || []) {
+      if (re.test(String(name))) return true;
+    }
+  }
+  return false;
 }
 
 export function filterNodesByCountry(nodes, country) {
-  const pats = getCountryPatterns(country);
-  if (!pats) return { filtered: nodes, excluded: 0 };
-  const filtered = nodes.filter((n) => pats.some((p) => p.test(n)));
+  const countries = normalizeCountries(country);
+  if (!countries.length) return { filtered: nodes, excluded: 0 };
+  const useSingleChar = detectSingleCharDialect(nodes);
+  const filtered = nodes.filter((n) =>
+    countries.some((c) => matchNodeCountry(n, c, useSingleChar)),
+  );
   return { filtered, excluded: nodes.length - filtered.length };
 }
 
@@ -349,15 +426,20 @@ const BUILTIN_POLICY_NAMES = new Set([
 const INFO_NODE_PATTERN =
   /剩余|流量|到期|过期|官网|重置|套餐|订阅|工单|[\d.]\s*[KMGTP]B$/i;
 
-/**
- * 判定节点名是否可用作业务出口（内置策略与机场信息节点返回 false）
- * 在候选集写口（runDelayProbe）与读口（loadHealthyList）统一调用
+// []【】()（）注解段。机场常把"实时更新订阅/0倍率/移动优化"等字样放进注解，
+// 主名才是节点标识。信息节点判定只看主名，避免注解关键词误杀真节点
+// （2026-01 生产实锤：S韩🇰🇷55[实时更新订阅]、🇺🇸 2[0倍率][实时更新订阅] 被"订阅"误杀）
+const ANNOTATION_RE = /\[[^\]]*\]|【[^】]*】|\([^)]*\)|（[^）]*）/g;
+
+/** 判定节点名是否可用作业务出口（内置策略与机场信息节点返回 false）
+ *  在候选集写口（runDelayProbe）与读口（loadHealthyList）统一调用
  */
 export function isUsableProxyNode(name) {
   const n = String(name || "").trim();
   if (!n) return false;
   if (BUILTIN_POLICY_NAMES.has(n.toUpperCase())) return false;
-  if (INFO_NODE_PATTERN.test(n)) return false;
+  // 信息节点只看主名：注解里的"订阅/更新"等字样不算（见 ANNOTATION_RE 注释）
+  if (INFO_NODE_PATTERN.test(n.replace(ANNOTATION_RE, " "))) return false;
   return true;
 }
 

package/src/clash/runtime.js

@@ -893,11 +893,32 @@ async function rollbackConfig(content, { index = 1, apiPort, secret } = {}) {
   } catch {}
 }
 
-/** 等待并校验 provider 上线（热应用/接管共用） */
+/**
+ * 强制刷新 provider（绕过 interval 缓存），让新订阅立即生效。
+ * 热加载/接管不会触发 provider 重新拉取：URL 已变但同名缓存未过期（interval 1h 内）时，
+ * 内核沿用旧订阅节点，节点数校验会把旧缓存误判为新订阅上线
+ * （2026-01-11 生产实锤：i3 换订阅后报应用成功，实际最长 1h 仍是旧机场节点）。
+ * 尽力而为：单条失败不报错（机场 URL 暂时不可达等），由后续节点数校验兜底。
+ */
+async function refreshProviders(subs, { apiPort, secret }) {
+  const headers = {};
+  if (secret) headers.Authorization = `Bearer ${secret}`;
+  await Promise.all(
+    subs.map((s) =>
+      fetch(
+        `http://127.0.0.1:${apiPort}/providers/proxies/${encodeURIComponent(s.name)}`,
+        { method: "PUT", headers, signal: AbortSignal.timeout(20_000) },
+      ).catch(() => {}),
+    ),
+  );
+}
+
+/** 等待并校验 provider 上线（热应用/接管共用）：先强刷 provider 再校验，确保校验的是新订阅 */
 export async function verifyProviders(
   subs,
   { apiPort = DISCOVER_DEFAULTS.port, secret = DISCOVER_DEFAULTS.secret, log = () => {}, waitMs = 3000 } = {},
 ) {
+  await refreshProviders(subs, { apiPort, secret });
   await delay(waitMs);
   try {
     const headers = {};

package/src/watch/data-store.js

@@ -657,9 +657,23 @@ function getPreciseMerchantsFromDb(targetLocations = [], options = {}) {
     searchParams.push(`%${search}%`, `%${search}%`);
   }
 
-  const totalRow = getDb()
-    .prepare(`SELECT COUNT(*) AS n FROM jobs WHERE ${where}${searchSql}`)
-    .get(...targetLocations, ...searchParams);
+  // INDEXED BY 强制走精准商家 partial 覆盖索引（候选仅数百行）。无统计信息时
+  // 优化器会误选 idx_jobs_redo_target 全量商家回表（127 万行实测 COUNT 2.6s/次，
+  // 页面 COUNT+LIST 合计 5~6s）。索引不存在的环境（老库未重启）抛
+  // "no such index"，自动回退普通查询
+  let totalRow;
+  try {
+    totalRow = getDb()
+      .prepare(
+        `SELECT COUNT(*) AS n FROM jobs INDEXED BY idx_jobs_precise_merchants WHERE ${where}${searchSql}`,
+      )
+      .get(...targetLocations, ...searchParams);
+  } catch (e) {
+    if (!/no such index/i.test(e.message)) throw e;
+    totalRow = getDb()
+      .prepare(`SELECT COUNT(*) AS n FROM jobs WHERE ${where}${searchSql}`)
+      .get(...targetLocations, ...searchParams);
+  }
   const total = totalRow?.n || 0;
 
   const selectSql = `
@@ -699,21 +713,47 @@ function getPreciseMerchantsFromDb(targetLocations = [], options = {}) {
     ORDER BY product_sold_count DESC, unique_id ASC
   `;
 
+  // 强制 partial 索引（同 COUNT，注释见上）；"FROM jobs" 在 selectSql 中仅出现一次
+  const listSql = (indexed) =>
+    `${selectSql.replace(
+      "FROM jobs",
+      indexed ? "FROM jobs INDEXED BY idx_jobs_precise_merchants" : "FROM jobs",
+    )}`;
+
   if (limit !== undefined) {
     const safeLimit = Math.max(Math.min(Math.floor(limit), 1000), 1);
     const safeOffset = Math.max(Math.floor(offset || 0), 0);
-    const rows = getDb()
-      .prepare(`${selectSql} LIMIT ? OFFSET ?`)
-      .all(...targetLocations, ...searchParams, safeLimit, safeOffset)
-      .map(mapJobRow);
-    return { total, limit: safeLimit, offset: safeOffset, users: rows };
+    let rows;
+    try {
+      rows = getDb()
+        .prepare(`${listSql(true)} LIMIT ? OFFSET ?`)
+        .all(...targetLocations, ...searchParams, safeLimit, safeOffset);
+    } catch (e) {
+      if (!/no such index/i.test(e.message)) throw e;
+      rows = getDb()
+        .prepare(`${listSql(false)} LIMIT ? OFFSET ?`)
+        .all(...targetLocations, ...searchParams, safeLimit, safeOffset);
+    }
+    return {
+      total,
+      limit: safeLimit,
+      offset: safeOffset,
+      users: rows.map(mapJobRow),
+    };
   }
 
-  const rows = getDb()
-    .prepare(selectSql)
-    .all(...targetLocations, ...searchParams)
-    .map(mapJobRow);
-  return { total, users: rows };
+  let allRows;
+  try {
+    allRows = getDb()
+      .prepare(listSql(true))
+      .all(...targetLocations, ...searchParams);
+  } catch (e) {
+    if (!/no such index/i.test(e.message)) throw e;
+    allRows = getDb()
+      .prepare(listSql(false))
+      .all(...targetLocations, ...searchParams);
+  }
+  return { total, users: allRows.map(mapJobRow) };
 }
 
 /**
@@ -1260,10 +1300,18 @@ export function createStore(filePath, options = {}) {
     return data;
   }
 
-  // 空级跳过记忆（claimNextJob 用）：key = "level|国家列表"，value = 首次全 miss 时间。
-  // 某来源级（如 seed）全部国家分支 miss 后，TTL 内跳过该级，避免每次领任务空跑
+  // 空级跳过记忆（claimNextJob 用）：key = "level|登录|国家列表"，value = 首次全
+  // miss 时间。某来源级（含 pinned）全部分支 miss 后，TTL 内跳过该级，避免每次
+  // 领任务空跑
   const levelEmptyCache = new Map();
 
+  // 任务增删/固定等使空池记忆失效的操作调用（前缀匹配，如 "pinned|"）
+  function invalidateClaimEmptyCache(prefix) {
+    for (const key of levelEmptyCache.keys()) {
+      if (key.startsWith(prefix)) levelEmptyCache.delete(key);
+    }
+  }
+
   async function claimNextJob(
     userId,
     expireMs = 5 * 60 * 1000,
@@ -1332,14 +1380,22 @@ export function createStore(filePath, options = {}) {
         : "(status_code IS NULL OR status_code = 0)";
       const notSellerWhere = loggedIn ? "" : "AND COALESCE(tt_seller, 0) != 1";
 
-      const locIn = (list, { includeEmpty = true } = {}) => {
+      // 单国等值分支：等值条件命中 idx_tq_claim_fast 国家表达式列，点查毫秒级。
+      // 勿与空位置 OR 合写——OR 会让国家列失效退化为 fallback 全走
+      //（2026-10-09 生产实测 miss 单分支 2.2s）
+      const locIn = (list) => {
         if (!list || list.length === 0) return null;
         const ph = list.map(() => "?").join(", ");
-        const sql = includeEmpty
-          ? `(UPPER(COALESCE(guessed_location, '')) IN (${ph}) OR COALESCE(guessed_location, '') = '')`
-          : `UPPER(COALESCE(guessed_location, '')) IN (${ph})`;
-        return { sql, params: [...list] };
+        return {
+          sql: `UPPER(COALESCE(guessed_location, '')) IN (${ph})`,
+          params: [...list],
+        };
       };
+      // 空位置等值分支：同样走 fast 索引点查（实测 9ms）
+      const locEmpty = () => ({
+        sql: `UPPER(COALESCE(guessed_location, '')) = ''`,
+        params: [],
+      });
       const locNotIn = (list) => {
         if (!list || list.length === 0) return null;
         const ph = list.map(() => "?").join(", ");
@@ -1370,16 +1426,30 @@ export function createStore(filePath, options = {}) {
         branches.push({ conditions, params });
       };
 
-      // prio 0: pinned + hasVideo
-      addBranch(
-        `status = 'pending' AND pinned = 1 AND video_count > 0 ${pinnedLocSql} AND ${statusCodeWhere} ${notSellerWhere}`,
-        pinnedLocParams,
-      );
-      // prio 1: pinned (no video req)
-      addBranch(
-        `status = 'pending' AND pinned = 1 ${pinnedLocSql} AND ${statusCodeWhere} ${notSellerWhere}`,
-        pinnedLocParams,
-      );
+      // 空级跳过记忆 TTL：池子空了没必要每次领任务都空跑全量分支
+      //（2026-09-29 实测 seed 空级每次烧 1.4s CPU；2026-10-09 实测 pinned 空池
+      // 每条分支全走 32 万行 2.1s）。TTL 过期后恢复探测一次——补进新任务即可自动恢复。
+      const LEVEL_EMPTY_TTL = 60 * 1000;
+
+      // prio 0/1: pinned + hasVideo / pinned。pinned=1 无可用排序索引（列表索引
+      // 列序不匹配 ORDER BY），池空时每条分支必全走确认 miss 且原本不在空级缓存内，
+      // 每次领取固定烧 ~4.3s → 纳入空池记忆，TTL 内整体跳过；togglePin/resetJob 主动失效
+      const pinnedEmptyKey = `pinned|${loggedIn ? 1 : 0}|${orderedCountries.join(",")}`;
+      const pinnedEmptySince = levelEmptyCache.get(pinnedEmptyKey);
+      const skipPinned =
+        pinnedEmptySince != null && now - pinnedEmptySince < LEVEL_EMPTY_TTL;
+      if (!skipPinned) {
+        // prio 0: pinned + hasVideo
+        addBranch(
+          `status = 'pending' AND pinned = 1 AND video_count > 0 ${pinnedLocSql} AND ${statusCodeWhere} ${notSellerWhere}`,
+          pinnedLocParams,
+        );
+        // prio 1: pinned (no video req)
+        addBranch(
+          `status = 'pending' AND pinned = 1 ${pinnedLocSql} AND ${statusCodeWhere} ${notSellerWhere}`,
+          pinnedLocParams,
+        );
+      }
 
       // prio 2-3: expired candidate（回收的超时任务优先）
       if (expiredCandidate) {
@@ -1414,14 +1484,14 @@ export function createStore(filePath, options = {}) {
       ];
 
       // 空级跳过记忆：某来源级（如 seed）全部国家分支 miss 后，记录时间；
-      // TTL 内该级整体跳过（池子空了没必要每次领任务都空跑 24国×2 条查询，
-      // 2026-09-29 实测 seed 空级每次烧 1.4s CPU 是 watch 饱和主因）。
-      // TTL 过期后恢复探测一次——refill 补进新任务即可自动恢复。
-      const LEVEL_EMPTY_TTL = 60 * 1000;
+      // TTL 内该级整体跳过。TTL 过期后恢复探测一次——refill 补进新任务即可自动恢复。
+      // key 含登录态：未登录（过滤更严，无 209002/商家）miss 不代表登录端 miss，
+      // 避免未登录轮污染登录端记忆
+      const levelKeyOf = (name) =>
+        `${name}|${loggedIn ? 1 : 0}|${orderedCountries.join(",")}`;
       for (const p of priorities) {
         if (p.loggedInOnly && !loggedIn) continue;
-        const levelKey = `${p.name}|${orderedCountries.join(",")}`;
-        const emptySince = levelEmptyCache.get(levelKey);
+        const emptySince = levelEmptyCache.get(levelKeyOf(p.name));
         if (emptySince && now - emptySince < LEVEL_EMPTY_TTL) {
           p.skip = true; // 标记跳过，下面构建分支时跳过
         }
@@ -1431,12 +1501,15 @@ export function createStore(filePath, options = {}) {
       for (const p of priorities) {
         if (p.loggedInOnly && !loggedIn) continue;
         if (p.skip) continue;
-        // 逐国顺序分支：配置内国家按优先级顺序；未传子集时末尾补“配置外国家”兑底。
-        // 空位置（loc=''）只在首个国家的分支参与：首国的 noVideoReq 分支 miss 即意味着
-        // 空位置池已耗尽，后续分支无需再 OR ''（避免反复扫描空位置大池）
-        const locationBranches = orderedCountries.map((loc, idx) =>
-          locIn([loc], { includeEmpty: idx === 0 }),
-        );
+        // 逐国顺序分支：配置内国家按优先级顺序；未传子集时末尾补“配置外国家”兜底。
+        // 空位置（loc=''）拆为独立等值分支、只挂首国：原 OR 合写毁掉 fast 索引国家列
+        // 退化为 fallback 全走（2026-10-09 实测 miss 2.2s/次），拆分后 IN 3ms / ='' 9ms。
+        // 同层内首国等值严格优先于空位置（原为并集按粉丝竞争，属行为微调已确认可接受）
+        const locationBranches = [];
+        orderedCountries.forEach((loc, idx) => {
+          locationBranches.push(locIn([loc]));
+          if (idx === 0) locationBranches.push(locEmpty());
+        });
         if (normalizedLocations.length === 0)
           locationBranches.push(locNotIn(orderedCountries));
         // 商家级专用（sellerAnyCountry）：国家对商家放开——末尾追加"任意国家"分支。
@@ -1444,6 +1517,9 @@ export function createStore(filePath, options = {}) {
         // 未传国家时同理（配置内各国 → 配置外 → 任意）。其他来源级分支不受影响。
         if (p.sellerAnyCountry) locationBranches.push(null); // null → 任意国家分支
         p._branchStart = branches.length; // 记录该级分支区间（用于判空）
+        // 每个位置描述符产出 hasVideo + noVideoReq 两条分支（国家层为主序、
+        // 是否要求视频为层内次序，与原版一致）：首国等值 → 首国空位置 →
+        // 其余配置内国家 → 配置外兜底 → 商家任意国家
         let subPrio = 0;
         for (const loc of locationBranches) {
           // 商家任意国家分支：不限 guessed_location（含空位置的商家）
@@ -1499,10 +1575,15 @@ export function createStore(filePath, options = {}) {
       // 空级写入 levelEmptyCache（TTL 内下次领取直接跳过），命中级清除记忆
       // bi = 命中分支下标（未命中则停在 branches.length）
       const hitIdx = bi;
+      // pinned 空池记忆：仅当 pinned 分支本轮真实执行时更新（跳过轮保留原记忆）
+      if (!skipPinned) {
+        if (hitIdx >= 2) levelEmptyCache.set(pinnedEmptyKey, now);
+        else levelEmptyCache.delete(pinnedEmptyKey);
+      }
       for (const p of priorities) {
         if (p.loggedInOnly && !loggedIn) continue;
         if (p._branchStart == null) continue; // 被 skip 跳过的级无分支，保留原记忆
-        const levelKey = `${p.name}|${orderedCountries.join(",")}`;
+        const levelKey = levelKeyOf(p.name);
         if (hitIdx >= p._branchEnd) levelEmptyCache.set(levelKey, now);
         else levelEmptyCache.delete(levelKey);
       }
@@ -2292,6 +2373,7 @@ export function createStore(filePath, options = {}) {
           .run(uniqueId);
       }
       markStatsDirty();
+      invalidateClaimEmptyCache("pinned|");
       return { saved: true };
     }
 
@@ -2323,6 +2405,7 @@ export function createStore(filePath, options = {}) {
         tableName,
       );
       if (ret.error) return { saved: false, error: ret.error };
+      invalidateClaimEmptyCache("pinned|");
       return { saved: true, pinned: nextPinned };
     }
 

package/src/watch/server.js

@@ -84,44 +84,25 @@ const STAT_GROUPS = {
         FROM task_queue`,
       },
       {
-        key: "jobsAgg",
+        // 目标商家计数（仪表盘"目标商家"卡片 + 烟花动画的数据源）：
+        // tt_seller+verified+location 三列条件完全被 idx_jobs_seller_verified_loc
+        // 覆盖，纯索引扫描无回表（127 万行实测 140ms），30s 级刷新无压力。
+        // 原随 jobsAgg 在 slow 组（5 分钟 TTL）导致烟花延迟数分钟
+        key: "targetUsersCount",
         mode: "one",
         params: () => getTargetLocations(),
-        sql: () => `SELECT
-          SUM(jobsTotal) as jobsTotal,
-          SUM(done) as done,
-          SUM(error) as error,
-          SUM(restricted) as restricted,
-          SUM(targetUsers) as targetUsers,
-          SUM(noVideo) as noVideo
-        FROM (
-          SELECT
-            COUNT(*) as jobsTotal,
-            SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END) as done,
-            SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as error,
-            SUM(CASE WHEN status = 'restricted' THEN 1 ELSE 0 END) as restricted,
-            SUM(CASE WHEN tt_seller = 1 AND verified = 0 AND ${targetInSql()} THEN 1 ELSE 0 END) as targetUsers,
-            SUM(CASE WHEN no_video = 1 THEN 1 ELSE 0 END) as noVideo
-          FROM jobs
-          UNION ALL
-          -- jobs_done 冷归档表：全部是 done 且只增不改。改用覆盖索引/部分索引计数，
-          -- 避免对 147 万行全表回表（原 SUM(CASE WHEN no_video=1) 无法匹配索引）
-          SELECT
-            c.cnt as jobsTotal,
-            c.cnt as done,
-            0 as error,
-            0 as restricted,
-            0 as targetUsers,
-            (SELECT COUNT(*) FROM jobs_done WHERE no_video = 1) as noVideo
-          FROM (SELECT COUNT(*) as cnt FROM jobs_done) c
-        )`,
+        sql: () => `SELECT COUNT(*) AS n FROM jobs
+          WHERE tt_seller = 1 AND verified = 0 AND ${targetInSql()}`,
       },
       {
         // 精确商家计数：目标商家 + 7 天 EC 视频播放>1000 + 有商品 + 评论0 + 销量>10
+        // INDEXED BY 强制走 idx_jobs_precise_merchants partial 覆盖索引（候选仅数
+        // 百行，毫秒级）：曾因 12.1s/次迁入 slow 组（5 分钟 TTL）导致卡片 5 分钟
+        // 才刷一次，索引修复后移回 fast 组恢复 30s 级。索引缺失时置空降级为 0
         key: "preciseMerchants",
         mode: "one",
         params: () => getTargetLocations(),
-        sql: () => `SELECT COUNT(*) AS n FROM jobs
+        sql: () => `SELECT COUNT(*) AS n FROM jobs INDEXED BY idx_jobs_precise_merchants
           WHERE tt_seller = 1 AND verified = 0 AND ${targetInSql()}
             AND top_video_seo_url IS NOT NULL AND top_video_seo_url != ''
             AND product_review_count = 0
@@ -132,10 +113,40 @@ const STAT_GROUPS = {
               WHERE CAST(json_extract(value, '$.playCount') AS INTEGER) > 1000
             )`,
       },
+      {
+        // 已完成/限制/错误计数（仪表盘三个状态卡片）：走部分索引覆盖计数，
+        // 索引只含对应状态的行（idx_jobs_list_done/error/restricted，
+        // WHERE status='xxx' 与查询条件完全匹配），127 万行毫秒级。
+        // 原随 jobsAgg 在 slow 组（5 分钟 TTL），2026-10-09 起错误卡片 5 分钟
+        // 才刷一次；拆出后恢复 30s 级。索引缺失查询失败时回退 slow 组 jobsAgg
+        key: "doneCount",
+        mode: "one",
+        sql: `SELECT (SELECT COUNT(*) FROM jobs INDEXED BY idx_jobs_list_done WHERE status = 'done')
+          + (SELECT COUNT(*) FROM jobs_done) AS n`,
+      },
+      {
+        key: "restrictedCount",
+        mode: "one",
+        sql: "SELECT COUNT(*) AS n FROM jobs INDEXED BY idx_jobs_list_restricted WHERE status = 'restricted'",
+      },
+      {
+        key: "errorCount",
+        mode: "one",
+        sql: "SELECT COUNT(*) AS n FROM jobs INDEXED BY idx_jobs_list_error WHERE status = 'error'",
+      },
     ],
     combine(results) {
       const tq = results.tqAgg || {};
-      const jb = results.jobsAgg || {};
+      // jobs 域轻量计数 done/error/restricted 已拆出为 fast 组独立计数
+      // （部分索引覆盖计数，毫秒级，30s 级刷新）；jobsAgg 仍在 slow 组提供
+      // jobsTotal（总用户）/noVideo，并作为拆出计数查询失败时的回退源。
+      // 未就绪时回退 0。
+      const slow = groupState.slow?.cache || {};
+      const jb = slow.jobsAgg || {};
+      const done = results.doneCount?.n != null ? results.doneCount.n : jb.done || 0;
+      const restricted =
+        results.restrictedCount?.n != null ? results.restrictedCount.n : jb.restricted || 0;
+      const error = results.errorCount?.n != null ? results.errorCount.n : jb.error || 0;
       const total = (tq.tqTotal || 0) + (jb.jobsTotal || 0);
       return {
         totalUsers: total,
@@ -143,10 +154,10 @@ const STAT_GROUPS = {
         jobsPending: tq.pending || 0,
         pendingUsers: tq.pending || 0,
         processingUsers: tq.processing || 0,
-        processedUsers: jb.done || 0,
-        restrictedUsers: jb.restricted || 0,
-        errorUsers: jb.error || 0,
-        targetUsers: jb.targetUsers || 0,
+        processedUsers: done,
+        restrictedUsers: restricted,
+        errorUsers: error,
+        targetUsers: results.targetUsersCount?.n || 0,
         preciseMerchants: results.preciseMerchants?.n || 0,
         sourceStats: {
           seed: tq.seed || 0,
@@ -155,9 +166,9 @@ const STAT_GROUPS = {
           guess: tq.guess || 0,
           following: tq.following || 0,
           follower: tq.follower || 0,
-          processed: jb.done || 0,
-          restricted: jb.restricted || 0,
-          error: jb.error || 0,
+          processed: done,
+          restricted: restricted,
+          error: error,
           noVideo: jb.noVideo || 0,
         },
       };
@@ -222,12 +233,50 @@ const STAT_GROUPS = {
   slow: {
     ttl: SLOW_STATS_TTL,
     // rawJobs 走 store.getRawJobsCount()（模块内部自带 60s 缓存），不进分片 SQL
+    // jobsAgg 自 fast 组迁入：jobs 表百万行级后单次 ~3.3s，只适合 5 分钟级刷新
+    // （fast 组 combine 从本组缓存读取）。targetUsers/preciseMerchants 已拆出
+    // 走覆盖索引回 fast 组（详见 fast 组注释）；done/error/restricted 也已拆出
+    // 为部分索引轻量计数（详见 fast 组注释），jobsAgg 保留全量聚合作为回退源，
+    // 并继续提供 jobsTotal（总用户）/noVideo（jobs 侧无匹配索引，保持 5 分钟级）
     sqls: [
       {
         key: "commentTaskCount",
         mode: "one",
         sql: "SELECT COUNT(*) as c FROM videos WHERE user_update_count IS NULL OR user_update_count <= 0",
       },
+      {
+        key: "jobsAgg",
+        mode: "one",
+        params: () => getTargetLocations(),
+        sql: () => `SELECT
+          SUM(jobsTotal) as jobsTotal,
+          SUM(done) as done,
+          SUM(error) as error,
+          SUM(restricted) as restricted,
+          SUM(targetUsers) as targetUsers,
+          SUM(noVideo) as noVideo
+        FROM (
+          SELECT
+            COUNT(*) as jobsTotal,
+            SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END) as done,
+            SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as error,
+            SUM(CASE WHEN status = 'restricted' THEN 1 ELSE 0 END) as restricted,
+            SUM(CASE WHEN tt_seller = 1 AND verified = 0 AND ${targetInSql()} THEN 1 ELSE 0 END) as targetUsers,
+            SUM(CASE WHEN no_video = 1 THEN 1 ELSE 0 END) as noVideo
+          FROM jobs
+          UNION ALL
+          -- jobs_done 冷归档表：全部是 done 且只增不改。改用覆盖索引/部分索引计数，
+          -- 避免对 147 万行全表回表（原 SUM(CASE WHEN no_video=1) 无法匹配索引）
+          SELECT
+            c.cnt as jobsTotal,
+            c.cnt as done,
+            0 as error,
+            0 as restricted,
+            0 as targetUsers,
+            (SELECT COUNT(*) FROM jobs_done WHERE no_video = 1) as noVideo
+          FROM (SELECT COUNT(*) as cnt FROM jobs_done) c
+        )`,
+      },
     ],
     combine(results, st) {
       // tagCount/tagHighScore 从独立 tags.db 读取（跨库）
@@ -249,6 +298,15 @@ const STAT_GROUPS = {
       return {
         rawJobs: st.getRawJobsCount ? st.getRawJobsCount() : 0,
         commentTaskCount: results.commentTaskCount?.c || 0,
+        // jobs 域聚合（供 fast 组 combine 读取，字段保持展开后的形态）
+        jobsAgg: {
+          jobsTotal: results.jobsAgg?.jobsTotal || 0,
+          done: results.jobsAgg?.done || 0,
+          error: results.jobsAgg?.error || 0,
+          restricted: results.jobsAgg?.restricted || 0,
+          targetUsers: results.jobsAgg?.targetUsers || 0,
+          noVideo: results.jobsAgg?.noVideo || 0,
+        },
         tagCount,
         tagHighScore,
       };
@@ -595,6 +653,12 @@ export function startWatchServer(
         // precheck 候选查询部分索引：预缩候选集且天然按 refresh_time 有序，
         // 消除 TEMP B-TREE 排序（76 万行实测 ~1s → 毫秒级）
         "CREATE INDEX IF NOT EXISTS idx_jobs_precheck ON jobs(refresh_time) WHERE tt_seller = 1 AND verified = 0 AND (pending_refresh IS NULL OR pending_refresh = 0)",
+        // 精准商家（目标商家页 + stats 计数）部分覆盖索引：WHERE 收录查询全部
+        // 便宜过滤条件，候选集从 jobs 全量商家（2026-10 已 127 万行）预缩到数百行，
+        // COUNT/LIST 由 127 万次回表（实测 COUNT 2.6s）降到毫秒级。
+        // ⚠️ WHERE 文本必须与 getPreciseMerchantsFromDb / stats preciseMerchants
+        // 查询逐词一致（SQLite 按术语文本匹配 partial index），改查询需同步改这里
+        "CREATE INDEX IF NOT EXISTS idx_jobs_precise_merchants ON jobs(location_created, product_sold_count DESC, unique_id) WHERE tt_seller = 1 AND verified = 0 AND top_video_seo_url IS NOT NULL AND top_video_seo_url != '' AND product_review_count = 0 AND product_sold_count > 10 AND recent_ec_videos IS NOT NULL AND recent_ec_videos != ''",
       ];
       for (const sql of ensureIdx) {
         try {