candidate-pool 2.1.1 → 2.2.0

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 所有变动按 **Conventional Commits** 约定分类，由 `changelogen` 自动生成。
 
+## v2.2.0
+
+[compare changes](https://github.com/GuoSirius/candidate-pool/compare/v2.1.1...v2.2.0)
+
+### 🚀 新功能 (Features)
+
+- **eod:** 尾盘报告过滤新增「只看组内第一」与「组内前三」 ([b07bffa](https://github.com/GuoSirius/candidate-pool/commit/b07bffa))
+
+### 🐛 缺陷修复 (Bug Fixes)
+
+- 修复观察模式整点触发尾盘段退化 0 分钟窗口导致 100% 0 候选 ([7eed01f](https://github.com/GuoSirius/candidate-pool/commit/7eed01f))
+- 用新逻辑重跑 2026-10-12 观察模式，纠正 0 候选存档（4 只） ([e4798e1](https://github.com/GuoSirius/candidate-pool/commit/e4798e1))
+- **eod:** 原始快照(quotes+minutes)单独存 eod/data/raw 供 --replay 离线重算 ([310e0ac](https://github.com/GuoSirius/candidate-pool/commit/310e0ac))
+- **eod:** 观察窗口 observeMinWindow 5→20（与正式口径等长），审计修复 replay 细节 ([8684db9](https://github.com/GuoSirius/candidate-pool/commit/8684db9))
+
+### 📦 杂项维护 (Chores)
+
+- 尾盘观察 2026-10-09 ([4d63d5d](https://github.com/GuoSirius/candidate-pool/commit/4d63d5d))
+- 尾盘选股 2026-10-09 ([c16b81d](https://github.com/GuoSirius/candidate-pool/commit/c16b81d))
+- **eod:** 用新过滤重建 10-09 三份尾盘报告 ([4511ca4](https://github.com/GuoSirius/candidate-pool/commit/4511ca4))
+- 每日实时初筛 2026-10-09 ([482d84c](https://github.com/GuoSirius/candidate-pool/commit/482d84c))
+- 尾盘观察 2026-10-12 ([c85600f](https://github.com/GuoSirius/candidate-pool/commit/c85600f))
+- 尾盘选股 2026-10-12 ([ccf7d1f](https://github.com/GuoSirius/candidate-pool/commit/ccf7d1f))
+- 每日实时初筛 2026-10-12 ([103593f](https://github.com/GuoSirius/candidate-pool/commit/103593f))
+
+### ❤️ Contributors
+
+- 郭之存 ([@siriusSupreme](https://github.com/siriusSupreme))
+
 ## v2.1.1
 
 [compare changes](https://github.com/GuoSirius/candidate-pool/compare/v2.1.0...v2.1.1)

package/eod/lib/report.js

@@ -82,7 +82,7 @@ function rowHtml(c, i, cfg, withBreakdown) {
   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>
@@ -225,12 +225,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];
@@ -272,7 +284,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 +440,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 +499,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/store.js

@@ -21,6 +21,15 @@ const path = require('path');
 const { now: nowBJ } = require('../../time');
 const paths = require('../../paths');
 
+/** Map<code,{rows,date,error}> → 纯对象（存档用，JSON 可序列化） */
+function minutesToObj(map) {
+  const o = {};
+  for (const [code, m] of map) {
+    o[code] = { rows: m.rows || null, date: m.date || null, error: m.error || null };
+  }
+  return o;
+}
+
 /** 候选对象 -> 存档记录（压缩字段：分时明细不落盘，只留尾盘段汇总） */
 function toRecord(c) {
   return {
@@ -167,15 +176,53 @@ function saveRun({ cfg, tradeDate, mode, cutHHMM, result, runner, segFrom = null
     tradeDate,
     mode,
     cutAt: cutHHMM,
+    // 是否 --stamp 落盘（带时点文件名）：--replay 靠它找回对应的原始快照
+    // （--stamp 的当天可能同时存在带时点与不带时点的 raw 文件，缺此字段会找错）。
+    stamp: stamp || undefined,
     updatedAt: nowBJ(),
     runs,
     stats: result.stats,
     records,
+    // 原始快照（quotes/minutes）不进主存档：体积大（全市场 ~6MB/日），
+    // 单独存 eod/data/raw/ 并 gitignore，仅供 --replay 离线重算（见 saveRaw）。
+    // 主存档保持精简 records，按原约定提交 git。
   };
   fs.writeFileSync(file, JSON.stringify(doc, null, 1), 'utf8');
   return { file, doc, recordCount: Object.keys(records).length, runCount: runs.length, replacedFill };
 }
 
+/**
+ * 原始数据存档（供 --replay 离线重算，无需重新抓行情）：
+ *   quotes = 全市场快照（初筛 preFilter + 板块强度统计用）
+ *   minutes = 初筛通过票的分时 K 线（Map<code,{rows,date,error}>）
+ * 与主存档同「交易日+口径」命名，落到 eod/data/raw/（.raw.json），
+ * 体积大（全市场 ~6MB/日）→ .gitignore 忽略、不进 git；换机器靠 D1 库。
+ * 主存档缺原始文件时，runReplay 退化为「仅重渲染已存 records」。
+ */
+function rawFile(cfg, tradeDate, mode, cutHHMM, opts) {
+  return path.join(paths.eodDir(), cfg.store.dataDir, 'raw', `eod-${tradeDate}${daySuffix(mode, cutHHMM, opts)}.raw.json`);
+}
+function saveRaw({ cfg, tradeDate, mode, cutHHMM, quotes, minutes, stamp = false, segMinutes = null }) {
+  if (!quotes || !minutes) return null;
+  const dir = path.join(paths.eodDir(), cfg.store.dataDir, 'raw');
+  fs.mkdirSync(dir, { recursive: true });
+  const doc = {
+    version: cfg.version,
+    tradeDate, mode, cutAt: cutHHMM, stamp,
+    savedAt: nowBJ(),
+    quotes,
+    minutes: minutesToObj(minutes),
+  };
+  const file = rawFile(cfg, tradeDate, mode, cutHHMM, { stamp, segMinutes });
+  fs.writeFileSync(file, JSON.stringify(doc), 'utf8');
+  return file;
+}
+function loadRaw(cfg, tradeDate, mode, cutHHMM, opts) {
+  const f = rawFile(cfg, tradeDate, mode, cutHHMM, opts);
+  if (!fs.existsSync(f)) return null;
+  try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch (e) { return null; }
+}
+
 /**
  * 回填（P5）：给指定交易日的正式文件写 fill 字段。
  * @param {object} patch code -> fill 对象（整体替换该 code 的 fill）
@@ -202,4 +249,4 @@ function applyFill(cfg, tradeDate, patch) {
   return { updated, missing };
 }
 
-module.exports = { saveRun, loadDay, applyFill, toRecord, dayFile, daySuffix };
+module.exports = { saveRun, loadDay, applyFill, toRecord, dayFile, daySuffix, saveRaw, loadRaw, rawFile };

package/eod/lib/trading.js

@@ -228,10 +228,23 @@ function sessionState({ cfg, now = null, marketDate = null, force = false, intra
   }
 
   // 14:30 ≤ now < 14:50 —— 观察模式
+  // 尾盘段取「now 往前 observeMinWindow（默认 20）个成交分钟」的**滚动窗口**（复用 backTradedMinutes）：
+  //   · 14:30 整点触发时自然窗口 [14:30, now] 退化为 0 分钟 → segPct=0 → 全部撞闸（2026-10-12 修复）；
+  //   · 更根本的：段涨幅门槛与满分都按 20 分钟标定，窗口不等长阈值即失真
+  //     （实测 20min→40 只 / 30min→87 只），故观察段一律与正式口径等长，
+  //     结果才可与 14:50 正式结果横向对比。自然窗口恒 < 20 → 14:30–14:49 恒为滚动。
+  const obsMinWin = Math.max(1, Math.round(s.observeMinWindow || 20));
+  const obsCut = clampToTradedMinute(M);
+  const naturalWin = M - hhmmToMin(s.observeFrom);
+  const segFromObs = (naturalWin >= obsMinWin)
+    ? segFromDefault
+    : fmtMin(backTradedMinutes(obsCut, obsMinWin)).replace(':', '');
   return {
     ...base, ok: true, mode: 'observe', tradeDate: today,
-    reason: `观察模式：未到 ${s.cutAt}，按当前时点 ${d.format('HH:mm')} 取数（口径会变，结果仅供参考）`,
+    reason: `观察模式：未到 ${s.cutAt}，按当前时点 ${d.format('HH:mm')} 取数（口径会变，结果仅供参考）`
+      + (segFromObs !== segFromDefault ? `；尾盘段用最近 ${obsMinWin} 分钟滚动窗口（与正式口径等长，口径未固定）` : ''),
     cutTime: d.format('HH:mm'), cutMinutes: M,
+    segFrom: segFromObs,
     elapsed: elapsedTradingMinutes(M),
     estimateFullDay: false,
   };

package/eod/lib/trading.selftest.js

@@ -96,10 +96,21 @@ check('正式/观察口径 segMinutes 为 undefined（不是滚动窗口）',
 console.log('\n[3] 盘中模式不夺权：14:30 之后仍走观察/正式口径');
 const o1435 = run({ now: at('14:35') });
 check('14:35 无参数 → observe', o1435.mode === 'observe', o1435.mode);
-check('14:35 无参数 → segFrom=1430（固定起点）', o1435.segFrom === '1430', o1435.segFrom);
+check('14:35 无参数 → segFrom=1415（自然窗口 5 < 20 → 滚动）', o1435.segFrom === '1415', o1435.segFrom);
 const i1435 = run({ now: at('14:35'), intraday: true });
 check('14:35 加 --intraday → 仍 observe（开关无副作用）', i1435.mode === 'observe', i1435.mode);
-check('14:35 加 --intraday → 仍 observe 且 segFrom=1430', i1435.segFrom === '1430', i1435.segFrom);
+check('14:35 加 --intraday → 仍 observe 且 segFrom=1415', i1435.segFrom === '1415', i1435.segFrom);
+
+console.log('\n[3b] 观察模式滚动窗口（2026-10-12 修复的 0 候选 bug + 尺子对齐）');
+// 14:30 整点：自然窗口 [14:30,14:30]=0 分钟 → segPct=0 → 全部撞「尾盘段涨幅不足」闸
+// （实测 14:30 截断日 100% 0 候选）。且段涨幅门槛按 20 分钟标定，窗口不等长阈值即失真，
+// 故观察段一律用 observeMinWindow(=20) 滚动窗口 —— 与正式口径等长，结果才可横向对比。
+const o1430 = run({ now: at('14:30') });
+check('14:30 无参数 → observe', o1430.mode === 'observe', o1430.mode);
+check('14:30 整点 → segFrom=1410（滚动 20 分钟）', o1430.segFrom === '1410', o1430.segFrom);
+check('14:30 整点 → reason 提示滚动窗口', /滚动/.test(o1430.reason), o1430.reason);
+check('14:31 → segFrom=1411（滚动 20 分钟）', run({ now: at('14:31') }).segFrom === '1411');
+check('14:35 → segFrom=1415（自然窗口 5 < 20，仍滚动）', run({ now: at('14:35') }).segFrom === '1415');
 
 const c1455 = run({ now: at('14:55') });
 check('14:55 → cut', c1455.mode === 'cut', c1455.mode);
@@ -174,6 +185,17 @@ for (const t of ['09:40', '10:30', '11:20', '11:45', '12:30', '13:00', '13:05',
     tm ? `segPct=${tm.segPct.toFixed(2)}% bars=${tm.bars}` : 'null（会被判 data_gap 剔除）');
 }
 
+console.log('\n[8b] 观察模式整点：尾盘段必须能算出真实 segPct（0 候选 bug 的端到端证明）');
+// 修复前：14:30 整点 segFrom=cutTime=1430 → p0/p1 同根 → segPct=0 → 100% 撞闸。
+// 修复后：segFrom 退到 1410（滚动 20 分钟窗口），段指标非退化，segPct > 0。
+{
+  const ss = run({ now: at('14:30') });
+  const tm = tailMetrics(rows, 'sz000001', ss.cutTime.replace(':', ''), ss.segFrom);
+  check('14:30 observe → tailMetrics 非 null（起点 K 线存在）', tm !== null, tm ? '' : 'null');
+  check('14:30 observe → segPct > 0（不再是退化的 0 分钟窗口）', tm && tm.segPct > 0,
+    tm ? `segPct=${tm.segPct.toFixed(3)}% bars=${tm.bars} 窗口 ${ss.segFrom}→${ss.cutTime}` : 'null');
+}
+
 console.log('\n[9] 落库口径：内部口径必须翻译成 D1/API 的 formal / observe');
 // 历史 bug（2026-09-21）：本地内部把「14:50 固定口径」叫 `cut`，落库时原样写进 D1 →
 //   · 记录页把正式运行显示成「观察」（前端 else 兜底）；
@@ -280,5 +302,37 @@ console.log('\n[11] 落库文件名：观察 / 盘中默认一天一个（不带
     dayFile(cfg, '2026-09-21', 'observe', '1431', { stamp: true }) !== dayFile(cfg, '2026-09-21', 'observe', '1445', { stamp: true }));
 }
 
+console.log('\n[12] 原始快照存档（saveRaw/loadRaw）：与主存档同口径命名，replay 靠 doc.stamp/segMinutes 找回');
+{
+  const fs = require('fs');
+  const { saveRaw, loadRaw, rawFile } = require('./store');
+  const cfgRaw = { version: 1, store: { dataDir: 'data' } };
+  const D = '1970-01-01';   // 假日期，不与真实存档冲突；测完即删
+
+  const norm = (p) => String(p).replace(/\\/g, '/');   // Windows path.join 产生反斜杠
+  check('raw 命名：观察 → raw/eod-<日>-obs.raw.json',
+    norm(rawFile(cfgRaw, D, 'observe', '1430')).endsWith(`raw/eod-${D}-obs.raw.json`));
+  check('raw 命名：盘中 + stamp 带时点与窗口',
+    norm(rawFile(cfgRaw, D, 'intraday', '1310', { stamp: true, segMinutes: 20 })).endsWith(`raw/eod-${D}-intraday1310-w20.raw.json`));
+  check('saveRaw：缺 quotes/minutes 直接返回 null（不写文件）',
+    saveRaw({ cfg: cfgRaw, tradeDate: D, mode: 'cut', cutHHMM: '1450' }) === null);
+
+  const saved = saveRaw({
+    cfg: cfgRaw, tradeDate: D, mode: 'observe', cutHHMM: '1430',
+    quotes: [{ code: 'sh600000' }],
+    minutes: new Map([['sh600000', { rows: [[1, 2, 3, 4]], date: '19700101', error: null }]]),
+  });
+  try {
+    check('saveRaw 往返：loadRaw 读回 quotes/minutes', (() => {
+      const d = loadRaw(cfgRaw, D, 'observe', '1430');
+      return !!d && d.quotes.length === 1 && !!d.minutes.sh600000 && d.minutes.sh600000.rows.length === 1;
+    })());
+    check('loadRaw：stamp 不匹配 → null（--stamp 当天不会找错 raw）',
+      loadRaw(cfgRaw, D, 'observe', '1430', { stamp: true }) === null);
+  } finally {
+    if (saved) { try { fs.unlinkSync(saved); } catch (_) { /* 忽略 */ } }
+  }
+}
+
 console.log(failed ? `\n自我检查失败：${failed} 项` : '\n全部通过');
 process.exit(failed ? 1 : 0);

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',

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": "2.2.0",
   "description": "A股短线选股工具包：次日候选池初筛（R01 量能验证突破 + R07 板块内补涨）与尾盘选股（14:50 口径），数据取自腾讯公开行情接口，输出单文件双语 HTML 报告",
   "bin": {
     "candidate-pool": "bin/candidate-pool.js",