codebee 0.1.95 → 0.1.97

package/app/ui/app.js

@@ -840,8 +840,12 @@ function recommendTaskType(goal) {
     // 专属词在前（简历/PPT/标书的目标里常带技术词，放 code 之后会被截胡，
     // 「优化我的简历，投后端岗」实测命中 code——2026-10-07 巡检）：
     ["resume", /(简历|求职|应聘)/i],
-    ["presentation", /(演示文稿|ppt|幻灯片|答辩)/i],
+    ["presentation", /(演示文稿|ppt|幻灯片|答辩|演示场合)/i],
     ["bid_doc", /(标书|投标|招标应答)/i],
+    // 缺陷复盘同为专属词（「复盘这些bug」会被 code 的 bug 词截胡）：要求复盘
+    // 与 bug/缺陷 共现（或命中漏测），纯 debug（「分析这个bug」）仍归 code。
+    ["defect_retro",
+     /(缺陷复盘|漏测|(bug|缺陷)[^，。；]{0,10}复盘|复盘[^，。；]{0,10}(bug|缺陷))/i],
     ["code", /(代码|bug|报错|修复|重构|接口|数据库|前端|后端|python|javascript|typescript|java|go\b|git)/i],
     ["translation", /(翻译|译成|translate|translation|中译英|英译中)/i],
     ["email", /(邮件|email|e-mail|回信|邀约信|商务函)/i],
@@ -849,11 +853,18 @@ function recommendTaskType(goal) {
     ["video_script", /(短视频|口播|分镜|抖音|b站|视频号|视频脚本)/i],
     ["speech", /(演讲稿|发言稿|致辞|演讲)/i],
     ["tech_proposal", /(技术方案|架构方案|选型方案|实施方案)/i],
-    ["research", /(调研报告|竞品调研|市场调研|深度研究)/i],
-    ["serial_novel", /(连载|续写.*章|网文|长篇小说)/i],
+    ["research", /(调研|深度研究)/i],
+    // goal_hint 引导词对齐（2026-10-08 第二轮巡检）：serial_novel 例句
+    // 「都市女频/可签约平台」、article 提示「头条/知乎」——照提示输入
+    // 此前不弹类型建议（同 video_script 补词第 3 例缝隙）。
+    ["serial_novel", /(连载|续写.*章|网文|长篇小说|女频|男频|签约平台)/i],
     ["novel", /(小说|故事|短篇|章节)/i],
-    ["article", /(公众号|自媒体|文章|博客|小红书)/i],
+    ["article", /(公众号|自媒体|文章|博客|小红书|头条|知乎)/i],
     ["doc", /(文档|操作手册|说明书)/i],
+    // 宽词放末位兜底（「电影排行榜文章」由前面的 article 先接住）；词形对齐
+    // rank_scan 的 goal_hint（「默认分析总榜热门题材」）。至此 direct 之外
+    // 17 型推荐规则全覆盖（2026-10-08 巡检补 rank_scan/defect_retro 两型）。
+    ["rank_scan", /(扫榜|热门题材|榜单分析|排行榜)/i],
   ];
   const hit = rules.find((x) => x[1].test(s));
   return hit && flowById(hit[0]) ? hit[0] : "";
@@ -3117,9 +3128,13 @@ async function createTask() {
     if (suggested) {
       const flow = flowById(suggested) || {};
       resetSubmit();
+      // 快档目标（rank_scan/defect_retro）没有评审门禁，卖点如实换成各自的
+      // 专用数据链路/产出模板；review/code 目标维持门禁口径。
+      const tail = flow.engine === "direct"
+        ? t("这个需求更适合「{0}」流程，能使用对应的专用数据链路与产出模板。是否切换后执行？")
+        : t("这个需求更适合「{0}」流程，能使用对应的规划与质量门禁。是否切换后执行？");
       const yes = await uiConfirm(
-        t("这个需求更适合「{0}」流程，能使用对应的规划与质量门禁。是否切换后执行？")
-          .replace("{0}", t(flow.name || suggested)),
+        tail.replace("{0}", t(flow.name || suggested)),
         { title: t("推荐任务类型"), ok: t("切换类型") });
       S.typeSuggestionDone = true;
       if (yes) pickType(suggested);
@@ -3847,6 +3862,7 @@ async function renameTask(id) {
 async function retryTask(id) {
   try {
     const r = await api("/api/tasks/" + encodeURIComponent(id) + "/retry", { method: "POST" });
+    chatJumpLatest();   // 续跑副本开新一轮：时间线要跳到最新，别停在原地或历史中间
     jumpToRun(r.run_id);
   } catch (e) { toast(t("重试失败：") + e.message, true); return; }
   poll();
@@ -3873,6 +3889,7 @@ async function continueSerial(id) {
     r = await api("/api/tasks/" + encodeURIComponent(id) + "/continue",
       { method: "POST", body: JSON.stringify({ chapters: ch }) });
   } catch (e) { toast(t("创建续写任务失败：") + e.message, true); return; }
+  chatJumpLatest();   // 续写批次开新一轮：对话时间线跳到最新
   jumpToRun(r.run_id);
   poll();
 }
@@ -4548,6 +4565,7 @@ window.sideOpenRun = function (id, n) {
  * 按时间顺序列出该任务全部 run 的全部步骤，run 之间加分隔条。 */
 window.sideOpenTask = function (key) {
   _taskStepRenderToken++;
+  chatJumpLatest();   // 首开任务详情：对话时间线落最新（默认落蜂巢时切到对话页签也带到底）
   $("rd-steps").innerHTML = '<div class="hint" role="status">' + esc(t("正在加载任务详情…")) + "</div>";
   S.lastRun = null;
   S.detailTaskKey = key;
@@ -4678,12 +4696,127 @@ function renderTaskDetail() {
   setResumeNowBtn(null);   // 退避与否要看 run 数据，先收起防上一个任务残留
   const isTask = ((S.state || {}).tasks || []).some((t2) => t2.id === key);
   if (isTask) {
+    renderProjectMemoryControls(key);
+    renderCheckpointControls(latestSummary.id || "", true);
+    refreshCheckpointRestoreAvailability(latestSummary);
+    if (latestSummary.id && S._checkpointRun !== latestSummary.id) {
+      S._checkpointRun = latestSummary.id;
+      loadRunCheckpoints(latestSummary.id);
+    }
     loadTaskRuns(key, latestSummary);
     return;
   }
   drawTaskDetail(key, ((S.state || {}).runs || []).filter((r) => (r.task_id || r.id) === key));
 }
 
+function renderCheckpointControls(runId, visible) {
+  const box = $("rd-checkpoints");
+  if (!box) return;
+  box.classList.toggle("hidden", !visible || !runId);
+  if (runId && box.dataset.runId !== runId) {
+    box.dataset.runId = runId;
+    box.dataset.hasRestorable = "false";
+    const restore = $("rd-checkpoints-restore");
+    if (restore) restore.classList.add("hidden");
+    box.classList.add("needs-load");
+  }
+}
+
+function refreshCheckpointRestoreAvailability(run) {
+  const box = $("rd-checkpoints");
+  const button = $("rd-checkpoints-restore");
+  if (!box || !button) return;
+  const terminal = !!run && ["done", "failed", "cancelled", "timeout"].includes(run.status);
+  button.classList.toggle("hidden", !terminal || box.dataset.hasRestorable !== "true");
+}
+
+function renderProjectMemoryControls(taskId) {
+  const box = $("rd-project-memory");
+  if (!box) return;
+  const task = ((S.state || {}).tasks || []).find((item) => item.id === taskId);
+  box.classList.toggle("hidden", !task || !task.workdir);
+  if (task && task.workdir && S._projectMemoryTask !== taskId) {
+    S._projectMemoryTask = taskId;
+    loadProjectMemory(taskId);
+  }
+}
+
+window.loadProjectMemory = async function (taskId) {
+  taskId = taskId || S.detailTaskKey || ((S.state || {}).tasks || []).find((item) => item.id === S.lastRunTask?.id)?.id;
+  if (!taskId) return;
+  const requestSeq = S._projectMemorySeq = (S._projectMemorySeq || 0) + 1;
+  const box = $("rd-project-memory-body");
+  if (!box) return;
+  box.textContent = t("正在加载项目记忆…");
+  try {
+    const data = await api("/api/tasks/" + encodeURIComponent(taskId) + "/memory");
+    if (requestSeq !== S._projectMemorySeq) return;
+    if (S.detailTaskKey && S.detailTaskKey !== taskId) return;
+    const entries = data.entries || [];
+    if (!entries.length) { box.innerHTML = '<span class="hint">' + esc(t("暂无项目记忆")) + "</span>"; return; }
+    box.innerHTML = entries.map((entry) => {
+      const canApprove = entry.status === "pending" && !entry.expired && entry.verified;
+      const canRestore = entry.status === "archived" && !entry.expired && entry.verified;
+      const actions = (canApprove ? '<button type="button" class="ghost small" onclick="decideProjectMemory(\'' + jsq(taskId) + '\',\'' + jsq(entry.id) + '\',\'approve\',' + Number(entry.version) + ')">' + esc(t("批准")) + "</button><button type=\"button\" class=\"ghost small\" onclick=\"decideProjectMemory('" + jsq(taskId) + "','" + jsq(entry.id) + "','reject'," + Number(entry.version) + ')\">' + esc(t("拒绝")) + "</button>" : "") +
+        (entry.status === "approved" ? '<button type="button" class="ghost small" onclick="decideProjectMemory(\'' + jsq(taskId) + '\',\'' + jsq(entry.id) + '\',\'archive\',' + Number(entry.version) + ')">' + esc(t("归档")) + "</button>" : "") +
+        (canRestore ? '<button type="button" class="ghost small" onclick="decideProjectMemory(\'' + jsq(taskId) + '\',\'' + jsq(entry.id) + '\',\'restore\',' + Number(entry.version) + ')">' + esc(t("恢复")) + "</button>" : "");
+      return '<article class="rd-memory-row"><div><strong>' + esc(entry.title || t("项目记忆")) + '</strong><span class="chip">' + esc(entry.status || "") + (entry.expired ? " · " + esc(t("已过期")) : "") + '</span></div><pre>' + esc(entry.content || "") + '</pre><div class="rd-memory-actions">' + actions + "</div></article>";
+    }).join("");
+  } catch (error) { box.innerHTML = '<span class="hint">' + esc(t("加载项目记忆失败：")) + esc(error.message) + "</span>"; }
+};
+
+window.decideProjectMemory = async function (taskId, id, action, version) {
+  try {
+    await api("/api/tasks/" + encodeURIComponent(taskId) + "/memory", {
+      method: "POST", headers: Object.assign({ "Content-Type": "application/json" }, authHeaders()),
+      body: JSON.stringify({ id, action, expected_version: version }),
+    });
+    await loadProjectMemory(taskId);
+  } catch (error) { toast(t("项目记忆操作失败：") + error.message, true); }
+};
+
+window.loadRunCheckpoints = async function (requestedRunId) {
+  const runId = requestedRunId || S.detailRunId || ((S.state || {}).task_latest || {})[S.detailTaskKey]?.id;
+  if (!runId) return;
+  const requestSeq = S._checkpointRequestSeq = (S._checkpointRequestSeq || 0) + 1;
+  const body = $("rd-checkpoints-body");
+  const box = $("rd-checkpoints");
+  box.classList.remove("hidden");
+  body.textContent = t("正在读取文件检查点…");
+  try {
+    const data = await api("/api/runs/" + encodeURIComponent(runId) + "/checkpoints");
+    if (requestSeq !== S._checkpointRequestSeq) return;
+    if (S.detailRunId && S.detailRunId !== runId) return;
+    if (S.detailTaskKey) {
+      const current = ((S.state || {}).task_latest || {})[S.detailTaskKey];
+      if (current && current.id !== runId) return;
+    }
+    const files = data.files && data.files.files || [];
+    const restore = $("rd-checkpoints-restore");
+    const latest = S.detailTaskKey && ((S.state || {}).task_latest || {})[S.detailTaskKey];
+    const run = (S.lastRun && S.lastRun.id === runId) ? S.lastRun : latest;
+    box.dataset.hasRestorable = files.some((file) => file.restorable) ? "true" : "false";
+    refreshCheckpointRestoreAvailability(run);
+    body.innerHTML = (data.files && data.files.warning ? '<p class="hint">' + esc(data.files.warning) + "</p>" : "") +
+      (files.length ? files.map((file) => '<article class="rd-checkpoint-row"><strong>' + esc(file.path) + '</strong><span class="chip">' + esc(file.status) + (file.restorable ? " · " + esc(t("可恢复")) : "") + '</span><pre>' + esc(file.diff || "") + "</pre></article>").join("") : '<span class="hint">' + esc(t("此运行没有文件快照")) + "</span>");
+    box.dataset.runId = runId;
+    box.classList.remove("needs-load");
+  } catch (error) { body.innerHTML = '<span class="hint">' + esc(t("检查点读取失败：")) + esc(error.message) + "</span>"; }
+};
+
+window.restoreRunCheckpoints = async function () {
+  const runId = $("rd-checkpoints")?.dataset.runId;
+  if (!runId || !await uiConfirm(t("恢复会覆盖检查点记录的文件，shell、MCP 和外部服务副作用不保证可回滚。确定继续？"), { ok: t("恢复文件"), danger: true })) return;
+  try {
+    const result = await api("/api/runs/" + encodeURIComponent(runId) + "/checkpoints/restore", {
+      method: "POST", headers: Object.assign({ "Content-Type": "application/json" }, authHeaders()),
+      body: JSON.stringify({ confirm: true }),
+    });
+    toast(t("已恢复 ") + (result.restored || 0) + t(" 个文件") + ((result.conflicts || []).length ? "；" + t("冲突 ") + result.conflicts.join(", ") : ""));
+    await loadRunCheckpoints();
+  } catch (error) { toast(t("恢复失败：") + error.message, true); }
+};
+
 function loadTaskRuns(key, latestSummary) {
   const cached = _taskRunsCache.get(key);
   if (cached) {
@@ -5101,6 +5234,7 @@ window.cancelAllRuns = cancelAllRuns;
 
 async function openRun(id, pinTab) {
   _taskStepRenderToken++;
+  chatJumpLatest();   // 首开运行详情：对话时间线落最新（历史长时别停在顶部）
   S.detailRunId = id;
   S.detailTaskKey = null;
   S.runDetailSig = "";   // 新目标首帧必画；也兜住「任务态改过 DOM 后回到本运行」的串台
@@ -5185,6 +5319,10 @@ function rdTabAvail() {
 
 function applyRdTabs() {
   const avail = rdTabAvail();
+  // 「切进对话页签」以 pane 入口前的真实显隐为准：rdChatNavGo/setRdTab 等
+  // 入口都是先改 S.rdTab 再进来，函数内抓 S.rdTab 旧值抓不到过渡。
+  const _chatPaneIn = document.querySelector('#run-detail .rd-pane[data-pane="chat"]');
+  const chatWasHidden = !_chatPaneIn || _chatPaneIn.classList.contains("hidden");
   if (!S.rdTab || !avail[S.rdTab]) {
     S.rdTab = ["chat", "hive", "steps", "result", "preview", "git", "bible", "bookmeta"]
       .find((k) => avail[k]) || "steps";
@@ -5209,6 +5347,17 @@ function applyRdTabs() {
   }
   // 对话页签不放日志抽屉：会盖住贴底输入条（手动切来/自动选卡都覆盖）
   if (S.rdTab === "chat" && !$("rd-log").classList.contains("hidden")) window.rdLogClose();
+  // 切进对话页签且带着跳最新标记（继续任务/首开详情置的）：把时间线带到底。
+  // 内容已与当前 run 对齐（drawChatFlow 盖的 run 戳）才就地落底并消费——内容
+  // 还是上一轮的旧帧（续跑换 run、/timeline 在途）则保留标记，等 drawChatFlow
+  // 重建完新内容再落底，避免停在旧帧尾、新一轮气泡压在折叠线下面。
+  if (S.rdTab === "chat" && chatWasHidden && chatForceBottom) {
+    const fl = $("rd-chat-flow");
+    if (fl && fl.dataset.runId && fl.dataset.runId === chatRunId) {
+      chatScrollBottomNow(fl);
+      chatForceBottom = false;
+    }
+  }
   renderChatNav();
 }
 
@@ -5467,6 +5616,18 @@ async function renderRunDetail() {
   $("btn-share").classList.toggle("hidden", active);   // 分享页：结束后可生成自包含 HTML
   $("btn-talk").classList.toggle("hidden", !(run.task_id && !chatEngineIsDirect(run)));
   const rcTask = ((S.state || {}).tasks || []).find((x) => x.id === run.task_id);
+  if (rcTask) {
+    renderProjectMemoryControls(rcTask.id);
+  } else {
+    const memoryBox = $("rd-project-memory");
+    if (memoryBox) memoryBox.classList.add("hidden");
+  }
+  renderCheckpointControls(run.id, !!rcTask);
+  refreshCheckpointRestoreAvailability(run);
+  if (rcTask && S._checkpointRun !== run.id) {
+    S._checkpointRun = run.id;
+    loadRunCheckpoints(run.id);
+  }
   // 签名守卫（模型页/检查器同款）：数据没变不重绘。详情区是全页最重的
   // 渲染面，此前 SSE 推送+轮询每 8s 无差别整块重写，是「页面一闪一闪、
   // 发布表单填一半被清空」的总根源（2026-09-30 用户实案）。运行中 ETA
@@ -5980,6 +6141,7 @@ function pbBlock(task, platform) {
   }
   const busy = st === "busy";
   let btns = "";
+  let pendHtml = "";   // 批量选择 chips（bookReady 分支里填充，extra 段落拼接）
   if (st === "none" || st === "error" || st === "waiting_login") {
     btns += '<button class="ghost" onclick="pbConnect(\'' + platform + '\')">' +
       (st === "error" ? t("重连") : t("连接平台")) + "</button>";
@@ -6006,11 +6168,62 @@ function pbBlock(task, platform) {
     if (run && run.status === "running") {
       btns += '<span class="pb-book">' + esc(t("自动发布中 ") + run.done + "/" + run.total) + "</span>";
     } else if (au.pending > 0) {
-      btns += ' <button class="ghost" ' + (busy || !au.guard_ok ? "disabled" : "") +
-        ' title="' + esc(au.guard_ok ? t("按章号顺序逐章填稿（人工模式每点一次填一章，浏览器里提交后再点发下一章）") : au.guard_reason || "") + '"' +
+      // 门禁不再禁用按钮：点了走 pbApiWithQualityOverride 的复审/强制对话，
+      // 死按钮只会让用户无路可走（2026-10-08 实案：guard false 全灰点不了）
+      btns += ' <button class="ghost" ' + (busy ? "disabled" : "") +
+        ' title="' + esc(au.guard_ok ? t("按章号顺序逐章填稿（人工模式每点一次填一章，浏览器里提交后再点发下一章）") : t("护栏提示：") + (au.guard_reason || "")) + '"' +
         ' onclick="pbPublishAll(\'' + esc(task.id) + "', '" + platform + '\')">' +
         t("发布全部待发") + t("（") + au.pending + t("）") + "</button>";
     }
+    // 批量选择：待发章号 chips 按卷分组（卷计划来自服务端 items[].volume），
+    // 「发布所选」人工模式 / 「直发所选」逐章自动提交（护栏照常生效）。
+    // 分卷由服务端按卷计划自动选/建（volumes.py），界面上不用管卷。
+    const its = (au.items && au.items.length ? au.items : [])
+      .map((x) => ({ n: Number(x.chapter_no), v: x.volume || "" }))
+      .filter((x) => x.n > 0);
+    if (its.length && !run) {
+      const key = task.id + ":" + platform;
+      const sig = its.map((x) => x.n).join(",");
+      S.pbSel = S.pbSel || {};
+      if (!S.pbSel[key] || S.pbSel[key].sig !== sig)
+        S.pbSel[key] = { sig, sel: new Set(its.map((x) => x.n)) };
+      const sel = S.pbSel[key].sel;
+      // 连续段按卷名分组；无卷计划的整块平铺不显示卷头
+      const groups = [];
+      for (const x of its) {
+        const g = groups[groups.length - 1];
+        if (g && g.v === x.v) g.ns.push(x.n);
+        else groups.push({ v: x.v, ns: [x.n] });
+      }
+      let chips = "";
+      for (const g of groups) {
+        if (groups.length > 1 || g.v)
+          chips += '<div class="pb-vol">' + esc(g.v || t("未分卷")) + "</div>";
+        for (const n of g.ns)
+          chips += '<label class="pb-chip' + (sel.has(n) ? " on" : "") + '">' +
+            '<input type="checkbox" ' + (sel.has(n) ? "checked" : "") +
+            ' onchange="pbSelToggle(\'' + esc(task.id) + "','" + platform + "'," + n + ',this.checked)">' +
+            n + "</label>";
+      }
+      pendHtml += '<div class="pb-pend" data-key="' + esc(key) + '">' +
+        '<div class="pb-pend-head">' +
+        '<span>' + esc(t("待发 ")) + its.length + esc(t(" 章（按卷计划自动分卷）")) + "</span>" +
+        '<a href="javascript:void(0)" onclick="pbSelAll(\'' + esc(task.id) + "','" + platform + "',true)" + '">' + esc(t("全选")) + "</a>" +
+        '<a href="javascript:void(0)" onclick="pbSelAll(\'' + esc(task.id) + "','" + platform + "',false)" + '">' + esc(t("清空")) + "</a>" +
+        "</div>" +
+        '<div class="pb-pend-chips">' + chips + "</div>" +
+        '<div class="pb-pend-btns">' +
+        '<button class="ghost" ' + (busy || !sel.size ? "disabled" : "") +
+        ' title="' + esc(au.guard_ok ? "" : t("护栏提示：") + (au.guard_reason || "")) + '"' +
+        ' onclick="pbPublishSelected(\'' + esc(task.id) + "','" + platform + '\',false)">' +
+        t("发布所选") + t("（") + sel.size + t("）") + "</button>" +
+        '<button class="ghost" ' + (busy || !sel.size ? "disabled" : "") +
+        ' title="' + esc(t("所选章节逐章自动提交（无人值守），护栏每日上限/连败退避照常生效") +
+          (au.guard_ok ? "" : "；" + t("护栏提示：") + (au.guard_reason || ""))) + '"' +
+        ' onclick="pbPublishSelected(\'' + esc(task.id) + "','" + platform + '\',true)">' +
+        t("直发所选") + t("（") + sel.size + t("）") + "</button>" +
+        "</div></div>";
+    }
     if (au.pending > 0 && !au.guard_ok) {
       btns += '<div class="pb-err">' + esc(au.guard_reason || t("护栏拦截")) + "</div>";
     }
@@ -6040,6 +6253,7 @@ function pbBlock(task, platform) {
       esc(t("作品已在平台建好（建书流程没走通或手工建的）？补登记后直接发章，不会在平台新建")) + '">' + t("登记已有作品") + "</button>";
   }
   let extra = "";
+  extra += pendHtml;
   if (st === "error" && !bookReady && ps.last_action === "create_book") {
     extra += '<div class="pb-hint">' + esc(t("若作品其实已在平台建好，点「登记已有作品」补登记，勿重复创建")) + "</div>";
   }
@@ -6287,8 +6501,71 @@ window.pbConfirmChapter = async function (taskId, platform, chapterNo) {
   S._pbSig = ""; pbKick();
 };
 
-window.pbPublishAll = async function (taskId, platform) {
-  const au = (((S.pubAuto && S.pubAuto.books) || [])
+function pbSelCountSync(key) {
+  // 就地对账：按钮计数/禁用态与全部 chip 勾选态向状态层看齐——重绘链一旦
+  // 断掉（poll 失败/详情上下文切换），勾选与计数也不许脱节（2026-10-08 实案
+  // 「勾了 18 计数 48」即重绘未跟上）。
+  const box = document.querySelector('.pb-pend[data-key="' +
+    String(key).replace(/"/g, "&quot;") + '"]');
+  const ent = (S.pbSel || {})[key];
+  if (!box || !ent) return;
+  for (const b of box.querySelectorAll("button")) {
+    const t = b.textContent || "";
+    if (/（\d+）$/.test(t)) b.textContent = t.replace(/（\d+）$/, "（" + ent.sel.size + "）");
+    b.disabled = ent.sel.size === 0;
+  }
+  for (const c of box.querySelectorAll(".pb-chip")) {
+    const inp = c.querySelector("input");
+    const num = Number((c.textContent || "").trim());
+    if (!inp || !num) continue;
+    const on = ent.sel.has(num);
+    if (inp.checked !== on) inp.checked = on;
+    c.classList.toggle("on", on);
+  }
+}
+
+window.pbSelToggle = function (taskId, platform, no, on) {
+  const key = taskId + ":" + platform;
+  const ent = (S.pbSel || {})[key];
+  if (!ent) return;
+  if (on) ent.sel.add(Number(no)); else ent.sel.delete(Number(no));
+  pbSelCountSync(key);       // 先就地同步，再触发整块重绘
+  S._pbSig = ""; pbKick();
+};
+
+window.pbSelAll = function (taskId, platform, all) {
+  const key = taskId + ":" + platform;
+  const ent = (S.pbSel || {})[key];
+  if (!ent) return;
+  if (all) for (const n of ent.sig.split(",")) ent.sel.add(Number(n));
+  else ent.sel.clear();
+  pbSelCountSync(key);
+  S._pbSig = ""; pbKick();
+};
+
+window.pbPublishSelected = async function (taskId, platform, autoSubmit) {
+  const key = taskId + ":" + platform;
+  const ent = (S.pbSel || {})[key];
+  const chapters = ent ? [...ent.sel].sort((a, b) => a - b) : [];
+  if (!chapters.length) return;
+  const msg = autoSubmit
+    ? t("将对所选 {0} 章（第 {1} 章—第 {2} 章）逐章自动填稿并提交发布，无需人工确认；护栏（每日上限/连续失败暂停）生效。确定直发？")
+    : t("将按章号顺序逐章填所选 {0} 章（第 {1} 章—第 {2} 章）。人工模式每轮填一章并停在表单页，由你在浏览器里确认提交。分卷会按卷计划自动选/建。继续？");
+  if (!(await uiConfirm(t(msg, chapters.length, chapters[0], chapters[chapters.length - 1]),
+    { ok: autoSubmit ? t("开始直发") : t("开始发布") }))) return;
+  try {
+    const r = await pbApiWithQualityOverride(
+      "/api/publish/task/" + encodeURIComponent(taskId) + "/publish-all",
+      { platform, chapters, auto_submit: !!autoSubmit },
+      "批量发布前的质量门禁未通过", taskId);
+    if (!(r && r.gate_reviewed))
+      toast(autoSubmit ? t("直发已启动，进度见发布台")
+                       : t("正在填第一章稿——填好后请在浏览器窗口里确认提交，再重新校准"));
+  } catch (e) { toast(t("自动发布失败：") + e.message, true); }
+  S._pbSig = ""; pbKick();
+};
+
+window.pbPublishAll = async function (taskId, platform) {  const au = (((S.pubAuto && S.pubAuto.books) || [])
     .find((b) => b.platform === platform)) || {};
   if (!au.pending) return;
   if (!(await uiConfirm(t("将从最靠前的待发章节开始填稿（共 {0} 章待发）。本轮只填一章并停在表单页，由你在浏览器里确认提交；提交后点击“我已在平台提交”，再选择下一章。护栏（每日上限/连续失败暂停）生效。继续？", au.pending),
@@ -8228,12 +8505,200 @@ function hiveThinkLine(lines) {
   return "";
 }
 
+/* —— 3D 场景（WebGL 蜂巢塔）控制层：引擎在 hive3d.js，这里只管模式切换/
+ * localStorage 持久化/WebGL 不可用降级，以及把 renderHive 的泳道数据翻译给场景。 —— */
+let hiveScene = null;          // Hive3D 场景实例（懒创建）
+let hiveSceneDead = false;     // WebGL 不可用/上下文丢失——本次页面周期内不再尝试
+let hiveMode = "3d";           // 当前视图模式（orch.hiveView）
+let hiveRunId = "";            // 最近一次 renderHive 的 run.id（尾巴/思考缓存键前缀）
+const hiveLiveMeta = {};       // rel -> { started_at }（3D 芯片秒表用）
+let hiveDialogPoll = null;
+let hiveDialogKey = "";
+
+function setHiveSceneButtons(is3d) {
+  document.querySelectorAll("[data-hive-view]").forEach((button) => {
+    const active = button.dataset.hiveView === (is3d ? "3d" : "2d");
+    button.classList.toggle("active", active);
+    button.setAttribute("aria-pressed", active ? "true" : "false");
+  });
+}
+
+function ensureHiveScene() {
+  if (hiveScene || hiveSceneDead) return hiveScene;
+  const canvas = $("rd-hive-gl"), overlay = $("rd-hive-overlay");
+  if (!canvas || !overlay || !window.Hive3D) { hiveSceneDead = true; return null; }
+  hiveScene = window.Hive3D.create({
+    canvas, overlay,
+    onCellActivate(rid, rel, cell) { openHiveMonitorLog(rid, rel, cell); },
+    /* 悬停气泡与运行中芯片的实时内容：尾巴/思考来自 hiveTick 的缓存，秒表现算 */
+    cellRefresh(rel) {
+      const key = hiveRunId + "|" + rel;
+      const meta = hiveLiveMeta[rel] || {};
+      return {
+        tail: hiveTails[key] || "",
+        think: hiveThink[key] || "",
+        elapsed: meta.started_at ? hiveElapsed(meta.started_at) : "",
+      };
+    },
+    onFatal() {   // 上下文丢失等不可恢复故障：退回 2D 并禁用 3D 入口
+      hiveSceneDead = true;
+      hiveScene = null;
+      setHiveSceneMode("2d", { silent: true });
+      toast(t("3D 场景不可用，已切换 2D 列表"), true);
+    },
+  });
+  if (!hiveScene) hiveSceneDead = true;
+  return hiveScene;
+}
+
+async function openHiveMonitorLog(runId, rel, cell) {
+  if (!rel) { toast(t("该步骤无日志"), true); return; }
+  const dialog = $("hive-log-dialog"), title = $("hive-log-title"), meta = $("hive-log-meta"), pre = $("hive-log-text"), error = $("hive-log-error");
+  if (!dialog || !title || !meta || !pre) { hiveOpenLog(runId, rel); return; }
+  if (hiveDialogPoll) { clearInterval(hiveDialogPoll); hiveDialogPoll = null; }
+  hiveDialogKey = runId + "|" + rel;
+  title.textContent = cell && cell.role ? t(cell.role) : rdLogStepLabel(runId, rel);
+  const status = cell && cell.status ? t({ running: "运行中", done: "完成", queued: "排队中", failed: "失败", timeout: "超时", cancelled: "已取消" }[cell.status] || cell.status) : "";
+  meta.textContent = [status, cell && cell.displayAgent, cell && (cell.displayElapsed || cell.started_at)].filter(Boolean).join(" · ");
+  pre.textContent = t("加载日志中…");
+  if (error) error.textContent = "";
+  if (typeof dialog.showModal === "function") dialog.showModal(); else dialog.setAttribute("open", "");
+  const load = async () => {
+    try {
+      const r = await api("/api/runs/" + encodeURIComponent(runId) + "/log?step=" + encodeURIComponent(rel) + "&pretty=1");
+      if (hiveDialogKey !== runId + "|" + rel) return;
+      pre.textContent = r.log || (r.step_status === "running" ? t("（等待输出…）") : t("（无输出）"));
+      pre.scrollTop = pre.scrollHeight;
+      if (r.step_status !== "running" && hiveDialogPoll) { clearInterval(hiveDialogPoll); hiveDialogPoll = null; }
+    } catch (e) {
+      if (error) error.textContent = t("日志读取失败：") + (e && e.message ? e.message : "");
+    }
+  };
+  await load();
+  if (cell && cell.status === "running") hiveDialogPoll = setInterval(load, 2500);
+}
+
+function closeHiveMonitorLog() {
+  hiveDialogKey = "";
+  if (hiveDialogPoll) { clearInterval(hiveDialogPoll); hiveDialogPoll = null; }
+  const dialog = $("hive-log-dialog");
+  if (dialog && dialog.open) dialog.close();
+}
+
+function setHiveSceneMode(mode, opts) {
+  const viewport = $("rd-hive-viewport");
+  if (!viewport) return;
+  let is3d = mode !== "2d";
+  if (is3d) {
+    const sc = ensureHiveScene();
+    if (!sc) {
+      is3d = false;
+      if (!(opts && opts.silent)) toast(t("当前环境不支持 WebGL，已切换 2D 列表"), true);
+    }
+  }
+  hiveMode = is3d ? "3d" : "2d";
+  if (hiveScene) hiveScene.setActive(is3d);
+  viewport.classList.toggle("hive-mode-3d", is3d);
+  viewport.classList.toggle("hive-mode-2d", !is3d);
+  const tools = document.querySelector(".hive-scene-tools");
+  if (tools) tools.classList.toggle("hive-2d", !is3d);
+  setHiveSceneButtons(is3d);
+  try { localStorage.setItem("orch.hiveView", hiveMode); } catch (e) { /* 隐私模式等 */ }
+}
+
+function setupHiveSceneControls() {
+  const viewport = $("rd-hive-viewport");
+  if (!viewport || viewport.dataset.controlsReady) return;
+  viewport.dataset.controlsReady = "true";
+  const hiveDialog = $("hive-log-dialog");
+  const hiveClose = $("hive-log-close");
+  if (hiveClose) hiveClose.addEventListener("click", closeHiveMonitorLog);
+  if (hiveDialog) hiveDialog.addEventListener("close", () => {
+    hiveDialogKey = "";
+    if (hiveDialogPoll) { clearInterval(hiveDialogPoll); hiveDialogPoll = null; }
+  });
+  document.querySelectorAll("[data-hive-view]").forEach((button) => {
+    button.addEventListener("click", () => setHiveSceneMode(button.dataset.hiveView));
+  });
+  document.querySelectorAll("[data-hive-scene-action]").forEach((button) => {
+    button.addEventListener("click", () => {
+      if (hiveMode !== "3d" || !hiveScene) return;
+      if (button.dataset.hiveSceneAction === "reset") hiveScene.resetView();
+      else hiveScene.zoomAt(button.dataset.hiveSceneAction === "zoom-in" ? 1 / 1.18 : 1.18);
+    });
+  });
+  let saved = "3d";
+  try { saved = localStorage.getItem("orch.hiveView") || "3d"; } catch (e) { /* ignore */ }
+  setHiveSceneMode(saved === "2d" ? "2d" : "3d", { silent: true });
+}
+
+/* renderHive → 场景数据翻译：泳道=蜂巢塔的一层，格子按状态映射高度/颜色。
+ * 气泡卡 HTML 在这里用 esc() 拼好（场景端 innerHTML 直用，自己不转义）；
+ * 运行中格子的尾巴/思考行留空，由场景每 2Hz 经 cellRefresh 回填。 */
+function hiveSceneSync(run, lanes, byStage) {
+  hiveRunId = run.id;
+  for (const k of Object.keys(hiveLiveMeta)) delete hiveLiveMeta[k];
+  const model = { runId: run.id, lanes: [] };
+  lanes.forEach((stage, i) => {
+    const list = byStage[stage];
+    const hasRun = list.some((s) => s.status === "running");
+    const settled = list.filter((s) => !["running", "queued"].includes(s.status)).length;
+    model.lanes.push({
+      name: stage, count: list.length, settled, active: hasRun,
+      /* 工位悬停气泡（阶段级）：进度 + 最近落定步骤 */
+      tip:
+        '<b class="hg-tip-role">' + esc(stage) + "</b>" +
+        '<i class="hg-tip-who">' + esc(settled + " / " + list.length) +
+        (hasRun ? " · " + esc(t("进行中")) : "") + "</i>" +
+        '<p class="hg-tip-tail">' +
+        esc(list.filter((s) => !["running", "queued"].includes(s.status)).slice(-1).map((s) => s.role || "").join("")) +
+        "</p>" +
+        '<u class="hg-tip-meta">' + esc(t("点击工位看该阶段最新日志")) + "</u>",
+      cells: list.slice(-8).map((s) => {
+        const st = s.status === "queued" ? "queued"
+          : s.status === "running" ? "running"
+          : s.status === "failed" ? "failed"
+          : s.status === "cancelled" ? "cancelled"
+          : s.status === "timeout" ? "timeout" : "done";
+        const who = s.agent_label || s.agent || "";
+        const mdl = String(s.model || "").trim();
+        const whoShow = who + (mdl ? " · " + mdl : "");
+        const rel = s.log || "";
+        if (st === "running") hiveLiveMeta[rel] = { started_at: s.started_at || "" };
+        const concl = String(s.summary || "").replace(/\s+/g, " ").trim();
+        const elapsed = s.duration_s != null ? s.duration_s + "s" : hiveElapsed(s.started_at);
+        const stWord = { running: t("运行中"), done: t("完成"), failed: t("失败"),
+          timeout: t("超时"), cancelled: t("已取消"), queued: t("排队中") }[st] || s.status;
+        const metaBits = [stWord, elapsed, rel ? t("点击格子看日志") : ""].filter(Boolean).join(" · ");
+        const tip =
+          '<b class="hg-tip-role">' + esc(s.role || "") + "</b>" +
+          (whoShow ? '<i class="hg-tip-who">' + esc(whoShow) + "</i>" : "") +
+          '<p class="hg-tip-tail">' + (st === "running" ? "" : esc(concl)) + "</p>" +
+          '<em class="hg-tip-think"></em>' +
+          '<u class="hg-tip-meta">' + esc(metaBits) + "</u>";
+        return {
+          rel, role: s.role || "", status: st, tip,
+          displayTail: st === "running" ? "" : concl,
+          displayStatus: stWord,
+          displayElapsed: elapsed,
+          displayAgent: whoShow,
+        };
+      }),
+    });
+  });
+  const sc = ensureHiveScene();
+  if (!sc) return;
+  sc.sync(model);                    // 2D 模式也同步：切回 3D 时数据即 ready（画布未激活零 GPU 开销）
+  sc.setActive(hiveMode === "3d");
+}
+
 window.renderHive = function (run) {
   const box = $("rd-hive");
   if (!box) return;
   const steps = (run && run.steps) || [];
-  if (!run || !steps.length) { box.classList.add("hidden"); stopHiveTick(); return; }
+  if (!run || !steps.length) { box.classList.add("hidden"); stopHiveTick(); if (hiveScene) hiveScene.setActive(false); return; }
   box.classList.remove("hidden");
+  setupHiveSceneControls();
   // 按步骤首次出现顺序分泳道（流水线天然有序）
   const lanes = [], byStage = {};
   steps.forEach((s) => {
@@ -8359,6 +8824,7 @@ window.renderHive = function (run) {
     if (cellsBox._hiveEnterT) clearTimeout(cellsBox._hiveEnterT);
     cellsBox._hiveEnterT = setTimeout(() => cellsBox.classList.remove("hive-enter"), 1400);
   }
+  hiveSceneSync(run, lanes, byStage);   // WebGL 蜂巢塔吃同一份泳道数据（内部自管激活）
   const live = running.length && (run.status === "running" || run.status === "queued");
   if (hiveClock) { clearInterval(hiveClock); hiveClock = null; }
   if (live) {
@@ -8444,6 +8910,7 @@ async function resumeNow() {
   } catch (e) { toast(t("操作失败：") + (e && e.message ? e.message : t("网络异常")), true); return; }
   if (r && r.ok) {
     toast(t("已跳过等待，马上继续"));
+    chatJumpLatest();   // 续跑副本接着跑：新步骤落时间线尾部，跳过去看最新
     refreshState();   // 后端 bump 也会推 SSE，这里主动刷一轮让按钮立刻消失
   } else {
     toast((r && r.error) || t("操作失败"), true);
@@ -8720,7 +9187,28 @@ let chatSig = "";
 let chatLiveSig = "";        // 时间线实时增量签名（思考/正文长度变才重建 DOM）
 let chatLiveTimer = null;    // 运行中快轮询句柄（1.2s，见 scheduleChatLive）
 let chatLiveRunId = null;
-let chatForceBottom = false; // 发送消息后强制贴底一次（不管当时滚到哪，都要看到自己刚发的内容与回复）
+let chatForceBottom = false; // 强制贴底一次（不管当时滚到哪，都要看到最新内容）；发送消息、继续任务、打开详情共用
+
+/* 瞬时落底：.rd-chat-flow 带 scroll-behavior:smooth，直接赋值 scrollTop 会变
+ * 成跨全时间的平滑滚动动画（长对话要滑近一秒，测试也会量到半途）——跳最新
+ * 这类大跨度移动一律压成瞬时。 */
+function chatScrollBottomNow(fl) {
+  if (!fl) return;
+  const prev = fl.style.scrollBehavior;
+  fl.style.scrollBehavior = "auto";
+  fl.scrollTop = fl.scrollHeight;
+  fl.style.scrollBehavior = prev;
+}
+
+/* 让对话时间线跳到最新：置强制贴底标记（drawChatFlow 下一次重建时消费），
+ * 并就现有内容先即时贴底，视觉零等待。「继续任务/立即续跑/继续连载」点完
+ * 新一轮内容落在时间线尾部，用户要看到的是最新进展，不是停在原地或历史中间；
+ * 首次打开详情同理。页签当前不可见时标记保留（drawChatFlow 不消费），
+ * 切进对话页签时由 applyRdTabs 带到底。 */
+function chatJumpLatest() {
+  chatForceBottom = true;
+  chatScrollBottomNow($("rd-chat-flow"));
+}
 
 function chatEngineIsDirect(run) {
   const st = S.state || {};
@@ -8870,6 +9358,7 @@ function drawChatFlow(run, data, active) {
     ":" + (it.consumed ? 1 : 0), "") + "|" + ((data && data.result) ? "r" : "");
   if (liveSig === chatLiveSig && flow.childElementCount) return;
   chatLiveSig = liveSig;
+  flow.dataset.runId = run.id;   // run 戳：applyRdTabs 判「内容是否已对齐当前对话」用
   // 时间显示统一收敛到 HH:MM（日期在 meta 条里，全量戳塞气泡就是噪音）；
   // 附件兼容 字符串路径 / {name|path} 对象 两种形态（对象直接拼会成 [object Object]）
   const chatTime = (v) => { const s = String(v || "");
@@ -8961,10 +9450,13 @@ function drawChatFlow(run, data, active) {
     ? t("运行中：新消息会排队，本轮回答完后依次送达")
     : t("已结束：发送后将自动开新一轮接着做");
   // 贴底跟随：用户滚到底部附近才自动滚到最新输出，回看历史不打扰；
-  // 刚发送过消息则强制贴底一次（用户要看到自己发的消息与正在来的回复）
-  const stick = chatForceBottom ||
+  // 带强制贴底标记（发送/继续任务/首开详情置的）则无条件跳最新。
+  // 页签当前不可见（display:none 时 scrollHeight 恒 0）贴底无处落：
+  // 标记保留给 applyRdTabs，切进对话页签那一刻再带到底。
+  const flowVisible = flow.offsetParent !== null;
+  const stick = (chatForceBottom && flowVisible) ||
     flow.scrollHeight - flow.scrollTop - flow.clientHeight < 80;
-  chatForceBottom = false;
+  if (chatForceBottom && flowVisible) chatForceBottom = false;
   // 思考过程面板（.ct-body 自带滚动条）逐帧整体重建会丢滚动位置——重绘前
   // 记住「贴底 or 用户上滑到哪」，重绘后恢复：贴底则一直跟最新（2026-09-22
   // 用户诉求），上滑回看历史思维链则保持位置不被打扰。
@@ -8974,7 +9466,7 @@ function drawChatFlow(run, data, active) {
     : true;
   const thinkTop = prevThink ? prevThink.scrollTop : 0;
   flow.innerHTML = html || '<div class="hint">' + esc(t("还没有对话内容")) + "</div>";
-  if (stick) flow.scrollTop = flow.scrollHeight;
+  if (stick) chatScrollBottomNow(flow);
   const newThink = flow.querySelector('[data-think-live="1"] .ct-body');
   if (newThink) {
     if (thinkPin) newThink.scrollTop = newThink.scrollHeight;
@@ -9532,9 +10024,7 @@ window.chatSend = async function () {
     ta.style.height = "";
     chatAtts = []; drawChatAtts();
     chatSig = "";   // 强制重画时间线
-    chatForceBottom = true;   // 发完滚到最新：看到自己刚发的消息与正在来的回复
-    const fl = $("rd-chat-flow");
-    if (fl) fl.scrollTop = fl.scrollHeight;   // 重画前先即时贴底，视觉零跳动
+    chatJumpLatest();   // 发完滚到最新：看到自己刚发的消息与正在来的回复
     if (active) {
       const d = await api("/api/runs/" + encodeURIComponent(chatRunId));
       if (d.run) renderChat(d.run, d.run.status === "running" || d.run.status === "queued");
@@ -9549,6 +10039,7 @@ function bindChat() {
   if (!btn || !file || !send || !ta) return;
   const focusBtn = $("rd-chat-focus");
   if (focusBtn) focusBtn.addEventListener("click", () => {
+    chatJumpLatest();   // 继续对话：先看到最新一轮再开口
     S.rdTab = "chat";
     S.rdTabPin = true;
     applyRdTabs();
@@ -9697,6 +10188,7 @@ const SKINS = [
   { id: "ocean", name: "深海", desc: "藏青底色 + 天蓝强调，夜间长时间盯任务更沉静（默认）" },
   { id: "hermes", name: "墨金", desc: "暖墨底色 + 金色发丝线，Hermes 式古典优雅" },
   { id: "classic", name: "经典", desc: "黑白灰 + 蓝色强调，ChatGPT 式清爽配色" },
+  { id: "paper", name: "简白", desc: "纯白画布 + 浅灰分区 + 克制蓝强调，Codex 式极简明亮" },
   { id: "forest", name: "森野", desc: "墨绿底色 + 青翠强调，偏自然的护眼配色" },
   { id: "amber", name: "暖阳", desc: "暖棕底色 + 琥珀强调，纸感暖调" },
   { id: "violet", name: "霓虹", desc: "暗紫底色 + 品红强调，霓虹感强" },
@@ -13090,10 +13582,25 @@ async function loadEvalBench() {
   const ae = $("eb-auto-enabled"), ad = $("eb-auto-days");
   if (ae && S.settings) ae.checked = S.settings.bench_auto_enabled === true;
   if (ad && S.settings) ad.value = S.settings.bench_auto_days || 7;
+  const fbe = $("eb-feedback-enabled");
+  if (fbe && S.settings) fbe.checked = S.settings.bench_feedback_enabled !== false;
   renderEvalBench();
   if (S.evalbench && S.evalbench.running) EB_TIMER = setInterval(pollEvalBench, 2500);
 }
 
+async function saveBenchFeedback() {
+  const msg = $("eb-feedback-msg");
+  try {
+    const r = await api("/api/settings", { method: "POST", body: JSON.stringify({
+      bench_feedback_enabled: !$("eb-feedback-enabled") || $("eb-feedback-enabled").checked }) });
+    S.settings = r.settings;
+    if (msg) { msg.textContent = t("已保存"); }
+    pollEvalBench();
+  } catch (e) {
+    if (msg) { msg.textContent = e.message; }
+  }
+}
+
 async function saveBenchAuto() {
   const msg = $("eb-auto-msg");
   try {
@@ -13161,7 +13668,8 @@ function renderEvalBench() {
     : t("裁判未就绪：先在「编排设置」配置编排者供应商");
   const pr = eb.progress;
   $("eb-progress").textContent = eb.running && pr
-    ? t("评测中 ") + (pr.done || 0) + "/" + (pr.total || 0) + (pr.current ? t("　·　") + pr.current : "")
+    ? t("评测中 ") + (pr.done || 0) + "/" + (pr.total || 0) + (pr.current ? t("　·　") + pr.current : "") +
+      (pr.cancel ? t("　·　停止中…当前样题完成后即停") : "")
     : "";
   board.innerHTML = (eb.leaderboard || []).map((r) => {
     const dims = Object.keys(r.scores || {}).length
@@ -13194,6 +13702,26 @@ function renderEvalBench() {
   }
   const btn = $("eb-run-btn");
   if (btn) btn.disabled = !!eb.running;
+  const stopBtn = $("eb-stop-btn");
+  if (stopBtn) {
+    const stopping = !!(eb.running && eb.progress && eb.progress.cancel);
+    stopBtn.textContent = stopping ? t("强制停止") : t("停止");
+    stopBtn.disabled = !eb.running;          // 空闲置灰：第二次点击=强制脱离的入口只在停止中开放
+  }
+  const fbBox = $("eb-feedback-status");
+  if (fbBox) {
+    const fb = eb.feedback || {};
+    if (!fb.enabled) {
+      fbBox.textContent = t("反哺已关闭：评测只出榜单，不影响选路。");
+    } else {
+      const sig = Object.values(fb.signals || {});
+      const down = sig.filter((x) => x.below).length;
+      const up = sig.length - down;
+      fbBox.textContent = sig.length
+        ? t("反哺生效：") + up + t(" 个模型加权 · ") + down + t(" 个降权（据 14 天内实测分）")
+        : t("反哺生效中：暂无 14 天内实测分，跑一轮评测后开始影响排序。");
+    }
+  }
 }
 
 /* 逐题对比：行=样题，列=候选模型（按榜单名次），格=最新一次得分 */
@@ -13241,7 +13769,21 @@ async function evalbenchRun() {
 }
 
 async function evalbenchCancel() {
-  try { await api("/api/evalbench/cancel", { method: "POST" }); } catch (e) { /* 空闲时 200 ok=false */ }
+  // 两段式：第一击优雅停（等当前样题做完——生成调用最坏要等几分钟）；
+  // 服务端已打停止标记后再点=强制脱离（立即回到空闲，后台线程自行收尾）。
+  const msg = $("eb-msg");
+  const already = !!(S.evalbench && S.evalbench.progress && S.evalbench.progress.cancel);
+  try {
+    const r = await api("/api/evalbench/cancel",
+                        { method: "POST", body: JSON.stringify({ force: already }) });
+    if (r && r.ok && r.force) {
+      if (msg) { msg.className = "msg ok"; msg.textContent = t("已强制脱离：界面回到空闲，后台当前调用跑完即自行退出"); }
+    } else if (r && r.ok) {
+      if (msg) { msg.className = "msg"; msg.textContent = t("已请求停止：当前样题完成后即停（生成调用最长可能等几分钟）；等不及再点一次「强制停止」"); }
+    }
+  } catch (e) {
+    if (msg) { msg.className = "msg err"; msg.textContent = e.message; }
+  }
   pollEvalBench();
 }