candidate-pool 2.1.1 → 3.0.0

package/eod/preopen_screener.js

@@ -0,0 +1,360 @@
+'use strict';
+/*
+ * eod/preopen_screener.js —— 盘前选股入口（Pre-Open Screener 编排层）
+ * ---------------------------------------------------------------------------
+ * 流程：
+ *   1. 时段守卫（sessionState）：非交易日 / 未到 9:20 / 已过 9:35 → 跳过
+ *   2. 抓竞价快照：观察池(fetchBatch) 或 全市场(fullMarketSnapshot)
+ *   3. 基线：前一日 K 线算 昨涨 + 趋势（观察池实时算；全市场用隔夜缓存）
+ *   4. 应用 P1/P2/P3 → 排除项 → 综合打分 → 分组
+ *   5. 落库(JSON) → HTML 报告 → 通知 → git 推送溯源
+ *
+ * 用法：
+ *   node eod/preopen_screener.js                     # 观察池，正常（受时段限制）
+ *   node eod/preopen_screener.js --universe          # 全市场盲扫（需 baseline 缓存）
+ *   node eod/preopen_screener.js --scope universe     # 同上
+ *   node eod/preopen_screener.js --baseline           # 仅预计算基线缓存（供全市场次日用）
+ *   node eod/preopen_screener.js --force              # 忽略时段，按当前快照取数
+ *   node eod/preopen_screener.js --now "2026-10-22 09:25"  # 指定时刻（测试/补跑）
+ *   node eod/preopen_screener.js --no-notify          # 不推送通知
+ *   node eod/preopen_screener.js --no-push            # 不 git 推送（仅落本地）
+ *   node eod/preopen_screener.js --json               # stdout 机器摘要
+ *   node eod/preopen_screener.js --paths              # 打印落点
+ *
+ * 时段守卫：9:20–9:35 之外静默跳过（避免定时任务误触 / 上午空跑）。
+ * 开盘价(open)在 9:25 撮合后固定，9:25–9:35 抓到的 open 一致 → 调度有 5 分钟宽限。
+ * ---------------------------------------------------------------------------
+ */
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const cfg = require('./preopen.config');
+const { dayjs } = require('../time');
+const { lastClosedTradingDay } = require('../rules');
+const market = require('./lib/market');
+const PR = require('./lib/preopen_rules');
+const store = require('./lib/preopen_store');
+const { buildHTML } = require('./lib/preopen_report');
+const { loadIndustryMap, listedOf, sectorOf, UNKNOWN } = require('./lib/sector');
+const { mapLimit } = require('./lib/http');
+const { notify } = require('../notify');
+const paths = require('../paths');
+const scaffold = require('../scaffold');
+
+const argv = process.argv.slice(2);
+function argOf(f) { const i = argv.indexOf(f); return i >= 0 ? argv[i + 1] : null; }
+const OPT = {
+  universe: argv.includes('--universe') || argOf('--scope') === 'universe',
+  baseline: argv.includes('--baseline'),
+  force: argv.includes('--force'),
+  now: argOf('--now'),
+  noNotify: argv.includes('--no-notify'),
+  noPush: argv.includes('--no-push'),
+  json: argv.includes('--json'),
+  paths: argv.includes('--paths'),
+  init: argv.includes('--init'),
+  stamp: argv.includes('--stamp'),
+};
+const RUNNER = process.env.GITHUB_ACTIONS ? 'github' : 'local';
+function log(m) { if (!OPT.json) console.log(m); }
+
+function fail(msg, err) {
+  log(`[失败] ${msg}` + (err ? `\n${err && err.stack || err}` : ''));
+  if (cfg.notify.enabled && cfg.notify.alertOnFailure && !OPT.noNotify) {
+    notify({ title: `盘前选股失败 · ${dayjs.tz().format('MM-DD HH:mm')}`, content: `${msg}\n\n${err && err.message || err || ''}` })
+      .then((res) => { for (const [ch, [ok, info]] of res) log(`[notify] ${ch}: ${ok ? 'OK' : '失败'}`); })
+      .catch(() => {});
+  }
+  process.exitCode = 1;
+}
+
+// ---------- 时段守卫 ----------
+function sessionState({ now, marketDate, force }) {
+  const from = parseInt(cfg.session.openFrom.replace(':', ''), 10);
+  const to = parseInt(cfg.session.openTo.replace(':', ''), 10);
+  const hhmm = now.hour() * 100 + now.minute();
+  const today = now.format('YYYY-MM-DD');
+  if (force) return { ok: true, reason: '--force 忽略时段', tradeDate: marketDate || today };
+  if (hhmm < from) return { ok: false, reason: `未到盘前窗口（${cfg.session.openFrom} 起）` };
+  if (hhmm > to) return { ok: false, reason: `已过盘前窗口（${cfg.session.openTo} 止，可用 --force 补跑）` };
+  if (marketDate && marketDate !== today) {
+    return { ok: false, reason: `行情日期 ${marketDate} ≠ 今日，非交易日，跳过` };
+  }
+  return { ok: true, reason: '盘前窗口内', tradeDate: marketDate || today };
+}
+
+// ---------- 观察池加载 ----------
+function readCandidates() {
+  const f = paths.candidatesFile();
+  if (!fs.existsSync(f)) throw new Error('candidates.json 不存在，无法加载观察池');
+  const c = JSON.parse(fs.readFileSync(f, 'utf8'));
+  const list = (c.stocks || []).map((s) => ({ code: String(s.code), name: String(s.name || s.code), sector: String(s.sector || '未分类') }));
+  if (!list.length) throw new Error('candidates.json 的 stocks 为空');
+  return list;
+}
+
+// ---------- 基线（前一日 K 线指标）----------
+async function getBaseline(codes, anchor, scope) {
+  if (scope === 'universe') {
+    const cf = path.join(paths.eodDir(), cfg.baseline.dataDir, cfg.baseline.fileName(anchor));
+    if (fs.existsSync(cf)) {
+      log(`[基线] 加载缓存 ${path.basename(cf)}`);
+      const m = new Map();
+      for (const [code, b] of Object.entries(JSON.parse(fs.readFileSync(cf, 'utf8')))) m.set(code, b);
+      return m;
+    }
+    if (!cfg.baseline.computeIfMissing) { log('[基线] 全市场无缓存且禁用实时计算 → 跳过趋势(P3)'); return new Map(); }
+    log('[基线] 全市场缓存缺失，实时计算（较慢，约数分钟）…');
+  }
+  const m = new Map();
+  const res = await mapLimit(codes, cfg.market.concurrency, async (code) => {
+    try {
+      const kl = await market.fetchKline(code, anchor);
+      return [code, PR.calcBaseline(kl, code, cfg)];
+    } catch (e) { return [code, { error: String((e && e.message) || e) }]; }
+  });
+  let okN = 0, errN = 0;
+  for (const [code, b] of res) {
+    if (b && !b.error) { m.set(code, b); okN++; } else errN++;
+  }
+  log(`[基线] K线 ${okN} 只成功 / ${errN} 只失败`);
+  if (scope === 'universe' && m.size) {
+    const out = {}; for (const [code, b] of m) out[code] = b;
+    fs.mkdirSync(path.dirname(path.join(paths.eodDir(), cfg.baseline.dataDir, cfg.baseline.fileName(anchor))), { recursive: true });
+    const cf = path.join(paths.eodDir(), cfg.baseline.dataDir, cfg.baseline.fileName(anchor));
+    fs.writeFileSync(cf, JSON.stringify(out), 'utf8');
+    log(`[基线] 已缓存 ${m.size} 只 → ${path.basename(cf)}`);
+  }
+  return m;
+}
+
+// ---------- 排除项 ----------
+function excludeOne(q, map, tradeDate) {
+  const ex = cfg.exclude;
+  if (ex.st && /ST|退/i.test(q.name)) return 'ST/退市风险';
+  if (ex.suspended) {
+    const hhmmss = String(q.stamp || '').slice(8, 14);
+    if (!(q.vol > 0) || hhmmss === '090000') return '停牌/无成交';
+  }
+  if (ex.newListing) {
+    if (/^[NC]/.test(q.name)) return '新股/次新';
+    const listed = listedOf(map, q.code);
+    if (listed && tradeDate) {
+      const days = Math.abs(dayjs.tz(tradeDate + ' 00:00:00').diff(dayjs.tz(listed.slice(0, 10) + ' 00:00:00'), 'day'));
+      if (days < ex.newListingDays) return '上市过短';
+    }
+  }
+  return null;
+}
+
+// ---------- git 推送（溯源）----------
+function gitPush(files, message) {
+  const root = paths.PKG_ROOT;
+  const run = (args, allowFail) => {
+    try { return execFileSync('git', args, { cwd: root, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } }).toString(); }
+    catch (e) { if (allowFail) return ''; throw e; }
+  };
+  run(['add', ...files]);
+  run(['-c', 'core.hooksPath=.git/cph', 'commit', '-m', message]);
+  const sha = run(['rev-parse', 'HEAD']).trim();
+  run(['-c', 'credential.helper=', '-c', 'credential.helper=wincred', 'push', 'origin', `${sha}:refs/heads/main`]);
+}
+
+// ---------- 主流程 ----------
+async function run() {
+  if (OPT.paths) {
+    const d = paths.describe();
+    log(`工作目录: ${d.home} (来源 ${d.source})`);
+    for (const [k, v] of Object.entries(d.workspace)) log(`  ${k.padEnd(14)} ${v}`);
+    return { paths: d };
+  }
+  if (OPT.init) { scaffold.autoInit({ log, init: true }); return { init: true }; }
+  scaffold.autoInit({ log });
+
+  const now = OPT.now
+    ? dayjs.tz(OPT.now.replace(' ', 'T') + '+08:00')
+    : dayjs.tz();
+  const anchor = lastClosedTradingDay(now);   // 前一日 K 线锚定日
+
+  // 仅预计算基线缓存（供全市场次日盘前用，建议收盘后定时跑）
+  if (OPT.baseline) {
+    const scope = argOf('--scope') || (OPT.universe ? 'universe' : cfg.scope.default);
+    let codes;
+    if (scope === 'universe') {
+      // 全市场：先抓快照枚举「活跃」代码（~5000），只对活跃票抓 K 线；
+      // 直接 expandCodes 会盲扫 3 万槽位（含大量 inactive），K 线逐个抓取会超时。
+      log('[基线] 全市场模式：先抓快照枚举活跃代码…');
+      const snap = await market.fullMarketSnapshot(cfg, log);
+      codes = snap.quotes.map((q) => q.code);
+      log(`[基线] 活跃代码 ${codes.length} 只（交易日 ${snap.meta.marketDate}）`);
+    } else {
+      codes = readCandidates().map((c) => c.code);
+    }
+    log(`[基线预计算] scope=${scope} 共 ${codes.length} 只，锚定日 ${anchor}`);
+    const m = new Map();
+    let done = 0;
+    const res = await mapLimit(codes, cfg.market.concurrency, async (code) => {
+      try {
+        const kl = await market.fetchKline(code, anchor);
+        const b = PR.calcBaseline(kl, code, cfg);
+        if ((++done) % 500 === 0) log(`[基线] 进度 ${done}/${codes.length}`);
+        return [code, b];
+      } catch (e) { return [code, { error: String((e && e.message) || e) }]; }
+    });
+    let ok = 0, err = 0;
+    for (const [c, b] of res) { if (b && !b.error) { m.set(c, b); ok++; } else err++; }
+    const out = {}; for (const [c, b] of m) out[c] = b;
+    const cf = path.join(paths.eodDir(), cfg.baseline.dataDir, cfg.baseline.fileName(anchor));
+    fs.mkdirSync(path.dirname(cf), { recursive: true });
+    fs.writeFileSync(cf, JSON.stringify(out), 'utf8');
+    log(`[基线] 已缓存 ${ok} 只（失败 ${err}）→ ${path.basename(cf)}`);
+    return { baseline: { file: cf, ok, err } };
+  }
+
+  // 时段守卫（本地时钟，第一遍）
+  let ss = sessionState({ now, force: OPT.force });
+  log(`[时段] ${ss.reason}`);
+  if (!ss.ok) { log('[结束] 跳过'); return { skipped: ss.reason }; }
+
+  // 范围与代码
+  const scope = argOf('--scope') || (OPT.universe ? 'universe' : cfg.scope.default);
+  let codes, quotes;
+  if (scope === 'watchlist') {
+    const watch = readCandidates();
+    codes = watch.map((w) => w.code);
+    log(`[1/4] 抓观察池竞价快照（${codes.length} 只）…`);
+    quotes = (await market.fetchBatch(codes, cfg)).filter((q) => q);
+  } else {
+    log('[1/4] 抓全市场竞价快照…');
+    const snap = await market.fullMarketSnapshot(cfg, log);
+    quotes = snap.quotes;
+    if (snap.meta.valid < cfg.market.minValidQuotes) throw new Error(`有效报价 ${snap.meta.valid} 低于红线 ${cfg.market.minValidQuotes}`);
+    codes = quotes.map((q) => q.code);
+    log(`      快照 ${snap.meta.valid} 只（交易日 ${snap.meta.marketDate}）`);
+    // 第二遍时段守卫（用行情日期确认交易日）
+    ss = sessionState({ now, marketDate: snap.meta.marketDate, force: OPT.force });
+    if (!ss.ok) { log('[结束] 跳过'); return { skipped: ss.reason }; }
+  }
+  const tradeDate = ss.tradeDate;
+
+  // 基线
+  log('[2/4] 计算基线（昨涨 + 趋势）…');
+  const baseline = await getBaseline(codes, anchor, scope);
+
+  // 行业映射（分组用）
+  const map = loadIndustryMap();
+  if (map.count < 3000) log(`[警告] 行业映射仅 ${map.count} 只，分组可能失真`);
+
+  // 规则 + 打分
+  log('[3/4] 应用 P1/P2/P3 打分…');
+  const candidates = [];
+  const gaps = [];
+  for (const q of quotes) {
+    const b = baseline.get(q.code);
+    if (!b) { gaps.push({ code: q.code, name: q.name, reason: '无基线K线' }); continue; }
+    const exR = excludeOne(q, map, tradeDate);
+    if (exR) { gaps.push({ code: q.code, name: q.name, reason: exR }); continue; }
+
+    const p1 = PR.calcP1(q, b, cfg);
+    q.__auctionChgPct = p1.auctionChgPct;
+    const p2 = PR.calcP2(q, b, cfg);
+    const p3 = PR.calcP3(b, cfg);
+    const sc = PR.scorePreopen(p1, p2, p3, cfg);
+    if (sc.total < cfg.score.minTotal) continue;
+
+    const sector = sectorOf(map, q.code) || UNKNOWN;
+    candidates.push({
+      code: q.code, name: q.name, sector,
+      board: /sh68[89]/.test(q.code) ? '科创板' : /^sz30/.test(q.code) ? '创业板' : /^bj/.test(q.code) ? '北交所' : '主板',
+      open: q.open, prevClose: q.prevClose, price: q.price,
+      auctionChgPct: p1.auctionChgPct, auctionVolRatio: p1.auctionVolRatio,
+      yesterdayChgPct: b.yesterdayChgPct,
+      trend: { maBull: p3.maBull, newHigh20: p3.newHigh20, newHigh60: p3.newHigh60, slope20: p3.slope20 },
+      p1, p2, p3,
+      label: PR.labelOf(p1, p2, p3),
+      risk: p2.risk,
+      total: +sc.total.toFixed(1),
+      scoreItems: { p1: +p1.score.toFixed(2), p2: +p2.score.toFixed(2), p3: +p3.score.toFixed(2) },
+      stamp: q.stamp,
+    });
+  }
+  candidates.sort((a, b) => b.total - a.total);
+
+  // 分组
+  const bySector = new Map();
+  for (const c of candidates) {
+    if (!bySector.has(c.sector)) bySector.set(c.sector, []);
+    bySector.get(c.sector).push(c);
+  }
+  const groups = [];
+  for (const [sector, list] of bySector) {
+    list.sort((a, b) => b.total - a.total);
+    list.forEach((c, i) => { c.groupRank = i + 1; c.bestInGroup = i === 0; c.groupSize = list.length; });
+    groups.push({ sector, size: list.length, shown: list.slice(0, cfg.group.maxPerGroup), best: list[0] });
+  }
+  groups.sort((a, b) => b.best.total - a.best.total);
+
+  const result = {
+    candidates, groups, top: candidates.slice(0, cfg.group.topN),
+    stats: { snapshotCount: quotes.length, baselineCount: baseline.size, candidateCount: candidates.length, groupCount: groups.length, gapCount: gaps.length },
+    gaps,
+  };
+
+  log(`[4/4] 落库 + 报告 + 通知…`);
+  return emitResult({ tradeDate, scope, anchor, result, baselineCount: baseline.size, quotesCount: quotes.length, marketDate: tradeDate, _t0: Date.now() });
+}
+
+async function emitResult(p) {
+  const { tradeDate, scope, result, marketDate } = p;
+  const saved = store.saveRun({
+    cfg, tradeDate, scope, candidates: result.candidates,
+    meta: { snapshotCount: result.stats.snapshotCount, baselineCount: p.baselineCount, validQuotes: p.quotesCount, marketDate, elapsedMs: Date.now() - (p._t0 || Date.now()) },
+    marketDate,
+  });
+  log(`[落库] ${path.basename(saved.file)}（${saved.recordCount} 条 / 第 ${saved.runCount} 次运行）`);
+
+  const reportDir = path.join(paths.eodDir(), cfg.store.reportDir);
+  fs.mkdirSync(reportDir, { recursive: true });
+  const suffix = OPT.stamp ? `-${dayjs.tz().format('HHmm')}` : '';
+  const reportFile = path.join(reportDir, `${cfg.store.prefix}-${tradeDate}${suffix}.html`);
+  fs.writeFileSync(reportFile, buildHTML({ cfg, tradeDate, scope, result, marketDate, anchor: p.anchor, runner: RUNNER }), 'utf8');
+  log(`[报告] ${reportFile}`);
+
+  if (cfg.notify.enabled && !OPT.noNotify) {
+    const top = result.top.slice(0, cfg.notify.topInMessage);
+    const lines = top.map((c, i) =>
+      `${i + 1}. ${c.name}（${c.code.replace(/^[a-z]+/, '')}）${c.sector} · 竞价${c.auctionChgPct?.toFixed(2)}% · 昨${c.yesterdayChgPct?.toFixed(2)}% · ${c.label} · 总分${c.total}`);
+    const content = [
+      `交易日 ${tradeDate} · 盘前选股（${scope === 'universe' ? '全市场' : '观察池'}）`,
+      `候选 ${result.stats.candidateCount} 只 / ${result.stats.groupCount} 行业（快照 ${result.stats.snapshotCount} → 基线 ${result.stats.baselineCount}）`,
+      '', ...lines, '',
+      `完整报告见本地：eod/reports/${cfg.store.prefix}-${tradeDate}${suffix}.html`,
+    ].join('\n');
+    const res = await notify({ title: `盘前选股 ${tradeDate}（${result.stats.candidateCount} 只）`, content, htmlPath: reportFile });
+    for (const [ch, [ok, info]] of res) log(`[notify] ${ch}: ${ok ? 'OK' : '失败 ' + JSON.stringify(info)}`);
+  }
+
+  // 推送远程溯源
+  if (!OPT.noPush) {
+    try {
+      const pushFiles = [saved.file, reportFile];
+      gitPush(pushFiles, `preopen: ${tradeDate} 候选 ${result.stats.candidateCount} 只（${scope}）`);
+      log('[推送] 已 git 提交并推送远程（溯源）');
+    } catch (e) {
+      log(`[推送] 失败（数据已落本地，可稍后手动推送）：${e && e.message || e}`);
+    }
+  }
+
+  const summary = {
+    tradeDate, scope,
+    snapshot: result.stats.snapshotCount, baseline: result.stats.baselineCount,
+    candidates: result.stats.candidateCount, groups: result.stats.groupCount,
+    top: result.top.slice(0, 10).map((c) => ({ code: c.code, name: c.name, total: c.total, label: c.label })),
+    reportFile, savedFile: saved.file,
+  };
+  if (OPT.json) console.log(JSON.stringify(summary, null, 2));
+  return summary;
+}
+
+run().catch((e) => fail('盘前选股流程异常', e));

package/eod/tail.config.js

@@ -42,6 +42,12 @@ module.exports = {
     earliest: '09:30',
     // 观察模式起点：≥ 14:30 允许运行（尾盘段起点已出现，可提前预览）
     observeFrom: '14:30',
+    // 观察模式尾盘窗口（分钟）：自然窗口 [14:30, now] 不足此值时，
+    // 改取「now 往前 N 个成交分钟」滚动窗口（与盘中模式同思路）。
+    // **必须与正式口径等长（20）**：段涨幅门槛（tailSegMinPct=0.5%）与满分（2.0%）
+    // 都按 20 分钟标定，窗口不等长阈值即失真（实测 20min→40 只 / 30min→87 只，见 docs/ops/01-方案.md）。
+    // 2026-10-12 由 5 改 20：5 分钟兜底虽然能出候选，但尺子和正式口径不一致，参考价值打折。
+    observeMinWindow: 20,
     // 固定口径时点：≥ 14:50 后运行，一律按 14:50 截断取数。
     // 这样「上午跑一次 + 下午跑一次」得到的是**同一口径**，避免同日结果漂移（Q1 多次运行的前提）。
     cutAt: '14:50',
@@ -97,15 +103,21 @@ module.exports = {
   // 3. 初筛过滤（FR-03 / Q5–Q10）—— 尾盘口径 ≠ R01 隔夜口径，独立配置
   // =========================================================================
   filter: {
-    // 当日涨幅区间（%）。上限若放到 9% 会引入接近涨停买不到的标的（Q5）
-    chgPctMin: 2.0,
+    // 当日涨幅区间（%）。上限若放到 9% 会引入接近涨停买不到的标的（Q5）。
+    // 2026-10-22 回溯调参（docs/backtest/01-复盘.md）：341 条候选分桶显示
+    // 2–3% 贴下限桶持一夜均 -1.11%、涨超 2% 命中率仅 8%（5–7% 桶 29%）；
+    // 涨幅也是全部原始特征里与次日收益相关最强的（ρ=+0.150）。
+    // 故下限 2.0 → 3.0，把最弱的一段挡在门外。
+    chgPctMin: 3.0,
     chgPctMax: 7.0,
     // 量比下限（Q6）。14:50 的即时量比天然偏小，1.2 是「已有温和放量」的起点；
     // 想更严可提到 1.5，想放宽可降到 1.0。
     volRatioMin: 1.2,
-    // 换手率区间（%）（Q9）：过低无人气，过高警惕出货
+    // 换手率区间（%）（Q9）：过低无人气，过高警惕出货。
+    // 2026-10-22 回溯调参：10–20% 桶 30 只持一夜均 -3.70%、胜率仅 17%，
+    // 是全表最差的一段（换手与收益 ρ=-0.141）。上限 20 → 10。
     turnoverMin: 2.0,
-    turnoverMax: 20.0,
+    turnoverMax: 10.0,
     // 流通市值区间（亿）（Q10）：与 candidate-pool 现有口径一致，便于横向对照
     floatCapMinYi: 20,
     floatCapMaxYi: 500,
@@ -133,29 +145,44 @@ module.exports = {
   },
 
   // =========================================================================
-  // 5. 强度打分（FR-06 / Q11）—— 总分 100，六项可解释
+  // 5. 强度打分（FR-06 / Q11）—— 总分 100，五项可解释
+  //    2026-10-22 回溯调参（docs/backtest/01-复盘.md）：
+  //    · 删「板块强度」项：341 条候选中该项 100% 拿满 15 分（常量，零区分度），
+  //      还让环境组均分（32.8/35）反超个股自身组（29.1/65），分数被背景分主导；
+  //    · 删除后余下五项按原权重比例重新分配并取整：30/20/15/10/10 → 35/24/18/12/11
+  //      （不按相关系数加权——各分项 |ρ| 均 <0.1，那是噪声不是信号，比例分配最稳）；
+  //    · 总分本身与次日收益几乎不相关（ρ=+0.044），故新增 minTotal 只作粗过滤，
+  //      排序区分度请直接看涨幅（ρ=+0.150，报告已对 chg≥5% 加标记）。
   // =========================================================================
   score: {
     weights: {
-      tailMomentum: 30,   // 尾盘动能：14:30→14:50 涨幅线性映射，+2% 封顶
-      volume: 20,         // 量能：量比 1.2 → 0 分，3.0 → 满分
-      position: 15,       // 位置：距日内高点越近越高
-      avgLine: 10,        // 均价线强度：现价 ÷ 均价 的超出幅度
-      sector: 15,         // 板块强度：所属行业当日涨幅的全市场分位
-      turnoverFit: 10,    // 换手适中度：3%–10% 满分，向两端递减
+      tailMomentum: 35,   // 尾盘动能：14:30→14:50 涨幅线性映射，+2% 封顶
+      volume: 24,         // 量能：量比 1.2 → 0 分，3.0 → 满分
+      position: 18,       // 位置：距日内高点越近越高
+      avgLine: 12,        // 均价线强度：现价 ÷ 均价 的超出幅度
+      turnoverFit: 11,    // 换手适中度：3%–7% 满分，向两端递减
     },
     // 尾盘动能：段涨幅达到该值即拿满分（%）
     tailMomentumFullPct: 2.0,
     // 量能：达到该量比即满分
     volRatioFull: 3.0,
-    // 均价线：超出均价该百分比即满分（%）
-    avgLineFullPct: 1.0,
-    // 换手适中区间（%）：落在此区间满分
+    // 均价线：超出均价该百分比即满分（%）。
+    // 2026-10-22 回溯调参：原 1.0% 时 89% 候选贴满分（均值 9.6/10），
+    // 该项已无区分度且与收益轻微负相关（ρ=-0.088）。满分线 1.0 → 1.5。
+    avgLineFullPct: 1.5,
+    // 换手适中区间（%）：落在此区间满分。
+    // 2026-10-22 随 turnoverMax 20→10 同步由 10 → 7：
+    // 上限收窄后若甜区仍顶到 10%，3–10% 全满分，「过高警惕出货」的扣分就没了。
     turnoverSweetLow: 3.0,
-    turnoverSweetHigh: 10.0,
-    // 板块强度：行业涨幅分位映射的区间（%）。行业中位涨幅达到 hi 即满分
-    sectorChgLoPct: 0.0,
-    sectorChgHiPct: 2.0,
+    turnoverSweetHigh: 7.0,
+    // 候选入选总分下限（低于此不进报告）。
+    // 2026-10-22 回溯调参新增：旧分制下 45–55 分段 84 只持一夜均 -1.32%、命中 12%，
+    // 是全部分数段里最差的一段。删除 sector 常量项后总分整体下移约 7 分
+    // （均值 61.9 → 50.1），旧 55 的等效新总分 ≈ 47，故下限取 **47**
+    // （= 决策批准的切分线在新分制下的等效值；若照抄 55 会等效旧 ~59.4，
+    // 回溯显示边际收益仅 +1pt 命中率却再砍 36% 产量，不值）。
+    // 注：尾盘此前没有总分下限（初筛+分时校验过即入选），此项为新增。
+    minTotal: 47,
     // 分时结构加分项（不计入 100 分，单独展示，避免权重膨胀）
     // 段内上涨分钟占比低于该值时在报告中标注「尾盘拉升不连贯」
     tailUpRatioWarn: 0.55,

package/eod/tail_screener.js

@@ -49,10 +49,11 @@ const fs = require('fs');
 const path = require('path');
 
 const cfg = require('./tail.config');
-const { sessionState, estimateFullDayVolRatio, nowBjt } = require('./lib/trading');
+const { sessionState, estimateFullDayVolRatio, nowBjt, TZ } = require('./lib/trading');
+const { dayjs } = require('../time');
 const market = require('./lib/market');
 const { buildCandidates } = require('./lib/screen');
-const { saveRun, loadDay, daySuffix } = require('./lib/store');
+const { saveRun, daySuffix, saveRaw, loadRaw } = require('./lib/store');
 const { syncTailRun, cleanupLegacyModes, d1Mode, targetLabel } = require('./lib/store_d1');
 const { buildHTML } = require('./lib/report');
 const { notify } = require('../notify');
@@ -116,7 +117,37 @@ function fail(msg, err) {
 async function runReplay(file) {
   const doc = JSON.parse(fs.readFileSync(file, 'utf8'));
   if (!doc.records || !doc.tradeDate) throw new Error('存档格式不对：缺少 records/tradeDate');
-  // 存档只存了压缩记录，重建 result 的最小形状即可满足报告渲染
+
+  // 自包含重算：优先用同口径的原始存档（eod/data/raw/，含 quotes+minutes）→ 不抓行情，
+  // 用当前代码重算。历史 bug（如 14:30 整点 0 分钟窗口）能凭原始数据纠正，
+  // 无需重新抓已取不到的接口。原始文件夹缺失则退化为「仅重渲染已存 records」。
+  // 原始文件按「交易日+口径(+stamp+窗口)」命名：stamp / segMinutes 从主存档找回，
+  // 否则 --stamp 的当天会找错 raw（把不带时点那份的窗口数据当本次口径重算）。
+  const lastRun = (doc.runs && doc.runs[doc.runs.length - 1]) || {};
+  const raw = loadRaw(cfg, doc.tradeDate, doc.mode || 'cut', doc.cutAt || '1450',
+    { stamp: doc.stamp, segMinutes: lastRun.segMinutes ?? null });
+  if (raw && raw.quotes && raw.minutes) {
+    const minutesMap = new Map(Object.entries(raw.minutes).map(([code, m]) => [code, {
+      rows: m.rows || [], date: m.date || null, error: m.error || null,
+    }]));
+    const now = dayjs.tz(`${doc.tradeDate} ${doc.cutAt || '1450'}`, TZ);
+    const ssRe = sessionState({ cfg, now, marketDate: doc.tradeDate });
+    const result = buildCandidates({
+      quotes: raw.quotes, minutes: minutesMap, cfg, map: map(),
+      tradeDate: doc.tradeDate, cutHHMM: doc.cutAt || '1450', segFrom: ssRe.segFrom,
+      makeTail: (rows, code, cut, seg) => market.tailMetrics(rows, code, cut, seg),
+    });
+    log(`[回放] 从原始存档离线重算（不抓行情）：${result.candidates.length} 候选 / 初筛 ${result.stats.prePassCount} 只`);
+    return emitResult({
+      tradeDate: doc.tradeDate, mode: doc.mode || 'cut', cutHHMM: doc.cutAt || '1450',
+      segFrom: ssRe.segFrom, segMinutes: ssRe.segMinutes ?? null, result,
+      meta: { slots: 0, batches: 0, failedBatches: 0, valid: raw.quotes.length, marketDate: doc.tradeDate, elapsedMs: 0, outlierDates: [] },
+      quotes: raw.quotes, minutes: minutesMap, _t0: Date.now(), skipRaw: true,
+      stamp: doc.stamp || false,
+    });
+  }
+
+  // 旧主存档（无原始数据 / 原始文件夹缺失）：仅重渲染已存的 records（渲染只读，不动存档）
   const candidates = Object.values(doc.records).map((r) => ({
     ...r,
     tail: r.tail || null,
@@ -141,11 +172,16 @@ async function runReplay(file) {
     stats: doc.stats || {},
     dropped: [],
   };
+  // 口径行用存档里真实记录的 segFrom（盘中/观察的滚动起点），不要回退到 cfg 默认 14:30 ——
+  // 否则旧盘中存档重渲染会显示错误的口径区间。
+  const recsRe = Object.values(doc.records);
+  const segFromRe = (recsRe[0] && recsRe[0].tail && recsRe[0].tail.segFrom) || lastRun.segFrom
+    || cfg.session.observeFrom.replace(':', '');
   return emitResult({
     tradeDate: doc.tradeDate, mode: doc.mode || 'cut', cutHHMM: doc.cutAt || '1450',
-    segFrom: cfg.session.observeFrom.replace(':', ''), result,
+    segFrom: segFromRe, result,
     meta: { slots: 0, batches: 0, failedBatches: 0, valid: candidates.length, marketDate: doc.tradeDate, elapsedMs: 0, outlierDates: [] },
-    skipStore: true,
+    skipStore: true, stamp: doc.stamp || false,
   });
 }
 
@@ -286,6 +322,7 @@ async function run() {
   return emitResult({
     tradeDate: ss.tradeDate, mode: ss.mode, cutHHMM, segFrom,
     segMinutes: ss.segMinutes ?? null, result, meta: snap.meta, _t0: t0,
+    quotes: snap.quotes, minutes,
   });
 }
 
@@ -301,17 +338,27 @@ function map() {
 
 /** 落库 + 报告 + 通知（live 与 replay 共用） */
 async function emitResult(p) {
-  const { tradeDate, mode, cutHHMM, segFrom, segMinutes, result, meta } = p;
+  const { tradeDate, mode, cutHHMM, segFrom, segMinutes, result, meta, quotes, minutes, skipRaw } = p;
+  // stamp：live 跑用 CLI 的 OPT.stamp；replay 时由 runReplay 传入存档里的 doc.stamp，
+  // 否则 replay 带 --stamp 的存档会把主存档/报告写到不带时点的文件名上（互相覆盖）。
+  const stamp = p.stamp ?? OPT.stamp;
 
   // 落库
   let saved = null;
   if (!p.skipStore) {
     saved = saveRun({
       cfg, tradeDate, mode, cutHHMM, result, runner: RUNNER,
-      segFrom, segMinutes, stamp: OPT.stamp,
+      segFrom, segMinutes, stamp,
     });
     log(`[落库] ${path.basename(saved.file)}（${saved.recordCount} 条 / 第 ${saved.runCount} 次运行）`);
 
+    // 原始快照单独落 eod/data/raw/（供 --replay 离线重算，gitignore 不入库）；
+    // replay 离线路径已持有原始数据，不必重写 → skipRaw。
+    if (!skipRaw && quotes && minutes) {
+      const raw = saveRaw({ cfg, tradeDate, mode, cutHHMM, quotes, minutes, stamp, segMinutes });
+      if (raw) log(`[原始存档] ${path.basename(raw)}（供 --replay 离线重算，不进 git）`);
+    }
+
     // 同步到数据源（网页 /api/tail/* 读 D1；本地 db/local.db 供离线复盘）。
     // 目标见 store_d1.js::targetArgv()：**本机跑默认两边都写，GitHub Actions 只写远程**；
     // `--local` / `--both` 可显式覆盖。--no-d1（盘中模式强制）则完全不写库。
@@ -331,7 +378,7 @@ async function emitResult(p) {
   // 报告
   const reportDir = path.join(paths.eodDir(), cfg.store.reportDir);
   fs.mkdirSync(reportDir, { recursive: true });
-  const suffix = daySuffix(mode, cutHHMM, { stamp: OPT.stamp, segMinutes });
+  const suffix = daySuffix(mode, cutHHMM, { stamp, segMinutes });
   const reportFile = path.join(reportDir, `eod-${tradeDate}${suffix}.html`);
   fs.writeFileSync(reportFile, buildHTML({
     cfg, tradeDate, mode, cutHHMM, segFrom, result, meta, runner: RUNNER,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "candidate-pool",
-  "version": "2.1.1",
+  "version": "3.0.0",
   "description": "A股短线选股工具包：次日候选池初筛（R01 量能验证突破 + R07 板块内补涨）与尾盘选股（14:50 口径），数据取自腾讯公开行情接口，输出单文件双语 HTML 报告",
   "bin": {
     "candidate-pool": "bin/candidate-pool.js",
@@ -53,6 +53,10 @@
     "tail:intraday": "node eod/tail_screener.js --intraday",
     "tail:replay": "node eod/tail_screener.js --replay",
     "tail:selftest": "node eod/lib/trading.selftest.js",
+    "preopen": "node eod/preopen_screener.js",
+    "preopen:watchlist": "node eod/preopen_screener.js --scope watchlist",
+    "preopen:baseline": "node eod/preopen_screener.js --baseline",
+    "preopen:backfill": "node eod/preopen_backfill.js",
     "paths": "node gen_candidates.js --paths",
     "paths:selftest": "node paths.selftest.js",
     "init": "node gen_candidates.js --init",