tt-help-cli-ycl 1.4.166 → 1.4.168

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,6 +1300,18 @@ export function createStore(filePath, options = {}) {
     return data;
   }
 
+  // 空级跳过记忆（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,
@@ -1328,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(", ");
@@ -1366,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) {
@@ -1391,36 +1465,61 @@ export function createStore(filePath, options = {}) {
       // 非 pinned 优先级：seed → seller → follow → other，每级 × 3 个 location tier × (hasVideo / noVideoReq)
       const priorities = [
         {
+          name: "seed",
           filter: `instr(COALESCE(sources, ''), '"seed"') > 0`,
           loggedInOnly: false,
         },
         {
+          name: "seller",
           filter: `tt_seller = 1 AND verified = 0`,
           loggedInOnly: true,
           sellerAnyCountry: true,
         },
         {
+          name: "follow",
           filter: `(instr(COALESCE(sources, ''), '"following"') > 0 OR instr(COALESCE(sources, ''), '"follower"') > 0 OR instr(COALESCE(sources, ''), '"comment"') > 0)`,
           loggedInOnly: false,
         },
-        { filter: `1 = 1`, loggedInOnly: false },
+        { name: "other", filter: `1 = 1`, loggedInOnly: false },
       ];
 
+      // 空级跳过记忆：某来源级（如 seed）全部国家分支 miss 后，记录时间；
+      // 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 emptySince = levelEmptyCache.get(levelKeyOf(p.name));
+        if (emptySince && now - emptySince < LEVEL_EMPTY_TTL) {
+          p.skip = true; // 标记跳过，下面构建分支时跳过
+        }
+      }
+
       let basePrio = 4;
       for (const p of priorities) {
         if (p.loggedInOnly && !loggedIn) continue;
-        // 逐国顺序分支：配置内国家按优先级顺序；未传子集时末尾补“配置外国家”兑底。
-        // 空位置（loc=''）只在首个国家的分支参与：首国的 noVideoReq 分支 miss 即意味着
-        // 空位置池已耗尽，后续分支无需再 OR ''（避免反复扫描空位置大池）
-        const locationBranches = orderedCountries.map((loc, idx) =>
-          locIn([loc], { includeEmpty: idx === 0 }),
-        );
+        if (p.skip) continue;
+        // 逐国顺序分支：配置内国家按优先级顺序；未传子集时末尾补“配置外国家”兜底。
+        // 空位置（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）：国家对商家放开——末尾追加"任意国家"分支。
         // 传了国家子集时对应国家的商家仍优先，领完再兜任意国家（含空位置商家）；
         // 未传国家时同理（配置内各国 → 配置外 → 任意）。其他来源级分支不受影响。
         if (p.sellerAnyCountry) locationBranches.push(null); // null → 任意国家分支
+        p._branchStart = branches.length; // 记录该级分支区间（用于判空）
+        // 每个位置描述符产出 hasVideo + noVideoReq 两条分支（国家层为主序、
+        // 是否要求视频为层内次序，与原版一致）：首国等值 → 首国空位置 →
+        // 其余配置内国家 → 配置外兜底 → 商家任意国家
         let subPrio = 0;
         for (const loc of locationBranches) {
           // 商家任意国家分支：不限 guessed_location（含空位置的商家）
@@ -1453,12 +1552,16 @@ export function createStore(filePath, options = {}) {
           );
           subPrio++;
         }
+        p._branchEnd = branches.length;
         basePrio += 2;
       }
 
-      // 逐级执行：首个命中分支的最优行即领取结果（未命中继续下一优先级分支）
+      // 逐级执行：首个命中分支的最优行即领取结果（未命中继续下一优先级分支）。
+      // 同时记录哪些来源级全部 miss → 写入 levelEmptyCache（下次领取 TTL 内直接跳过该级）
       let selectedRow = null;
-      for (const b of branches) {
+      let bi = 0;
+      for (; bi < branches.length; bi++) {
+        const b = branches[bi];
         selectedRow =
           getDb()
             .prepare(
@@ -1468,6 +1571,23 @@ export function createStore(filePath, options = {}) {
         if (selectedRow) break;
       }
 
+      // 记录空级：分支按优先级顺序执行，命中所处级之前的所有来源级必然全 miss；
+      // 空级写入 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 = levelKeyOf(p.name);
+        if (hitIdx >= p._branchEnd) levelEmptyCache.set(levelKey, now);
+        else levelEmptyCache.delete(levelKey);
+      }
+
       if (selectedRow) {
         getDb()
           .prepare(
@@ -2253,6 +2373,7 @@ export function createStore(filePath, options = {}) {
           .run(uniqueId);
       }
       markStatsDirty();
+      invalidateClaimEmptyCache("pinned|");
       return { saved: true };
     }
 
@@ -2284,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 {