candidate-pool 2.1.1 → 3.0.0

package/eod/lib/preopen_rules.js

@@ -0,0 +1,190 @@
+'use strict';
+/*
+ * eod/lib/preopen_rules.js —— 盘前选股规则引擎（纯函数，零副作用，可单测）
+ * ---------------------------------------------------------------------------
+ * 与 rules.js 同范式：所有计算函数入参为数据、出参为结果，不读网络、不改全局。
+ * 三类信号：
+ *   - P01 竞价强势：今开 vs 昨收的高开幅度 + 竞价量能比（竞价量 / 昨日量）
+ *   - P02 弱转强/超预期：昨日涨幅(强势门槛) + 今日竞价高开区间 → 超预期/符合/不及预期
+ *   - P03 趋势跟踪：均线多头 + N日新高 + 斜率（来自前一日 K 线）
+ *
+ * 输入数据约定：
+ *   - quote：腾讯报价解析对象（market.parseQuote 产出），含 open/prevClose/vol/chgPct 等
+ *   - kline.rows：前复权日K，【降序】最新在前，每根 { date, open, close, high, low, vol }
+ *     锚定日 = 最近已收盘交易日（lastClosedTradingDay），rows[0] 即昨日 bar
+ * ---------------------------------------------------------------------------
+ */
+
+function clamp01(v) { return Math.max(0, Math.min(1, v)); }
+/** 线性映射 0..1；v 为空返回 0（缺数据不猜值） */
+function lin(v, lo, hi) {
+  if (v == null || !Number.isFinite(v)) return 0;
+  if (hi === lo) return v >= hi ? 1 : 0;
+  return clamp01((v - lo) / (hi - lo));
+}
+
+// ---------- 趋势计算（P03）----------
+/**
+ * 由日K（降序）计算趋势指标。
+ * @returns {object} { ma5..ma60, maBull, newHigh20, newHigh60, slope20(%/日), volPriceUp }
+ */
+function calcTrend(rowsDesc, cfg) {
+  const closes = rowsDesc.map((r) => r.close).reverse(); // 升序：最旧在前
+  const n = closes.length;
+  const out = { ma5: null, ma10: null, ma20: null, ma60: null, maBull: false, newHigh20: false, newHigh60: false, slope20: null, volPriceUp: false };
+  if (n < 5) return out;
+
+  const ma = (k) => (n >= k ? closes.slice(n - k).reduce((a, b) => a + b, 0) / k : null);
+  out.ma5 = ma(5);
+  out.ma10 = ma(10);
+  out.ma20 = ma(20);
+  out.ma60 = ma(60);
+
+  // 均线多头：MA5>MA10>MA20>MA60（各周期数据齐备才判定）
+  if (out.ma5 != null && out.ma10 != null && out.ma20 != null && out.ma60 != null) {
+    out.maBull = out.ma5 > out.ma10 && out.ma10 > out.ma20 && out.ma20 > out.ma60;
+  }
+
+  // N 日新高：昨日收盘为近 N 日最高
+  const last20 = closes.slice(n - Math.min(20, n));
+  const last60 = closes.slice(n - Math.min(60, n));
+  out.newHigh20 = closes[n - 1] >= Math.max(...last20);
+  out.newHigh60 = n >= 60 ? closes[n - 1] >= Math.max(...last60) : false;
+
+  // 斜率：近 20 日收盘价 OLS 回归斜率，折算 %/日（相对均值）
+  if (n >= 20) {
+    const w = closes.slice(n - 20);
+    const x = w.map((_, i) => i);
+    const xm = x.reduce((a, b) => a + b, 0) / 20;
+    const ym = w.reduce((a, b) => a + b, 0) / 20;
+    let num = 0, den = 0;
+    for (let i = 0; i < 20; i++) { num += (x[i] - xm) * (w[i] - ym); den += (x[i] - xm) ** 2; }
+    const slope = den ? num / den : 0;          // 绝对斜率（元/日）
+    out.slope20 = ym ? (slope / ym) * 100 : 0;   // %/日
+  }
+
+  // 量价齐升（近 5 日）：上涨日占比 ≥ 60%
+  if (n >= 6) {
+    const recent = rowsDesc.slice(0, 5); // 降序最新 5 日
+    const ups = recent.filter((r, i) => i < recent.length - 1 && r.close >= rowsDesc[i + 1].close).length;
+    out.volPriceUp = ups / Math.max(1, recent.length - 1) >= 0.6;
+  }
+  return out;
+}
+
+// ---------- 基线（前一日 K 线指标）----------
+/**
+ * 由 K 线计算「前一日」基线：昨日涨幅、昨日成交量、趋势。
+ * @param {object} kline  { rows: 降序日K, today, hist }（fetchKline 产出）
+ * @returns {object|null} { yesterdayChgPct, yesterdayVol, trend }
+ */
+function calcBaseline(kline, code, cfg) {
+  const rows = (kline && kline.rows) || [];
+  if (!rows.length) return null;
+  const y = rows[0];                 // 昨日 bar
+  const prior = rows[1];             // 前日 bar
+  let yesterdayChgPct = null;
+  if (y && prior && prior.close > 0) {
+    yesterdayChgPct = (y.close / prior.close - 1) * 100;
+  }
+  const yesterdayVol = y ? y.vol : null; // 手（与竞价量同口径）
+  const trend = calcTrend(rows, cfg);
+  return { code, yesterdayChgPct, yesterdayVol, trend };
+}
+
+// ---------- P01 竞价强势 ----------
+function calcP1(quote, baseline, cfg) {
+  const p = cfg.rules.p1;
+  const prevClose = quote.prevClose;
+  const open = quote.open;
+  let auctionChgPct = null;
+  if (prevClose > 0 && open != null && open > 0) {
+    auctionChgPct = (open / prevClose - 1) * 100;
+  }
+  // 竞价量能比 = 竞价成交量 / 昨日全天成交量（同口径，免单位换算）
+  let auctionVolRatio = null;
+  const yVol = baseline && baseline.yesterdayVol;
+  if (quote.vol != null && yVol) auctionVolRatio = quote.vol / yVol;
+
+  const highOpen = auctionChgPct != null && auctionChgPct >= p.auctionChgMin;
+  const nearLimit = auctionChgPct != null && auctionChgPct >= p.auctionChgLimit;
+  const volOk = auctionVolRatio != null && auctionVolRatio >= p.auctionVolRatioMin;
+
+  // 打分：高开幅度(0.6) + 量能比(0.4)；未高开则 0 分
+  const sChg = lin(auctionChgPct, p.auctionChgMin, p.auctionChgLimit);
+  const sVol = lin(auctionVolRatio, p.auctionVolRatioMin, p.auctionVolRatioFull);
+  const score = highOpen ? 0.6 * sChg + 0.4 * sVol : 0;
+
+  return {
+    auctionChgPct, auctionVolRatio, highOpen, nearLimit, volOk,
+    score, ok: highOpen && volOk,
+  };
+}
+
+// ---------- P02 弱转强 / 超预期 ----------
+function calcP2(quote, baseline, cfg) {
+  const p = cfg.rules.p2;
+  const yChg = baseline ? baseline.yesterdayChgPct : null;
+  // 竞价涨幅复用 P1 的计算（调用方传入，避免重复）
+  const aChg = quote.__auctionChgPct != null ? quote.__auctionChgPct : null;
+  const applicable = yChg != null && yChg >= p.yesterdayStrong;
+
+  let verdict = '非强势股';
+  let score = 0;
+  let risk = false;
+  if (applicable && aChg != null) {
+    if (aChg >= p.exceed) {
+      verdict = aChg >= p.yesterdayLimit ? '超预期·涨停预期' : '超预期·高开';
+      score = 1.0;
+    } else if (aChg >= p.expectLow) {
+      verdict = '符合预期·健康高开';
+      score = 0.7;
+    } else if (aChg >= 0) {
+      verdict = '偏弱高开';
+      score = 0.3;
+    } else {
+      verdict = '不及预期·核按钮';
+      score = 0.0;
+      risk = true;
+    }
+  }
+  return { yesterdayChgPct: yChg, auctionChgPct: aChg, applicable, verdict, score, risk };
+}
+
+// ---------- P03 趋势跟踪 ----------
+function calcP3(baseline, cfg) {
+  const p = cfg.rules.p3;
+  const t = (baseline && baseline.trend) || {};
+  const slope = t.slope20;
+  const sSlope = lin(slope, p.slopeMinPerDay, p.slopeFullPerDay);
+  const sHigh = (t.newHigh20 ? 1 : 0) * 0.3 + (t.newHigh60 ? 1 : 0) * 0.2;
+  // 权重：多头 0.4 + 新高 0.3(20日0.3+60日0.2取含) + 斜率 0.3
+  const score = (t.maBull ? 0.4 : 0) + Math.min(0.3, sHigh) + 0.3 * sSlope;
+  return { ...t, score: clamp01(score), ok: !!t.maBull };
+}
+
+// ---------- 综合打分 ----------
+function scorePreopen(p1, p2, p3, cfg) {
+  const w = cfg.score.weights;
+  const items = { p1: p1.score, p2: p2.score, p3: p3.score };
+  const total = w.p1 * items.p1 + w.p2 * items.p2 + w.p3 * items.p3;
+  return { total, items };
+}
+
+/** 由三项结果推导一句话标签（报告/通知用） */
+function labelOf(p1, p2, p3) {
+  if (p2.verdict && p2.verdict.startsWith('超预期')) return '超预期';
+  if (p2.verdict === '符合预期·健康高开') return '弱转强·符合';
+  if (p2.verdict === '不及预期·核按钮') return '不及预期·风险';
+  if (p1.nearLimit) return '竞价涨停';
+  if (p1.highOpen && p3.ok) return '竞价强+趋势';
+  if (p1.highOpen) return '竞价强势';
+  if (p3.ok) return '趋势向上';
+  return '观察';
+}
+
+module.exports = {
+  clamp01, lin,
+  calcTrend, calcBaseline,
+  calcP1, calcP2, calcP3, scorePreopen, labelOf,
+};

package/eod/lib/preopen_store.js

@@ -0,0 +1,96 @@
+'use strict';
+/*
+ * eod/lib/preopen_store.js —— 盘前选股落库（JSON 归档，溯源用）
+ * ---------------------------------------------------------------------------
+ * 一天一份文件：preopen/data/preopen-YYYYMMDD.json
+ *   - records: code -> 候选明细（含 P1/P2/P3 分项、基线、标签、总分）
+ *   - runs[]: 当日多次运行留痕（幂等：同文件整文件覆盖，records 按 code 唯一）
+ *   - close：收盘回填后追加当日收盘/涨跌幅/是否涨停/命中标记（preopen_backfill.js）
+ *
+ * 与 tail store 解耦：盘前数据既要「开盘快照」又要「收盘回填」，结构不同，独立维护。
+ * ---------------------------------------------------------------------------
+ */
+const fs = require('fs');
+const path = require('path');
+const paths = require('../../paths');
+
+function dataFile(cfg, tradeDate) {
+  return path.join(paths.eodDir(), cfg.store.dataDir, `${cfg.store.prefix}-${tradeDate}.json`);
+}
+
+/** 读已有归档（无则返回 null） */
+function loadRun(cfg, tradeDate) {
+  const f = dataFile(cfg, tradeDate);
+  if (!fs.existsSync(f)) return null;
+  try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch (e) { return null; }
+}
+
+/**
+ * 落库（幂等：同文件整文件覆盖，runs[] 追加本次运行）。
+ * @param {object} p { cfg, tradeDate, scope, candidates, meta, marketDate }
+ * @returns {{file, recordCount, runCount}}
+ */
+function saveRun({ cfg, tradeDate, scope, candidates, meta, marketDate }) {
+  const dir = path.join(paths.eodDir(), cfg.store.dataDir);
+  fs.mkdirSync(dir, { recursive: true });
+  const f = dataFile(cfg, tradeDate);
+
+  const prev = loadRun(cfg, tradeDate) || {};
+  const records = prev.records || {};
+  for (const c of candidates) records[c.code] = c;
+
+  const runs = prev.runs || [];
+  runs.push({
+    at: new Date().toISOString(),
+    count: candidates.length,
+    codes: candidates.map((c) => c.code),
+  });
+  if (runs.length > cfg.store.keepRunHistory) runs.splice(0, runs.length - cfg.store.keepRunHistory);
+
+  const doc = {
+    tradeDate,
+    scope: scope || cfg.scope.default,
+    mode: 'preopen',
+    generatedAt: new Date().toISOString(),
+    marketDate,
+    meta: Object.assign({}, meta, { recordCount: Object.keys(records).length, runCount: runs.length }),
+    runs,
+    // 保留历史回填结果（若有）
+    close: prev.close || null,
+    records,
+  };
+  fs.writeFileSync(f, JSON.stringify(doc, null, 2), 'utf8');
+  return { file: f, recordCount: doc.meta.recordCount, runCount: runs.length };
+}
+
+/**
+ * 收盘回填：把当日收盘数据合并进归档（不重建候选，只追加 close 段）。
+ * @param {object} closeMap  code -> { close, dayChgPct, limitUp, hit }
+ */
+function mergeBackfill(cfg, tradeDate, closeMap, summary) {
+  const doc = loadRun(cfg, tradeDate);
+  if (!doc) throw new Error(`未找到盘前归档 ${tradeDate}，无法回填`);
+  doc.close = {
+    backfilledAt: new Date().toISOString(),
+    marketDate: tradeDate,
+    hitDayChgMin: summary.hitDayChgMin,
+    total: 0, hit: 0,
+    perCode: {},
+  };
+  let hit = 0, total = 0;
+  for (const [code, v] of Object.entries(closeMap)) {
+    const rec = doc.records[code];
+    if (!rec) continue;
+    rec.close = v;
+    total++;
+    if (v.hit) hit++;
+    doc.close.perCode[code] = v;
+  }
+  doc.close.total = total;
+  doc.close.hit = hit;
+  doc.close.hitRate = total ? +(hit / total * 100).toFixed(1) : 0;
+  fs.writeFileSync(dataFile(cfg, tradeDate), JSON.stringify(doc, null, 2), 'utf8');
+  return doc.close;
+}
+
+module.exports = { dataFile, loadRun, saveRun, mergeBackfill };

package/eod/lib/report.js

@@ -23,17 +23,19 @@ function yi(n) { return (n == null || isNaN(n)) ? '—' : Number(n).toFixed(1) +
 function esc(s) { return String(s ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'); }
 
 /*
- * 六维分项按「这分是谁给的」分两组（2026-09-21）：
- *   · 个股自身 65 分 = 尾盘动能 30 + 量能 20 + 位置 15 —— 这只票「自己在走」的证据，**重点看这组**；
- *   · 环境与质量 35 分 = 板块 15 + 均价线 10 + 换手 10 —— 板块与流动性给的背景分。
- * 只看总分会被「板块热 + 换手够」抬高分数骗到，故两组在表头/底色上必须可分辨。
+ * 五个分项按「这分是谁给的」分两组（2026-10-22 回溯调参后）：
+ *   · 个股自身 77 分 = 尾盘动能 35 + 量能 24 + 位置 18 —— 这只票「自己在走」的证据，**重点看这组**；
+ *   · 环境与质量 23 分 = 均价线 12 + 换手 11 —— 流动性与位置给的背景分。
+ * 原「板块强度 15 分」因在全部候选上恒为满分（常量、零区分度）被删除，
+ * 权重按原比例重分配（30/20/15/10/10 → 35/24/18/12/11），依据见 docs/backtest/01-复盘.md。
+ * 只看总分会被背景分抬高分数骗到，故两组在表头/底色上必须可分辨。
  * 组内按权重降序（权重大的先看）—— 顺序即渲染顺序。
  * ⚠️ 与 web/src/views/TailView.vue 的 SCORE_GROUPS 是同一份口径，改一处必须改另一处。
  */
 const SCORE_GROUPS = [
   {
-    key: 'self', cls: 'self', max: 65,
-    zh: '个股自身 · 重点看（65 分）', en: 'The stock itself · focus (65)',
+    key: 'self', cls: 'self', max: 77,
+    zh: '个股自身（77 分）', en: 'The stock itself (77)',
     cols: [
       ['tailMomentum', '尾盘动能', 'Tail momentum'],
       ['volume', '量能', 'Volume'],
@@ -41,10 +43,9 @@ const SCORE_GROUPS = [
     ],
   },
   {
-    key: 'ctx', cls: 'ctx', max: 35,
-    zh: '环境与质量（35 分）', en: 'Context &amp; quality (35)',
+    key: 'ctx', cls: 'ctx', max: 23,
+    zh: '环境质量（23 分）', en: 'Context & quality (23)',
     cols: [
-      ['sector', '板块', 'Sector'],
       ['avgLine', '均价线', 'VWAP'],
       ['turnoverFit', '换手', 'Turnover'],
     ],
@@ -76,13 +77,18 @@ function rowHtml(c, i, cfg, withBreakdown) {
   const warn = cfg.score.tailUpRatioWarn;
   const tagBits = [];
   if (c.bestInGroup) tagBits.push(`<span class="tag pass">${b('组内最优', 'best in group')}</span>`);
+  // 2026-10-22 回溯调参：涨幅是全部原始特征里与次日收益相关最强的（ρ=+0.150），
+  // 5–7% 段是唯一正期望的涨幅桶，故对 chg≥5% 的候选加显式标记（决策清单第 8 项）。
+  if (c.chgPct != null && c.chgPct >= 5) {
+    tagBits.push(`<span class="tag hot">${b('涨幅≥5%', 'chg ≥5%')}</span>`);
+  }
   if (tail.upRatio != null && tail.upRatio < warn) {
     tagBits.push(`<span class="tag gap">${b('拉升不连贯', 'choppy tail')}</span>`);
   }
   const cells = withBreakdown
     ? SCORE_COLS.map(([k], idx) => `<td class="${SCORE_CELL_CLS[idx]}">${num(c.score ? c.score[k] : null, 1)}</td>`).join('')
     : '';
-  return `<tr data-sector="${esc(c.sector)}">
+  return `<tr data-sector="${esc(c.sector)}"${c.bestInGroup ? ' data-best="1"' : ''} data-grank="${c.groupRank || ''}">
     <td>${i + 1}</td>
     <td><b>${esc(c.name)}</b><span class="src">${c.code.replace(/^[a-z]+/, '')}</span></td>
     <td>${b(esc(c.sector), esc(c.sector))}</td>
@@ -161,9 +167,10 @@ const CSS = `  :root, :root[data-theme="light"] {
   .tag.fail { background: #f1f5f9; color: var(--slate); }
   .tag.pass { background: #fef2f2; color: var(--red); }
   .tag.gap { background: #fffbeb; color: var(--amber); }
+  .tag.hot { background: var(--red); color: #fff; font-weight: 700; }
   .table-wrap { overflow-x: auto; }
   table { width: 100%; border-collapse: collapse; font-size: 0.85rem; }
-  th, td { padding: 8px 9px; text-align: left; border-bottom: 1px solid var(--border); white-space: nowrap; }
+  th, td { padding: 8px 9px; text-align: center; vertical-align: middle; border-bottom: 1px solid var(--border); white-space: nowrap; }
   th { color: var(--muted); font-weight: 600; background: #fefce8; }
   /* 六维分项分两组：表头两级 + 组底色 + 组首左分隔线，让「重点看哪组」不用读文字 */
   th.grp { text-align: center; font-size: 0.8rem; border-bottom: 1px solid var(--border); }
@@ -172,7 +179,7 @@ const CSS = `  :root, :root[data-theme="light"] {
   th.grp-sub.grp-self { background: #fff7ed; color: var(--accent); }
   th.grp-sub.grp-ctx { background: #f1f5f9; color: var(--slate); }
   th.sc-start, td.sc-start { border-left: 2px solid var(--border); }
-  td.num { text-align: right; font-variant-numeric: tabular-nums; }
+  td.num { text-align: center; font-variant-numeric: tabular-nums; }
   td.sc-self { background: rgba(217, 119, 6, 0.06); }
   td.sc-ctx { background: rgba(100, 116, 139, 0.05); }
   .score-note { margin: 0 0 12px; font-size: 0.86rem; line-height: 1.75; color: #57534e; background: #fff7ed; border: 1px dashed var(--border); border-radius: 8px; padding: 10px 14px; }
@@ -192,6 +199,7 @@ const CSS = `  :root, :root[data-theme="light"] {
   :root[data-theme="dark"] .tag.fail { background: var(--tag-fail-bg); }
   :root[data-theme="dark"] .tag.pass { background: var(--tag-pass-bg); }
   :root[data-theme="dark"] .tag.gap { background: var(--tag-gap-bg); }
+  :root[data-theme="dark"] .tag.hot { background: #b91c1c; color: #fff; }
   :root[data-theme="dark"] th { background: var(--th-bg); }
   :root[data-theme="dark"] th.grp-self { background: var(--grp-self-bg); color: var(--grp-self-fg); }
   :root[data-theme="dark"] th.grp-ctx { background: var(--grp-ctx-bg); color: var(--grp-ctx-fg); }
@@ -225,12 +233,24 @@ function buildHTML(m) {
   const { candidates, groups, top, stats } = result;
   // 三种口径必须在报告顶部一眼可辨：盘中模式的「尾盘段」是滚动窗口近似，
   // 若标签写得像正式结果，复盘时会把近似值当基准（口径混淆）。
-  const modeLabel = mode === 'observe'
-    ? b(`观察模式（口径 ${cutHHMM}，未固定）`, `observe mode (cut ${cutHHMM}, not final)`)
-    : mode === 'intraday'
-      ? b(`盘中模式（口径 ${cutHHMM}，尾盘段=最近窗口近似 · 非正式结果）`,
-        `intraday mode (cut ${cutHHMM}, rolling-window approximation — NOT final)`)
-      : b(`固定口径 ${cutHHMM}`, `fixed cut ${cutHHMM}`);
+  // 观察模式整点触发时自然窗口退化为 0 分钟 → trading.js 改用最近 observeMinWindow 分钟滚动窗口
+  // （segFrom != 1430）。此时必须把「非正式」写进标签，否则复盘会把滚动窗口当 14:30 正式尾盘
+  // （口径混淆，与盘中模式同一条红线）。
+  let modeLabel;
+  if (mode === 'observe' && segFrom !== '1430') {
+    const cutMin = (+cutHHMM.slice(0, 2)) * 60 + (+cutHHMM.slice(2, 4));
+    const segMin = (+segFrom.slice(0, 2)) * 60 + (+segFrom.slice(2, 4));
+    const win = cutMin - segMin;
+    modeLabel = b(`观察模式（按最近 ${win} 分钟滚动窗口，与正式口径等长 · 非正式）`,
+      `observe mode (rolling ${win}-min window, same length as formal — NOT final)`);
+  } else if (mode === 'observe') {
+    modeLabel = b(`观察模式（口径 ${cutHHMM}，未固定）`, `observe mode (cut ${cutHHMM}, not final)`);
+  } else if (mode === 'intraday') {
+    modeLabel = b(`盘中模式（口径 ${cutHHMM}，尾盘段=最近窗口近似 · 非正式结果）`,
+      `intraday mode (cut ${cutHHMM}, rolling-window approximation — NOT final)`);
+  } else {
+    modeLabel = b(`固定口径 ${cutHHMM}`, `fixed cut ${cutHHMM}`);
+  }
 
   // ---- 核心结论 ----
   const bestGroup = groups[0];
@@ -247,7 +267,7 @@ function buildHTML(m) {
       `Funnel: snapshot ${stats.snapshotCount} → pre-filter pass ${stats.prePassCount} → after tail checks ${stats.candidateCount}.`),
   ];
 
-  // 两级表头：第一行把六个子分切成「个股自身 65 / 环境与质量 35」两块，
+  // 两级表头：第一行把五个子分切成「个股自身 77 / 环境与质量 23」两块，
   // 第一行列宽靠 colspan 自动对齐到下面的子分列，不需要额外配 colgroup。
   const topHead = `<tr><th rowspan="2">#</th><th rowspan="2">${b('标的', 'Name')}</th><th rowspan="2">${b('行业', 'Industry')}</th>
     <th rowspan="2">${b('涨幅', 'Chg')}</th><th rowspan="2">${b('尾盘段', 'Tail seg')}</th><th rowspan="2">${b('量比', 'Vol ratio')}</th>
@@ -259,12 +279,12 @@ function buildHTML(m) {
 
   // 读分说明：不解释这一步，用户只会看到一堆等宽数字，不知道哪几个该当真。
   const scoreNote = `<p class="score-note" id="scoreNote">${b(
-    `六维分项按「这分是谁给的」分成两组：<b class='sn-self'>个股自身 65 分</b>（尾盘动能 30 + 量能 20 + 位置 15）—— 这只票自己在走出来的证据，<b>重点看这一组</b>；<b class='sn-ctx'>环境与质量 35 分</b>（板块 15 + 均价线 10 + 换手 10）—— 板块与流动性给的背景分，靠它撑起来的高分不可信。`,
-    `<b class='sn-self'>The stock itself — 65 pts</b> (tail momentum 30 + volume 20 + position 15): evidence this name moved on its own — <b>this is the group to read first</b>. <b class='sn-ctx'>Context &amp; quality — 35 pts</b> (sector 15 + VWAP 10 + turnover 10): background handed over by the sector and by liquidity; a high total carried by this group alone is not trustworthy.`)}</p>`;
+    `五个分项按「这分是谁给的」分成两组：<b class='sn-self'>个股自身 77 分</b>（尾盘动能 35 + 量能 24 + 位置 18）—— 这只票自己在走出来的证据，<b>重点看这一组</b>；<b class='sn-ctx'>环境与质量 23 分</b>（均价线 12 + 换手 11）—— 流动性与位置给的背景分，靠它撑起来的高分不可信。总分与次日收益相关性弱（ρ≈0.04），<b>「涨幅≥5%」标记比总分更值得看</b>（涨幅是相关最强的特征，ρ=+0.15）。`,
+    `<b class='sn-self'>The stock itself — 77 pts</b> (tail momentum 35 + volume 24 + position 18): evidence this name moved on its own — <b>this is the group to read first</b>. <b class='sn-ctx'>Context &amp; quality — 23 pts</b> (VWAP 12 + turnover 11): background handed over by liquidity and position; a high total carried by this group alone is not trustworthy. The total correlates only weakly with next-day return (ρ≈0.04), so the <b>chg ≥5% flag</b> deserves more attention than the total (chg is the strongest correlate, ρ=+0.15).`)}</p>`;
 
   // ---- 候选明细（单表双视图）：TOP 表与分行业卡片本是同一批候选的两种组织方式，
   // 双列表翻页滚动成本高，故合并为一张表：默认按总分排序，「按行业」视图由前端
-  // 把行重排进分组分隔行之下；行业 chips 做筛选；分项 6 列可用开关收起。
+  // 把行重排进分组分隔行之下；行业 chips 做筛选；分项 5 列可用开关收起。
   // 展示上限沿用 report.maxRows（总量控制），列表为 top 之外的全量候选。----
   const listed = candidates.slice(0, cfg.report.maxRows);
   const truncated = candidates.length - listed.length;
@@ -272,7 +292,15 @@ function buildHTML(m) {
   for (const c of listed) { const k = c.sector || '未分类'; chipCounts[k] = (chipCounts[k] || 0) + 1; }
   const chipOrder = groups.map((g) => g.sector).filter((s) => chipCounts[s]);
   for (const k of Object.keys(chipCounts)) if (!chipOrder.includes(k)) chipOrder.push(k);
+  // 「只看组内第一」/「组内前三」：跨行业挑更强用的伪过滤值（@best / @top3），
+  // 组内排名来自 groupAndRank 的 groupRank（组内按总分降序）。
+  const bestCount = listed.reduce((n, c) => n + (c.bestInGroup ? 1 : 0), 0);
+  const top3Count = listed.reduce((n, c) => n + ((c.groupRank || 99) <= 3 ? 1 : 0), 0);
   const chipsHtml = [`<button type="button" class="chip active" data-filter="">${b(`全部 ${listed.length}`, `All ${listed.length}`)}</button>`]
+    .concat([
+      `<button type="button" class="chip" data-filter="@best">${b('只看组内第一', 'Group #1 only')}<i>${bestCount}</i></button>`,
+      `<button type="button" class="chip" data-filter="@top3">${b('组内前三', 'Group top 3')}<i>${top3Count}</i></button>`,
+    ])
     .concat(chipOrder.map((s) =>
       `<button type="button" class="chip" data-filter="${esc(s)}">${b(esc(s), esc(s))}<i>${chipCounts[s]}</i></button>`))
     .join('');
@@ -420,20 +448,47 @@ function buildHTML(m) {
     var viewSectorBtn = document.getElementById('viewSector');
     function renderCand() {
       var frag = document.createDocumentFragment();
+      var bestOnly = (candFilter === '@best');
+      var top3 = (candFilter === '@top3');
+      var ranked = bestOnly || top3; // 过滤视图下 # 列临时改显组内排名
+      // 行筛选：@best 只留组内第一；@top3 留组内排名 1-3；其余按行业 chip 过滤
+      function want(tr) {
+        if (bestOnly) return tr.hasAttribute('data-best');
+        if (top3) {
+          var g = parseInt(tr.getAttribute('data-grank'), 10);
+          return g >= 1 && g <= 3;
+        }
+        return !candFilter || tr.getAttribute('data-sector') === candFilter;
+      }
+      var shown = [];
       if (candView === 'score') {
         candRows.forEach(function (tr) {
-          if (!candFilter || tr.getAttribute('data-sector') === candFilter) frag.appendChild(tr);
+          if (want(tr)) { frag.appendChild(tr); shown.push(tr); }
         });
       } else {
         sepOrder.forEach(function (sep) {
           var sec = sep.getAttribute('data-sep');
-          if (candFilter && sec !== candFilter) return;
-          sep.hidden = false; frag.appendChild(sep);
+          if (!bestOnly && !top3 && candFilter && sec !== candFilter) return;
+          // 先收集该组本次要显示的行：空组（如组内第一被 maxRows 截断）不渲染分隔行
+          var groupRows = [];
           candRows.forEach(function (tr) {
-            if (tr.getAttribute('data-sector') === sec) frag.appendChild(tr);
+            if (tr.getAttribute('data-sector') === sec && want(tr)) groupRows.push(tr);
           });
+          if (!groupRows.length) return;
+          sep.hidden = false; frag.appendChild(sep);
+          groupRows.forEach(function (tr) { frag.appendChild(tr); shown.push(tr); });
         });
       }
+      // # 列：过滤视图显示组内排名（1/2/3…），切回时恢复原始序号
+      shown.forEach(function (tr) {
+        var cell = tr.cells[0];
+        if (ranked) {
+          if (!tr.dataset.idx) tr.dataset.idx = cell.textContent;
+          cell.textContent = tr.getAttribute('data-grank') || tr.dataset.idx;
+        } else if (tr.dataset.idx) {
+          cell.textContent = tr.dataset.idx;
+        }
+      });
       while (tbody.firstChild) tbody.removeChild(tbody.firstChild);
       tbody.appendChild(frag);
     }
@@ -452,6 +507,8 @@ function buildHTML(m) {
       Array.prototype.forEach.call(document.querySelectorAll('#chips .chip'), function (c) {
         c.classList.toggle('active', (c.getAttribute('data-filter') || '') === candFilter);
       });
+      // 组内前三要求同组相邻：选中时自动切到「按行业」视图（用户仍可手动切回按总分）
+      if (candFilter === '@top3' && candView !== 'sector') { setView('sector'); return; }
       renderCand();
     });
     var bdToggle = document.getElementById('bdToggle');

package/eod/lib/screen.js

@@ -11,8 +11,10 @@
  *          （已退市个股仍会返回陈旧价格，只看价格会把它们放进来）
  *        - 一字板：开=高=低（全天一个价，实盘买不到）
  *        - 已封涨停：现价达到该板块涨停价（主板 10% / 双创 20% / 北交所 30%）
- *   3. 打分（FR-06）六项全部线性映射到 0..1 再加权，**每一项都能在报告里解释**，
+ *   3. 打分（FR-06）五项全部线性映射到 0..1 再加权，**每一项都能在报告里解释**，
  *      不做「黑箱总分」。任何一项缺数据记 0 分而不是猜值。
+ *      （2026-10-22 回溯调参：原第六项「板块强度」在全部候选上恒为满分（常量，
+ *      零区分度）已删除，权重按比例重分配，见 tail.config.js score 段注释。）
  *   4. 分组（FR-07）按行业聚合，组内按总分降序，标记组内最优。
  * ---------------------------------------------------------------------------
  */
@@ -36,6 +38,7 @@ const REASON = {
   TAIL_SEG: '尾盘段涨幅不足',
   BELOW_AVG: '现价低于当日均价',
   FROM_HIGH: '距日内高点回落过多',
+  LOW_SCORE: '总分低于下限',
 };
 
 /** 板块判定：涨跌幅制度与成交量单位都与板块相关 */
@@ -169,26 +172,6 @@ function turnoverFit(t, s, f) {
   return clamp01((f.turnoverMax - t) / (f.turnoverMax - s.turnoverSweetHigh));
 }
 
-/**
- * 板块强度（实测后定的混合口径）。
- *
- * 只用「行业涨幅中位数的绝对阈值」会在普涨日整体饱和——实测 2026-09-18
- * 全市场 68.7% 个股上涨，多数行业中位数都超过 2%，导致候选清一色拿满分、该项失去区分度。
- * 只用「分位」则会在普跌日把「跌得最少的行业」也抬到满分，同样失真。
- * 故取两者折中：
- *   1. 行业中位数 ≤ sectorChgLoPct（默认 0%）→ 0 分：行业实际在跌，不给板块加分；
- *   2. 行业中位数 ≥ sectorChgHiPct（默认 2%）→ 满分：绝对强度已足够；
- *   3. 区间内 → 按该行业在全市场行业涨幅中的**分位**给分（相对强弱，自归一）。
- */
-function sectorStrength(sec, s) {
-  if (!sec || sec.median == null) return 0;
-  if (sec.median <= s.sectorChgLoPct) return 0;
-  if (sec.median >= s.sectorChgHiPct) return 1;
-  if (!sec.total || sec.total <= 1) return 0;
-  const pct = (sec.total - sec.rank) / (sec.total - 1);   // rank=1 → 1，最末 → 0
-  return clamp01(pct);
-}
-
 /** 「距日内高点」百分比：越小越强 */
 function fromHighPct(q, tm) {
   if (!(q.high > 0) || tm == null || tm.p1 == null) return null;
@@ -196,7 +179,7 @@ function fromHighPct(q, tm) {
 }
 
 /**
- * 六项打分（FR-06）。总分 = Σ(权重 × 归一化值)。
+ * 五项打分（FR-06）。总分 = Σ(权重 × 归一化值)。
  * @returns {{total:number, items:object, ctx:object}} items 为各项得分（已乘权重）
  */
 function scoreStock(q, tm, cfg, sectorStats, sector) {
@@ -216,8 +199,6 @@ function scoreStock(q, tm, cfg, sectorStats, sector) {
     position: w.position * (1 - lin(fh, 0, f.maxFromHighPct)),
     // 均价线强度：高出均价 0% → 0 分，avgLineFullPct → 满分
     avgLine: w.avgLine * lin(tm.priceVsAvgPct, 0, s.avgLineFullPct),
-    // 板块强度：见 sectorStrength() 的口径说明
-    sector: w.sector * sectorStrength(sec, s),
     // 换手适中度
     turnoverFit: w.turnoverFit * turnoverFit(q.turnover, s, f),
   };
@@ -295,6 +276,13 @@ function buildCandidates({ quotes, minutes, cfg, map, tradeDate, cutHHMM, segFro
 
     const sector = sectorOf(map, q.code) || UNKNOWN;
     const sc = scoreStock(q, tm, cfg, sectorStats, sector);
+    // 总分下限（2026-10-22 回溯调参新增）：45–55 段是回溯里最差的一段，
+    // 打不过线的连同原因进 dropped，报告「数据缺口」区可见。
+    if (cfg.score.minTotal != null && sc.total < cfg.score.minTotal) {
+      tailReasons[REASON.LOW_SCORE] = (tailReasons[REASON.LOW_SCORE] || 0) + 1;
+      dropped.push({ code: q.code, name: q.name, reason: REASON.LOW_SCORE });
+      continue;
+    }
     const sec = sectorStats.get(sector);
 
     candidates.push({
@@ -351,5 +339,5 @@ function buildCandidates({ quotes, minutes, cfg, map, tradeDate, cutHHMM, segFro
 module.exports = {
   REASON, BOARD_LABEL, boardOf, limitUpPct, daysBetween,
   preFilterOne, preFilter, postCheck, scoreStock, turnoverFit, fromHighPct, lin,
-  sectorStrength, groupAndRank, buildCandidates,
+  turnoverFit, groupAndRank, buildCandidates,
 };