dsh-livebench-panel 0.2.18 → 0.2.21

package/README.md

@@ -42,11 +42,43 @@ cd livebench
 | 模型 | harness 全部 provider 的全部模型（含内置 deepseek-official）；分组展示 | 首次验证选小任务 + 便宜模型 |
 | 推理强度 | 该模型的 reasoning effort（无配置则禁用）；编码进条目名，不同强度独立出分 | 日常 `medium`/`high`；对比测试固定同一档 |
 | 题集 release | LiveBench 题目发布批次 | 公开题目最全的是 `2024-11-25`（推荐） |
+| **Baseline 题库** | 参考模型的实测对错题集，**可脱离分类/任务单独使用**（见下节） | 快速探针：参考模型「做错」的题 |
 | 分类 | 六大类：coding / math / reasoning / language / data_analysis / instruction_following | 首次验证选 `language` |
 | 任务 | 分类下的具体任务（如 language/typos 拼写纠错） | 首次验证选 `typos`（短平快） |
-| 题目序号范围 | 该任务题目的起止下标（0 起，**含首尾**） | 冒烟测试填 0–1（只跑 2 题） |
+| 题目序号范围 | 起止下标（0 起，**含首尾**）；选 Baseline 时序号相对该题库 | 冒烟测试填 0–1（只跑 2 题） |
 | max-tokens | 单次回答的 token 上限 | 推理模型给 8192+，否则思考被截断判 0 分 |
 
+## Baseline 题库（探针）
+
+用**一个参考模型的实测对错**当尺子，快速判断别的模型处在哪个档位。位于「分类 / 任务」之上，
+三层可选：
+
+1. **参考模型**：`Baseline(glm-5.3-flash@max)`
+2. **任务**：该参考模型已经跑过全量的任务（如 `olympiad（36）`）
+3. **做错 / 做对**：各自标注题目数量（如 `做错（8）` / `做对（28）`），可多选
+
+选中后**不需要也不应该再选分类/任务**——"不选 = 全部分类"这条规则对 Baseline 不适用。
+「题目序号范围」仍然生效，序号相对 Baseline 题库（0 起、含首尾）；超出上界不会报错，
+会按实际题数截断。
+
+**为什么默认勾「做错」**：探针的价值在于"参考模型做不出来的题"。参考模型能轻松做对的题，
+对更强的模型没有分辨力，混进来只会稀释信号。「做对」也保留，用于反向验证
+（例如确认某模型确实强于参考模型）。
+
+**当前内置的数据**（2026-09-12 实测，release `2024-11-25`）：
+
+| 参考模型 | 任务 | 全量 | 做对 | 做错 |
+|---|---|---|---|---|
+| `zai-coding-cn__glm-5.3-flash@max` | `math/olympiad` | 36 | 28 | 8 |
+
+实测效果（跑「做错」那 8 题）：`aiportx-gg/grok-4.6@xhigh` 明显强于参考模型；
+`deepseek-official/deepseek-flash@max` 明显更弱。失败的 8 题全部属于 olympiad 的
+**公式还原**题型——把解答里的公式挖空让模型补全，是纯符号推理，很吃"智力"。
+
+后续任务按同样方式补进 `lib/index.js` 的 `BASELINE_SETS.tasks` 即可：
+只需填 `passed` / `failed` 两组 question id（取自 LiveBench 的 `question.jsonl`），
+面板用 `--question-id` 直接指定，题目在题库里是否连续都无所谓。
+
 ## 功能
 
 - **标签页位置**：`conversation.view` 槽位 `id: "livebench"`、`order: 20`（对话 = 0，轨迹 = 10，LiveBench 排最右）。

package/lib/client.js

@@ -121,7 +121,7 @@ window.__ModuleLoader__.load({
 		function LiveBenchView() {
 					const [config, setConfig] = useState(null);
 					const [configError, setConfigError] = useState(null);
-					const [sel, setSel] = useState({ models: [], efforts: {}, cats: [], tasks: [], release: "2024-11-25", begin: "", end: "", maxTokens: "32000" });
+					const [sel, setSel] = useState({ models: [], efforts: {}, cats: [], tasks: [], release: "2024-11-25", begin: "", end: "", maxTokens: "32000", baseline: null });
 					const [modelDdOpen, setModelDdOpen] = useState(false);
 					const [busy, setBusy] = useState(false);
 					const [running, setRunning] = useState(false);
@@ -131,8 +131,8 @@ window.__ModuleLoader__.load({
 					const [homeBusy, setHomeBusy] = useState(false);
 					const [results, setResults] = useState(null);
 					const [pickedModels, setPickedModels] = useState(() => new Set());
-					const [sortBy, setSortBy] = useState(null);
-					const [sortDir, setSortDir] = useState("asc");
+					const [sortBy, setSortBy] = useState("time");
+					const [sortDir, setSortDir] = useState("desc");
 					const [modelOrder, setModelOrder] = useState(() => {
 						try { return JSON.parse(localStorage.getItem("dlb_model_order_v1")) ?? []; } catch { return []; }
 					});
@@ -243,24 +243,54 @@ window.__ModuleLoader__.load({
 						return { providerId: pid, modelId: mid, modelValue: value, efforts: model?.efforts ?? [] };
 					}), [sel.models, config]);
 
+					// Baseline 三层选择：参考模型 -> 任务 -> 做对/做错
+					const baselineObj = useMemo(
+						() => (config?.baselines ?? []).find((b) => b.id === sel.baseline) ?? null,
+						[config, sel.baseline]);
+					const baselineTaskObj = useMemo(
+						() => (baselineObj?.tasks ?? []).find((t) => t.task === sel.baselineTask) ?? null,
+						[baselineObj, sel.baselineTask]);
+					// 当前勾选真正会跑几题：题号范围的上界就是它 - 1
+					const baselineSelectedCount = useMemo(() => {
+						if (baselineTaskObj === null) return 0;
+						let n = 0;
+						if (sel.baselinePicks.includes("failed")) n += baselineTaskObj.failedCount;
+						if (sel.baselinePicks.includes("passed")) n += baselineTaskObj.passedCount;
+						return n;
+					}, [baselineTaskObj, sel.baselinePicks]);
+
 					const onStart = async () => {
 						setStartError(null);
 						if (selectedModelEntries.length === 0) {
 							setStartError("请先在模型下拉中至少勾选一个模型。");
 							return;
 						}
-						const benchNames = [];
-						if (sel.cats.length === 0) {
-							benchNames.push("live_bench");
-						} else if (sel.tasks.length === 0) {
-							for (const cat of sel.cats) benchNames.push(`live_bench/${cat}`);
+						// Baseline 题库：绕开分类/任务的"不选 = 全部"推导，
+						// 由服务端按「参考模型 + 任务 + 做对/做错」解析出 question id。
+						let benchNames = null;
+						if (baselineObj !== null) {
+							if (baselineTaskObj === null) {
+								setStartError("已选 Baseline，请再选择它下面的任务（例如 olympiad）。");
+								return;
+							}
+							if (sel.baselinePicks.length === 0) {
+								setStartError("已选 Baseline 任务，请至少勾选「做错」或「做对」之一。");
+								return;
+							}
 						} else {
-							for (const t of sel.tasks) benchNames.push(`live_bench/${t}`);
-						}
-						const zeroTask = sel.tasks.find((t) => countFor(t.split("/")[0], t.split("/")[1]) === 0);
-						if (zeroTask) {
-							setStartError(`任务 ${zeroTask.split("/")[1]} 在 release ${sel.release} 下没有可用题目（该批题目已退役），请取消勾选或换 release。`);
-							return;
+							benchNames = [];
+							if (sel.cats.length === 0) {
+								benchNames.push("live_bench");
+							} else if (sel.tasks.length === 0) {
+								for (const cat of sel.cats) benchNames.push(`live_bench/${cat}`);
+							} else {
+								for (const t of sel.tasks) benchNames.push(`live_bench/${t}`);
+							}
+							const zeroTask = sel.tasks.find((t) => countFor(t.split("/")[0], t.split("/")[1]) === 0);
+							if (zeroTask) {
+								setStartError(`任务 ${zeroTask.split("/")[1]} 在 release ${sel.release} 下没有可用题目（该批题目已退役），请取消勾选或换 release。`);
+								return;
+							}
 						}
 						setBusy(true);
 						try {
@@ -274,7 +304,9 @@ window.__ModuleLoader__.load({
 										provider: entry.providerId,
 										model: entry.modelId,
 										reasoningEffort: sel.efforts[entry.modelValue] ?? "default",
-										benchNames,
+										...(baselineObj !== null
+											? { baseline: baselineObj.id, baselineTask: sel.baselineTask, baselinePicks: sel.baselinePicks }
+											: { benchNames }),
 										release: sel.release,
 										begin: sel.begin,
 										end: sel.end,
@@ -359,15 +391,20 @@ window.__ModuleLoader__.load({
 						const groupStart = new Set(groups.map((g) => g.tasks[0]));
 						const cells = new Map();
 						const startTimes = new Map();
+						// 哪些 模型×任务 是 Baseline 子集跑出来的：同一列里会混着"全量"和
+						// "题库子集"两种分数，必须在界面上标出来，否则没法解读。
+						const baselineCells = new Set();
 						for (const row of results.rows) {
-							cells.set(`${row.model}__@__${taskKey(row.category, row.task)}`, row);
+							const key = `${row.model}__@__${taskKey(row.category, row.task)}`;
+							cells.set(key, row);
+							if (row.baselineLabel) baselineCells.add(key);
 							const fromMeta = row.runStartedAt ? Math.floor(Date.parse(row.runStartedAt) / 1000) : null;
 							const candidate = (Number.isFinite(fromMeta) ? fromMeta : null) ?? runStampSeconds(row.model) ?? row.time ?? null;
 							const prev = startTimes.get(row.model);
 							if (candidate && (prev === undefined || candidate < prev)) startTimes.set(row.model, candidate);
 						}
 						const taskTotals = (results && results.taskTotals) || {};
-						return { models, tasks, groups, groupStart, cells, startTimes, taskTotals };
+						return { models, tasks, groups, groupStart, cells, startTimes, taskTotals, baselineCells };
 					}, [results]);
 					const cellOf = (model, key) => matrix.cells.get(`${model}__@__${key}`);
 					// 排序：sortBy=null 时用拖拽自定义顺序；点击表头在 正序/倒序 间切换
@@ -380,8 +417,13 @@ window.__ModuleLoader__.load({
 						}
 						if (sortBy === "time") {
 							base.sort((a, b) => {
+								// 没有时间戳的排在最后，不管升序降序 —— 否则空值会被当成 0
+								// 混在中间/开头，看起来像"最旧的一次评测"。
 								const ta = matrix.startTimes.get(a) ?? 0;
 								const tb = matrix.startTimes.get(b) ?? 0;
+								if (ta === 0 && tb === 0) return a.localeCompare(b);
+								if (ta === 0) return 1;
+								if (tb === 0) return -1;
 								return sortDir === "asc" ? ta - tb : tb - ta;
 							});
 							return base;
@@ -398,7 +440,7 @@ window.__ModuleLoader__.load({
 					// 点击表头：切换排序字段（再次点击同一列则反转方向）
 					const toggleSort = (field) => {
 						if (sortBy === field) setSortDir((d) => (d === "asc" ? "desc" : "asc"));
-						else { setSortBy(field); setSortDir("asc"); }
+						else { setSortBy(field); setSortDir(field === "time" ? "desc" : "asc"); }
 					};
 					const sortMark = (field) => (sortBy === field ? (sortDir === "asc" ? " ↑" : " ↓") : "");
 
@@ -536,7 +578,7 @@ window.__ModuleLoader__.load({
 								),
 								h("div", { className: c("field") },
 									h("label", { className: c("label") }, "max-tokens（默认 32000）"),
-									h("input", { className: c("input"), type: "number", min: 256, max: 32768, value: sel.maxTokens, onChange: setField("maxTokens") }),
+									h("input", { className: c("input"), type: "number", min: 256, max: 200000, value: sel.maxTokens, onChange: setField("maxTokens"), title: "单题输出上限。推理模型在难题上容易把预算全花在思考里、正文为空（成绩表括号里记为「没做出来」），这类题可以把上限调大后重跑。" }),
 								),
 								h("div", { className: c("field") },
 									h("label", { className: c("label") }, "题目序号范围（可选，0 起，含首尾）"),
@@ -544,6 +586,67 @@ window.__ModuleLoader__.load({
 										h("input", { className: c("input"), type: "number", min: 0, placeholder: "起（含）", title: "起始题号（0 起，包含该题）", value: sel.begin, onChange: setField("begin"), style: { flex: "1", minWidth: "0" } }),
 										h("input", { className: c("input"), type: "number", min: 0, placeholder: "止（含）", title: "结束题号（包含该题）；只填起不填止 = 从该题跑到底", value: sel.end, onChange: setField("end"), style: { flex: "1", minWidth: "0" } }),
 									),
+								// Baseline 题库：位于「分类 / 任务」之上的独立条目，三层选择。
+								// 选中后走它自己的任务 + 一组 question id，因此不需要（也不应该）
+								// 再受"不选分类 = 全部分类"这条规则约束。
+								h("div", { className: c("field") },
+									h("label", { className: c("label") }, "Baseline 题库（探针，可单独使用，不必选分类/任务）"),
+									// 第 1 层：参考模型
+									h("div", { className: c("chips") },
+										(config?.baselines ?? []).map((b) => h("button", {
+											key: b.id,
+											type: "button",
+											className: c("chip") + (sel.baseline === b.id ? " " + c("chipOn") : ""),
+											title: `参考模型 ${b.referenceModel}\n已实测 ${b.tasks.length} 个任务`,
+											onClick: () => setSel((prev) => (prev.baseline === b.id
+												? { ...prev, baseline: null, baselineTask: null, baselinePicks: [] }
+												: { ...prev, baseline: b.id, baselineTask: null, baselinePicks: [] })),
+										}, b.label)),
+									),
+									// 第 2 层：任务（该参考模型已实测过的任务）
+									baselineObj !== null && h("div", { className: c("chips"), style: { marginTop: "6px" } },
+										h("span", { className: c("hint"), style: { alignSelf: "center" } }, "任务："),
+										(baselineObj.tasks ?? []).map((t) => h("button", {
+											key: t.task,
+											type: "button",
+											className: c("chip") + (sel.baselineTask === t.task ? " " + c("chipOn") : ""),
+											title: `${t.task} · release ${t.release}\n该任务全量 ${t.total} 题（做对 ${t.passedCount} / 做错 ${t.failedCount}）`,
+											onClick: () => setSel((prev) => (prev.baselineTask === t.task
+												? { ...prev, baselineTask: null, baselinePicks: [] }
+												// 默认勾「做错」：探针的用途就是拿参考模型做不出来的题去量别人
+												: { ...prev, baselineTask: t.task, baselinePicks: ["failed"] })),
+										}, `${t.taskName}（${t.total}）`)),
+									),
+									// 第 3 层：做对 / 做错，各带题目数量
+									baselineTaskObj !== null && h("div", { className: c("chips"), style: { marginTop: "6px" } },
+										h("span", { className: c("hint"), style: { alignSelf: "center" } }, "题目："),
+										[["failed", "做错"], ["passed", "做对"]].map(([key, text]) => {
+											const count = key === "failed" ? baselineTaskObj.failedCount : baselineTaskObj.passedCount;
+											const on = sel.baselinePicks.includes(key);
+											return h("button", {
+												key,
+												type: "button",
+												className: c("chip") + (on ? " " + c("chipOn") : ""),
+												disabled: count === 0,
+												title: key === "failed"
+													? `${baselineTaskObj.referenceModel} 得 0 分的 ${count} 题（探针首选：做不出来的题才有分辨力）`
+													: `${baselineTaskObj.referenceModel} 判分 ≥0.5 的 ${count} 题（反向验证用）`,
+												onClick: () => setSel((prev) => ({
+													...prev,
+													baselinePicks: prev.baselinePicks.includes(key)
+														? prev.baselinePicks.filter((p) => p !== key)
+														: [...prev.baselinePicks, key],
+												})),
+											}, `${text}（${count}）`);
+										}),
+									),
+									baselineTaskObj !== null && h("span", { className: c("hint") },
+										`已选 ${baselineTaskObj.referenceModel} 的 ${baselineTaskObj.taskName}：`
+										+ `本次只跑勾选的题（共 ${baselineSelectedCount} 题，有效题号 0–${Math.max(0, baselineSelectedCount - 1)}），`
+										+ "上面的「分类/任务」被忽略；"
+										+ "「题目序号范围」仍然生效（序号相对本题库，从 0 起、含首尾；超出上界不会报错，会按实际题数截断）；"
+										+ `release 固定为 ${baselineTaskObj.release}。`),
+								),
 								h("div", { className: c("field") },
 									h("label", { className: c("label") }, "分类（可多选，不选 = 全部分类；括号内为该 release 下有效题数）"),
 									h("div", { className: c("chips") },
@@ -601,7 +704,7 @@ window.__ModuleLoader__.load({
 							h("div", { className: c("row") },
 								h("div", { className: c("cardHead") },
 									h("span", { className: c("label") }, `评测成绩（行 = 模型，列 = 任务）· ${sortedModels.length} 个模型 × ${matrix.tasks.length} 个任务`),
-									h("span", { className: c("hint") }, "分数 = 该任务平均分 ×100；括号 (-没做或没做完的题数/用户选择的题数，即题目序号范围的题数)；× = 未执行该任务；— = 无有效判分（如全部访问失败，不计入正确率）；颜色 ≥75 绿 / 40–75 橙 / <40 红；拖 ⠿ 换行序（存在本机），点表头按模型名或时间排序。"),
+									h("span", { className: c("hint") }, "分数 = 该任务平均分 ×100；括号 (-没做或没做完的题数/用户选择的题数，即题目序号范围的题数)；× = 未执行该任务；— = 无有效判分（如全部访问失败，不计入正确率）；颜色 ≥75 绿 / 40–75 橙 / <40 红；默认按 time 倒序（最新在前），点表头可在模型名/时间间切换排序，拖 ⠿ 则回到本机保存的自定义行序。"),
 								),
 								h("button", {
 									className: c("btn") + " " + c("btnDanger"),
@@ -692,12 +795,20 @@ window.__ModuleLoader__.load({
 															h("div", { className: c("dim") }, "×"));
 													}
 													const sub = `(-${row.notDone ?? 0}/${row.configured ?? 0})`;
-													const allFailed = row.answered > 0 && row.errors >= row.answered;
-													const title = allFailed
-														? `本次选择 ${row.configured ?? 0} 题，其中 ${row.errors} 题全部访问失败（未做完），不计入正确率 ${sub}`
-														: `本次选择 ${row.configured ?? 0} 题，做完 ${row.done ?? 0} 题，没做或没做完 ${row.notDone ?? 0} 题 ${sub}` +
-															(row.errors > 0 ? `（其中 ${row.errors} 题 API 失败）` : "");
-													if (allFailed || row.judged === 0) {
+													const emptyCount = row.empty ?? 0;
+													// 「没做出来」= API 失败 + 空答案（思考吃满 max-tokens 没产出正文），
+													// 两者都不进正确率分母
+													const notProduced = row.notProduced ?? row.errors ?? 0;
+													const allFailed = row.answered > 0 && notProduced >= row.answered;
+													const basePrefix = row.baselineLabel ? `【${row.baselineLabel}】` : "";
+													const reasons = [
+														row.errors > 0 ? `${row.errors} 题 API 失败` : null,
+														emptyCount > 0 ? `${emptyCount} 题思考占满 max-tokens、未产出答案` : null,
+													].filter(Boolean).join("，");
+													const title = basePrefix + (allFailed
+														? `本次选择 ${row.configured ?? 0} 题，全部没做出来（${reasons}），不计入正确率 ${sub}`
+														: `本次选择 ${row.configured ?? 0} 题，做出来 ${row.done ?? 0} 题，没做出来 ${row.notDone ?? 0} 题 ${sub}`
+															+ (reasons ? `（其中 ${reasons}）` : ""));													if (allFailed || row.judged === 0) {
 														return h("td", { key: taskKeyCol, className: cls, title },
 															h("div", { className: c("dim") }, "—"),
 															h("div", { className: c("cellSub") }, sub));

package/lib/index.js

@@ -102,9 +102,64 @@ const RELEASES = [
 ];
 /** Sane cap so a runaway run cannot eat memory with its log. */
 const LOG_MAX_LINES = 600;
-/** One evaluation at a time per model, but several models may run concurrently. */
+/** One evaluation at a time per model, but several models may run together. */
 const MAX_CONCURRENT_RUNS = 9;
 
+/**
+ * 「Baseline」题库：记录某个**参考模型**在各任务上的实测对错，用来给别的模型一把同样的尺子。
+ *
+ * 结构是三层可选：参考模型（baseline）→ 任务（task）→ 对/错（passed / failed）。
+ * 作为"探针"用时通常只跑 failed —— 参考模型做不出来的题，才对更强的模型有分辨力；
+ * passed 一并留存，便于反向验证（例如确认某模型确实强于参考模型）。
+ * 目前只有 olympiad 做过全量实测，后续任务按同样方式补进 tasks 即可。
+ *
+ * 实现要点：题目 id 取自 LiveBench 的 question.jsonl。面板用 `--question-id` 直接指定，
+ * 因此不要求这些题在题库里连续；`--question-begin/--question-end` 仍然会作用在
+ * **id 过滤之后**的列表上，所以「题目序号范围」对 baseline 一样有效。
+ */
+const BASELINE_SETS = {
+	glm53flash: {
+		id: "glm53flash",
+		label: "Baseline(glm-5.3-flash@max)",
+		referenceModel: "zai-coding-cn__glm-5.3-flash@max",
+	// 参考模型在每个任务上的实测结果：passed = 判分 >= 0.5 的题，failed = 判分 0 的题。
+	// 作为"探针"用时通常只跑 failed —— 参考模型做不出来的题，才对更强的模型有分辨力；
+	// passed 也一并留存，便于反向验证（例如确认某模型确实强于参考模型）。
+	// 新增任务时只在这里加一项：id 取自 LiveBench question.jsonl 的 question_id，
+	// 面板用 --question-id 直接指定，所以题目在题库里是否连续都无所谓。
+	tasks: [
+		{
+			task: "live_bench/math/olympiad",
+			category: "math",
+			taskName: "olympiad",
+			release: "2024-11-25",
+			// 2026-09-12 实测：glm-5.3-flash@max 跑满该任务全量 36 题（并发 4），
+			// 通过 28、失败 8；失败的 8 题全部属于"公式还原"题型。
+			passed: [
+				"ef6c6830ebf0e71d74e7ceb45a242f2b87228933eebfe47db8d798d5738cdaeb", "6e12ab2219a4051c396de5afc4228be52c2d8617c7f5621be8c364f50016c80d",
+				"c03217423ccb2181ef9e3106b4c116aaf1bcdbd45b3a97e04110665690177eca", "698d9bd9ad134096358dad82317dae610d9f265255aeee52c644871b83eb7a85",
+				"56155e5b8c1dc430cc262691aea0a75d71f7dee78b6e15304607caf0b56ecfbd", "3f55db366e970e1965bbba20e9958a4c0ea52e4224d11d875d390983485dd32b",
+				"3649fb05ed87c2f3ed8a933e7c8f032b54a5d6f0d23504cdd578541dd60c0f08", "e5b72d9cdb39c6e5f8798a557f119fff35d98fd165f55659e71bf6ac38b5f178",
+				"bc3551b5f643d8920f428909104fe2640a50f6b8a17fff6196aa78f25df28bb6", "2dd75e080f3e276f3dcf304d970e6a03973ddf777537422c9aba59559ddc9594",
+				"558c3c463860fcaa2b08edd9d5f0f11071944bf7d9229574862a92e6d91f1a21", "e81b96eed50d6b9b43f041d6a36ad0d9a4d00038c42c47a16efd4465d79d08a4",
+				"2191e02b65ac78dd0d28bc13f41786d2596dbaa560ad9d0658a27ae2814faef3", "fc903ff1f1f66a6096c9dea58c278b48f54c80a606b65f82af1730559d73755f",
+				"e56e4d8ed64cb6d0e43ce3c8edda0a77d769b4bda5230c1aba57442e27214694", "749116060528890530a40d111c5506f4cdec004a7c52a87ef0a4a01206c187ec",
+				"6d9bd0806e27f34ff88209075cad638ca0ed6662f499c74bdd3a256d3511b9fe", "9a199388f2e2bd43deac789cd248363bdcb32611480ac27cf62420b4c351759e",
+				"a908da1d873928f9f872dddd33c29620dfa0a54646b79bfde672bd15e6986ec9", "2c17f46f8323e8e692a1827bb18c9a9a43fcff9860b72372cb9551b7cdd532f5",
+				"d805a5c9f398cf5126ee84e6899cc9a3d34444a7e2337d15cdf9cc2a949649ba", "f4fdca7e355eaf9362449ebf7df78a366e239091bdb4c4a34b9dfcf9882f23de",
+				"aba8388e52d25b4006e78d4010c26cf8848c3e3145b0c050b9d55c8aff211fe8", "95b0921a4de64f6e510ac36b5426ecea550c4d3a6033dfbd0d93dd2213fea714",
+				"6df4693c156b7581ffb9a1267a84c055bc9edd8170681b9021bb837f1e9d1167", "1f6132e867a52e5c7b084011484f7fcfec9195f407c9bfb06a3f13f5b709d333",
+				"c6675bf6647188f84ee445590a494a8d516635bad77ace98ec61d28746839a8d", "2c5982946e20e2a85531ac00121697b263591e055ac19586db59a890fdaf98b1",
+			],
+			failed: [
+				"0d3a48049dc5da31531654f59e7866832579f812b892610bd1b178fc4d010d0c", "5b9c56e9392dd999162474f10addf1a3a72f1d8b1c8bafc999ccec6f22194c18",
+				"11f95734f602e7d1481f9887ca7fc8bed83258e22fd5c443449ac159a4732115", "2a82215ea19fcbded36fa95df35b6e7c5f6ed28b0b5f6c3460b4223f1904a536",
+				"527d5f9f9cf27824b84109a495eeced7c7c097fb324b872212f6813a660e5ee4", "f22ff1f6c067d0e085eb79fe5c2e35df01f9edb2bcc73e59e1e15eefd32b8f07",
+				"6dfb6aade6429e2cca0718a497a442299a57199dfd547813471f4cf30ed6c7c7", "0499deda2f068008d488551abf96b4b758c6ed6b79cd2ec6a204d1250b140421",
+			],
+		},
+	],	},
+};
 /** Resolve the profile directory from the config-tree anchor (plugin-market pattern). */
 function resolveProfileDir(ctx) {
 	if (typeof ctx.baseUrl === "string" && ctx.baseUrl.startsWith("file:")) {
@@ -299,6 +354,51 @@ function scanCategoryTasks(dataDir) {
 	return tasks;
 }
 
+/**
+ * 缓存版的 scanCategoryTasks：/config 每次都要它，/results 也要用它算"某 release 下的
+ * 有效题数"。question.jsonl 是静态文件，扫描结果缓存 60s 足够。
+ */
+let taskScanCache = { at: 0, data: null };
+function scanCategoryTasksCached(dataDir) {
+	const now = Date.now();
+	if (taskScanCache.data !== null && now - taskScanCache.at < 60000) return taskScanCache.data;
+	const data = scanCategoryTasks(dataDir);
+	taskScanCache = { at: now, data };
+	return data;
+}
+
+/**
+ * 某个任务在指定 release 下的**有效题数**。
+ * LiveBench 的 --question-begin/--question-end 作用在 release 过滤后的列表上，
+ * 所以边界裁剪必须用这个数，而不是 question.jsonl 的原始行数。
+ * @returns {number|null} null 表示没有该任务的数据（调用方回退到原始题数）。
+ */
+function releaseQuestionCount(tasks, category, task, release) {
+	const meta = (tasks[category] ?? {})[task];
+	if (!meta || !Array.isArray(meta.buckets) || typeof release !== "string" || release.length === 0) return null;
+	let n = 0;
+	for (const b of meta.buckets) {
+		const releasedOk = b.r !== "" && b.r <= release;
+		const notRemoved = b.rm === "" || b.rm > release;
+		if (releasedOk && notRemoved) n += b.n;
+	}
+	return n;
+}
+
+/**
+ * Python `list[begin:end]` 的长度，含越界裁剪。
+ * 面板的「止」是闭区间，所以 end 先 +1 再按切片语义算：
+ *   len = min(total, end+1) - min(total, begin)
+ * 只写 min(total, end-begin+1) 会在 begin 也越界时算多
+ * （8 题填 6-9，实际跑 2 题却算成 4 题）。
+ */
+function clampedRangeLength(total, begin, end) {
+	if (!Number.isFinite(total) || total <= 0) return null;
+	const b = Math.max(0, Math.min(total, Number(begin)));
+	const e = Math.max(0, Math.min(total, Number(end) + 1));
+	return Math.max(0, e - b);
+}
+
 function readDirSafe(dir) {
 	try {
 		return readdirNames(dir);
@@ -510,6 +610,23 @@ function parseAnswerLineLight(line) {
  */
 let resultsCache = { at: 0, data: null };
 
+/**
+ * 答案行是否"没产出内容"。
+ *
+ * 两类：
+ *   1. `eval_status: token_exhaustion` —— 推理模型把 max_tokens 全烧在思考上，正文为空；
+ *   2. `turns` / `choices` 是空串或空数组 —— 上游 200 但没给内容。
+ *
+ * 这两种都不是"做错了"，而是**没做出来**，不该进正确率的分母（用户口径：
+ * 做对的题 / 做出来的题）。它们也不是 $ERROR$（那是 API 失败），所以单列一类。
+ *
+ * 用正则直接扫原始行，避免为了判定空答案去 JSON.parse 上百万字节的答案文件。
+ */
+const EMPTY_ANSWER_RE = /"eval_status"\s*:\s*"token_exhaustion"|"turns"\s*:\s*\[\s*(?:""\s*)?\]|"choices"\s*:\s*\[\s*""\s*\]/;
+function isEmptyAnswerLine(line) {
+	return EMPTY_ANSWER_RE.test(line);
+}
+
 async function readTextFileAsync(path) {
 	const fsPromises = await import("node:fs/promises");
 	try {
@@ -551,11 +668,12 @@ async function computeResults(dataDir) {
 				const text = await readTextFileAsync(join(answerDir, file));
 				if (text === null) continue;
 				const key = `${model}\u0000${task}`;
-				const stat = answers.get(key) ?? { answered: 0, errors: 0 };
+				const stat = answers.get(key) ?? { answered: 0, errors: 0, empty: 0 };
 				for (const line of text.split("\n")) {
 					if (line.trim().length === 0) continue;
 					stat.answered += 1;
 					if (line.includes('"$ERROR$"')) stat.errors += 1;
+					else if (isEmptyAnswerLine(line)) stat.empty += 1;
 				}
 				// 空文件（尚未产出答案，或成绩已被删除只留下 0 字节壳）不计入结果：
 				// 否则删掉的记录会在下一次扫描时凭“文件名仍在”重新冒出来。
@@ -591,8 +709,13 @@ async function computeResults(dataDir) {
 		const category = entry?.category ?? catByTask.get(task) ?? "";
 		const total = totals.get(task) ?? 0;
 		const judgedCount = entry?.n ?? 0;
-		// 做完的题 = 实际产出的有效答案（尝试数 - 访问失败数）
-		const done = Math.max(0, stat.answered - stat.errors);
+		// 「做出来」的题 = 尝试数 - API 失败 - 空答案。
+		// 关键：思考吃满 max_tokens、正文为空的题属于"没做出来"，不是"做错了"，
+		// 必须从正确率分母里剔除，否则一个模型 8 题里只答出 1 题（0.9167 分）
+		// 会被算成 11.5% 而不是 91.7%。
+		const empty = stat.empty ?? 0;
+		const notProduced = stat.errors + empty;
+		const done = Math.max(0, stat.answered - notProduced);
 		// 选择题数 = 用户在「题目序号范围」里选择的题数（end 含端点）。
 		// 有元数据就直接用范围大小；没有元数据（历史数据）时用本次实际写入的答案行数兜底：
 		// LiveBench 会为范围内每一题写一行（访问失败也写 $ERROR$），所以跑完后
@@ -608,15 +731,27 @@ async function computeResults(dataDir) {
 				return true;
 			});
 			if (inScope) {
+				// 「可选题目总数」的基准，按优先级取：
+				//   baseline 子集大小 > 该任务在本次 release 下的有效题数 > question.jsonl 原始行数。
+				// 基准取错会把越界的范围当成有效选择（题库只有 8 题而用户填 0-8 时算出 9 题），
+				// 于是 notDone 永远多 1，全做对也显示 (-1/8)。
+				const byRelease = releaseQuestionCount(scanCategoryTasksCached(dataDir), category, task, meta.release);
+				const baselineTotal = Number.isFinite(Number(meta.baselineSize)) && Number(meta.baselineSize) > 0
+					? Number(meta.baselineSize)
+					: null;
+				const scopeTotal = baselineTotal ?? byRelease ?? total;
 				const hasRange = meta.begin !== null && meta.begin !== undefined && meta.end !== null && meta.end !== undefined;
-				if (hasRange) configured = Math.min(total, Number(meta.end) - Number(meta.begin) + 1);
+				if (hasRange) {
+					const len = clampedRangeLength(scopeTotal, Number(meta.begin), Number(meta.end));
+					if (len !== null) configured = len;
+				}
 			}
 		}
 		// 实际尝试数比设定还多（断点重跑等）时，以实际为准
 		if (configured < stat.answered) configured = stat.answered;
 		const notDone = Math.max(0, configured - done);
-		// 正确率 = 做对的题 / 已判分的做完题（访问失败/未做的题不计入分母）
-		const judgedDone = Math.max(0, judgedCount - stat.errors);
+		// 正确率 = 做对的题 / **做出来的题**（API 失败、思考吃满 token 没产出答案的都不进分母）
+		const judgedDone = Math.max(0, judgedCount - notProduced);
 		const score = entry && judgedDone > 0 ? (entry.sum / judgedDone) * 100 : null;
 		return {
 			model,
@@ -628,11 +763,15 @@ async function computeResults(dataDir) {
 			time: entry && entry.time > 0 ? entry.time : null,
 			answered: stat.answered,
 			errors: stat.errors,
+			empty,
+			notProduced,
 			done,
 			configured,
 			notDone,
 			// 本次运行的开始时间（ISO）；旧数据没有元数据时为 null，前端退回解析 displayName 里的运行戳
 			runStartedAt: meta !== undefined && typeof meta.startedAt === "string" ? meta.startedAt : null,
+			// 非 null 表示这一行跑的是 Baseline 题库子集，不是该任务全量
+			baselineLabel: meta !== undefined && typeof meta.baselineLabel === "string" ? meta.baselineLabel : null,
 		};
 	});
 	// taskTotals 同时给出裸任务名与 `category/task` 两种键，便于前端按列取题目总数
@@ -743,7 +882,7 @@ function apply(ctx) {
 		}
 		const providerId = typeof body.provider === "string" ? body.provider : "";
 		const modelId = typeof body.model === "string" ? body.model.trim() : "";
-		const release = typeof body.release === "string" ? body.release : "2024-11-25";
+		let release = typeof body.release === "string" ? body.release : "2024-11-25";
 		const category = typeof body.category === "string" && body.category.length > 0 ? body.category : null;
 		const task = typeof body.task === "string" && body.task.length > 0 ? body.task : null;
 		const reasoningEffort = typeof body.reasoningEffort === "string" && body.reasoningEffort.length > 0 && body.reasoningEffort !== "default" ? body.reasoningEffort : null;
@@ -764,8 +903,44 @@ function apply(ctx) {
 		// Multi-select support: the client resolves its category/task chips into
 		// an explicit bench-path list ("live_bench", "live_bench/<cat>",
 		// "live_bench/<cat>/<task>"); gen_api_answer accepts nargs="+".
+		// Baseline 题库则完全绕开分类/任务选择（"不选 = 全部分类"不适用），
+		// 锁定到它自己的任务 + 一组 question id。
+		const baselineKey = typeof body.baseline === "string" && body.baseline.length > 0 ? body.baseline : null;
+		const baseline = baselineKey !== null ? (BASELINE_SETS[baselineKey] ?? null) : null;
+		if (baselineKey !== null && baseline === null) {
+			return { status: 400, payload: { ok: false, error: `unknown baseline: ${baselineKey}` } };
+		}
 		let benchNames = null;
-		if (Array.isArray(body.benchNames) && body.benchNames.length > 0) {
+		// Baseline 是三层选择：参考模型 + 任务 + 对/错。服务端负责把选择解析成 question id 列表，
+		// 客户端只送选择，不送 id —— 免得界面与题库数据脱节。
+		let baselinePick = null;
+		if (baseline !== null) {
+			const taskKey = typeof body.baselineTask === "string" ? body.baselineTask : "";
+			const picks = Array.isArray(body.baselinePicks)
+				? body.baselinePicks.filter((p) => p === "passed" || p === "failed")
+				: [];
+			const baselineTask = baseline.tasks.find((t) => t.task === taskKey) ?? null;
+			if (baselineTask === null) {
+				return { status: 400, payload: { ok: false, error: `baseline ${baselineKey}: 未选择任务（或任务不存在）：${taskKey}` } };
+			}
+			if (picks.length === 0) {
+				return { status: 400, payload: { ok: false, error: `baseline ${baselineKey}/${taskKey}: 请至少选择「做对」或「做错」之一` } };
+			}
+			const ids = [];
+			const seen = new Set();
+			for (const pick of picks) {
+				for (const qid of baselineTask[pick]) {
+					if (!seen.has(qid)) { seen.add(qid); ids.push(qid); }
+				}
+			}
+			if (ids.length === 0) {
+				return { status: 400, payload: { ok: false, error: `baseline ${baselineKey}/${taskKey}: 所选分组没有题目` } };
+			}
+			// baseline 的 question id 属于特定 release，跟着用户选别的 release 会一题都匹配不到
+			release = baselineTask.release;
+			benchNames = [baselineTask.task];
+			baselinePick = { label: baseline.label, task: baselineTask.task, picks, ids };
+		} else if (Array.isArray(body.benchNames) && body.benchNames.length > 0) {
 			if (body.benchNames.length > 24) {
 				return { status: 400, payload: { ok: false, error: "too many bench names (max 24)" } };
 			}
@@ -824,13 +999,23 @@ function apply(ctx) {
 			"--bench-name",
 			...(benchNames !== null ? benchNames : [benchParts.join("/")]),
 			"--livebench-release-option", release,
-			"--max-tokens", String(asInt(body.maxTokens, 256, 32768, 32000)),
+			// 上限放到 200k：推理模型在难题上会把 max_tokens 全烧在思考里，正文为空
+			// （eval_status=token_exhaustion），此时"做不出来"其实是预算不够而不是能力不够。
+			// 旧上限 32768 在 olympiad 这类题上会直接把参考模型卡死。
+			"--max-tokens", String(asInt(body.maxTokens, 256, 200000, 32000)),
 			"--parallel-requests", String(asInt(body.parallel, 1, 8, 1)),
 			// 流式：中转网关（Cloudflare 等）对非流式请求有 ~100s 超时（524），
 			// 高推理强度模型思考数分钟必然超时。流式保持字节流动可规避。
 			"--stream",
 			"--mode", "single",
 		];
+		// Baseline：直接点名 question id。--question-id 是 nargs="+"，后面跟一串 id；
+		// 它和后面的 --question-begin/--question-end 叠加时，范围作用在**id 过滤后**的
+		// 列表上（gen_api_answer: load_questions(..., question_id) 之后才做 [begin:end]），
+		// 所以「题目序号范围」对 baseline 题库同样有效。
+		if (baselinePick !== null) {
+			args.push("--question-id", ...baselinePick.ids);
+		}
 		if (body.begin !== undefined && body.begin !== null && `${body.begin}`.length > 0) {
 			args.push("--question-begin", String(asInt(body.begin, 0, 100000, 0)));
 		}
@@ -897,6 +1082,17 @@ function apply(ctx) {
 				benchNames: benchNames !== null ? benchNames : [benchParts.join("/")],
 				begin: body.begin ?? null,
 				end: body.end ?? null,
+				// 算"本次设定题数"要用 release 过滤后的有效题数来裁剪边界，所以必须记下来
+				release,
+				// baseline 评测标出来：成绩表里同一列会混着"全量"和"题库子集"两种分数，
+				// 不标注就没法解读。
+				baseline: baselinePick !== null ? baselineKey : null,
+				baselineLabel: baselinePick !== null
+					? `${baselinePick.label} · ${baselinePick.task.split("/").slice(-1)[0]} · ${baselinePick.picks.map((p) => (p === "passed" ? "做对" : "做错")).join("+")}`
+					: null,
+				baselineTask: baselinePick !== null ? baselinePick.task : null,
+				baselinePicks: baselinePick !== null ? baselinePick.picks : null,
+				baselineSize: baselinePick !== null ? baselinePick.ids.length : null,
 				startedAt: new Date().toISOString(),
 			}), "utf8");
 		} catch { /* 元数据写入失败不影响评测 */ }
@@ -1005,7 +1201,22 @@ function apply(ctx) {
 				available: layout.available,
 				root: layout.root,
 				releases: RELEASES,
-				tasks: scanCategoryTasks(layout.dataDir),
+				tasks: scanCategoryTasksCached(layout.dataDir),
+				// Baseline 题库：参考模型在各任务上的实测对错，供"探针"式快速评测选用
+				baselines: Object.values(BASELINE_SETS).map((b) => ({
+					id: b.id,
+					label: b.label,
+					referenceModel: b.referenceModel,
+					tasks: b.tasks.map((t) => ({
+						task: t.task,
+						category: t.category,
+						taskName: t.taskName,
+						release: t.release,
+						total: t.passed.length + t.failed.length,
+						passedCount: t.passed.length,
+						failedCount: t.failed.length,
+					})),
+				})),
 				providers: providers.map(({ id, name: pname, models, api, baseURL }) => ({
 					id,
 					name: pname,
@@ -1223,4 +1434,4 @@ function apply(ctx) {
 	}), `${name}: delete route`);
 }
 
-export { name, inject, apply, writeGeneratedModelConfig, readProviders, validateBenchName };
+export { name, inject, apply, writeGeneratedModelConfig, readProviders, validateBenchName, clampedRangeLength, releaseQuestionCount, isEmptyAnswerLine };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-livebench-panel",
-  "version": "0.2.18",
-  "description": "DSH web plugin: a LiveBench tab in the Trajectory view (right of 对话/轨迹). Run LiveBench evaluations against every model configured in the DeepSeek Harness — pick provider/model, category, task, release and question range from dropdowns, watch progress, and read scores in place.",
+  "version": "0.2.21",
+  "description": "DSH web plugin: a LiveBench tab in the Trajectory view (right of 对话/轨迹). Run LiveBench evaluations against every model configured in the DeepSeek Harness — pick provider/model, category, task, release and question range from dropdowns, watch progress, and read scores in place. Ships a Baseline probe set built from the questions a reference model cannot solve.",
   "license": "MIT",
   "author": "cszr (Vithrive)",
   "type": "module",