codebee 0.1.95 → 0.1.96

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;
@@ -5101,6 +5119,7 @@ window.cancelAllRuns = cancelAllRuns;
 
 async function openRun(id, pinTab) {
   _taskStepRenderToken++;
+  chatJumpLatest();   // 首开运行详情：对话时间线落最新（历史长时别停在顶部）
   S.detailRunId = id;
   S.detailTaskKey = null;
   S.runDetailSig = "";   // 新目标首帧必画；也兜住「任务态改过 DOM 后回到本运行」的串台
@@ -5185,6 +5204,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 +5232,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();
 }
 
@@ -5980,6 +6014,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>";
@@ -6011,6 +6046,41 @@ function pbBlock(task, platform) {
         ' onclick="pbPublishAll(\'' + esc(task.id) + "', '" + platform + '\')">' +
         t("发布全部待发") + t("（") + au.pending + t("）") + "</button>";
     }
+    // 批量选择：待发章号 chips（默认全选），「发布所选」人工模式 / 「直发所选」
+    // 逐章自动提交（护栏每日上限/连败退避照常生效）。分卷由服务端按卷计划
+    // 自动选/建（volumes.py），界面上不用管卷。
+    const items = (au.items && au.items.length ? au.items : [])
+      .map((x) => Number(x.chapter_no)).filter((n) => n > 0);
+    if (items.length && !run) {
+      const key = task.id + ":" + platform;
+      const sig = items.join(",");
+      S.pbSel = S.pbSel || {};
+      if (!S.pbSel[key] || S.pbSel[key].sig !== sig)
+        S.pbSel[key] = { sig, sel: new Set(items) };
+      const sel = S.pbSel[key].sel;
+      let chips = "";
+      for (const n of items)
+        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("待发 ")) + items.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 || !au.guard_ok || !sel.size ? "disabled" : "") +
+        ' onclick="pbPublishSelected(\'' + esc(task.id) + "','" + platform + '\',false)">' +
+        t("发布所选") + t("（") + sel.size + t("）") + "</button>" +
+        '<button class="ghost" ' + (busy || !au.guard_ok || !sel.size ? "disabled" : "") +
+        ' title="' + esc(t("所选章节逐章自动提交（无人值守），护栏每日上限/连败退避照常生效")) + '"' +
+        ' 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 +6110,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 +6358,46 @@ window.pbConfirmChapter = async function (taskId, platform, chapterNo) {
   S._pbSig = ""; pbKick();
 };
 
-window.pbPublishAll = async function (taskId, platform) {
-  const au = (((S.pubAuto && S.pubAuto.books) || [])
+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));
+  S._pbSig = ""; pbKick();   // 重画刷新按钮计数（勾选态存 S.pbSel 不丢）
+};
+
+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();
+  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 +8337,95 @@ function hiveThinkLine(lines) {
   return "";
 }
 
+const hiveSceneTransform = { x: 0, y: 0, zoom: 1 };
+
+function updateHiveSceneTransform() {
+  const scene = $("rd-hive-cells");
+  if (!scene) return;
+  scene.style.setProperty("--scene-x", hiveSceneTransform.x + "px");
+  scene.style.setProperty("--scene-y", hiveSceneTransform.y + "px");
+  scene.style.setProperty("--scene-zoom", String(hiveSceneTransform.zoom));
+}
+
+function setHiveSceneMode(mode) {
+  const scene = $("rd-hive-cells");
+  const viewport = $("rd-hive-viewport");
+  const tools = document.querySelector(".hive-scene-tools");
+  if (!scene || !viewport) return;
+  const is3d = mode !== "2d";
+  scene.classList.toggle("hive-3d", is3d);
+  scene.classList.toggle("hive-2d", !is3d);
+  viewport.classList.toggle("hive-2d", !is3d);
+  if (tools) tools.classList.toggle("hive-2d", !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 setupHiveSceneControls() {
+  const viewport = $("rd-hive-viewport");
+  const scene = $("rd-hive-cells");
+  if (!viewport || !scene || viewport.dataset.controlsReady) return;
+  viewport.dataset.controlsReady = "true";
+  updateHiveSceneTransform();
+
+  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 (button.dataset.hiveSceneAction === "reset") {
+        hiveSceneTransform.x = 0;
+        hiveSceneTransform.y = 0;
+        hiveSceneTransform.zoom = 1;
+      } else {
+        hiveSceneTransform.zoom = Math.max(.65, Math.min(1.55,
+          hiveSceneTransform.zoom + (button.dataset.hiveSceneAction === "zoom-in" ? .1 : -.1)));
+      }
+      updateHiveSceneTransform();
+    });
+  });
+
+  let drag = null;
+  viewport.addEventListener("pointerdown", (event) => {
+    if (event.button !== 0 || event.target.closest(".hive-cell, button, a, input, textarea")) return;
+    drag = { id: event.pointerId, x: event.clientX, y: event.clientY,
+      originX: hiveSceneTransform.x, originY: hiveSceneTransform.y };
+    viewport.classList.add("is-dragging");
+    viewport.setPointerCapture(event.pointerId);
+  });
+  viewport.addEventListener("pointermove", (event) => {
+    if (!drag || drag.id !== event.pointerId) return;
+    hiveSceneTransform.x = drag.originX + event.clientX - drag.x;
+    hiveSceneTransform.y = drag.originY + event.clientY - drag.y;
+    updateHiveSceneTransform();
+  });
+  const endDrag = (event) => {
+    if (!drag || (event && drag.id !== event.pointerId)) return;
+    drag = null;
+    viewport.classList.remove("is-dragging");
+  };
+  viewport.addEventListener("pointerup", endDrag);
+  viewport.addEventListener("pointercancel", endDrag);
+  viewport.addEventListener("lostpointercapture", endDrag);
+  viewport.addEventListener("wheel", (event) => {
+    if (!scene.classList.contains("hive-3d")) return;
+    event.preventDefault();
+    hiveSceneTransform.zoom = Math.max(.65, Math.min(1.55,
+      hiveSceneTransform.zoom * (event.deltaY < 0 ? 1.08 : .92)));
+    updateHiveSceneTransform();
+  }, { passive: false });
+}
+
 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; }
   box.classList.remove("hidden");
+  setupHiveSceneControls();
   // 按步骤首次出现顺序分泳道（流水线天然有序）
   const lanes = [], byStage = {};
   steps.forEach((s) => {
@@ -8444,6 +8636,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 +8913,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 +9084,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 +9176,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 +9192,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 +9750,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 +9765,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 +9914,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 +13308,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 +13394,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 +13428,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 +13495,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();
 }
 

package/app/ui/artdiff.js

@@ -1,74 +1,74 @@
-/* 成品两版对比的纯 diff 计算（OpenCreator「版本化对比」借鉴）。
- * 独立文件无 DOM 依赖：app.js 用 window.ArtifactDiff 渲染，tests 用
- * module.exports 直测。算法：公共前后缀修剪 + 中段 LCS（上限保护，
- * 超限诚实降级为整块替换计数，不装作对齐了）。 */
-(function (root, factory) {
-  var api = factory();
-  if (typeof window !== "undefined") window.ArtifactDiff = api;
-  if (typeof module !== "undefined" && module.exports) module.exports = api;
-})(typeof self !== "undefined" ? self : this, function () {
-  "use strict";
-
-  var MID_CAP = 400;          // 中段行数单边上限
-  var MID_PRODUCT_CAP = 160000; // LCS DP 格子上限（400×400）
-
-  /* LCS 回溯产出统一 diff 行：[{t:"="|"-"/"+", s:行文本}]（只对中段）。 */
-  function lcsRows(A, B) {
-    var n = A.length, m = B.length;
-    var dp = [];
-    for (var k = 0; k <= n; k++) dp.push(new Uint32Array(m + 1));
-    for (var i = n - 1; i >= 0; i--)
-      for (var j = m - 1; j >= 0; j--)
-        dp[i][j] = A[i] === B[j] ? dp[i + 1][j + 1] + 1
-          : (dp[i + 1][j] >= dp[i][j + 1] ? dp[i + 1][j] : dp[i][j + 1]);
-    var rows = [];
-    i = 0; j = 0;
-    while (i < n && j < m) {
-      if (A[i] === B[j]) { rows.push({ t: "=", s: A[i] }); i++; j++; }
-      else if (dp[i + 1][j] >= dp[i][j + 1]) { rows.push({ t: "-", s: A[i] }); i++; }
-      else { rows.push({ t: "+", s: B[j] }); j++; }
-    }
-    while (i < n) { rows.push({ t: "-", s: A[i] }); i++; }
-    while (j < m) { rows.push({ t: "+", s: B[j] }); j++; }
-    return rows;
-  }
-
-  /* 对外主口：旧版 a、新版 b → {
-   *   prefix/suffix: 相同行数（渲染端折叠展示），
-   *   identical: 布尔，两版一致，
-   *   rows: 中段统一 diff 行（超限时为 null），
-   *   oversized: {a, b} 超限时中段行数（诚实整块计数） } */
-  function diff(a, b) {
-    a = String(a == null ? "" : a);
-    b = String(b == null ? "" : b);
-    var A = a.split("\n"), B = b.split("\n");
-    var p = 0;
-    while (p < A.length && p < B.length && A[p] === B[p]) p++;
-    var s = 0;
-    while (s < A.length - p && s < B.length - p &&
-           A[A.length - 1 - s] === B[B.length - 1 - s]) s++;
-    var midA = A.slice(p, A.length - s), midB = B.slice(p, B.length - s);
-    var out = { prefix: p, suffix: s, identical: !midA.length && !midB.length,
-                rows: null, oversized: null };
-    if (out.identical) return out;
-    if (midA.length > MID_CAP || midB.length > MID_CAP ||
-        midA.length * midB.length > MID_PRODUCT_CAP) {
-      out.oversized = { a: midA.length, b: midB.length };
-      return out;
-    }
-    out.rows = lcsRows(midA, midB);
-    return out;
-  }
-
-  /* rows → 摘要计数（+x/-y，渲染端徽章用）。 */
-  function counts(d) {
-    var add = 0, del = 0;
-    if (d.oversized) return { add: d.oversized.b, del: d.oversized.a };
-    (d.rows || []).forEach(function (r) {
-      if (r.t === "+") add++; else if (r.t === "-") del++;
-    });
-    return { add: add, del: del };
-  }
-
-  return { diff: diff, counts: counts, lcsRows: lcsRows };
-});
+/* 成品两版对比的纯 diff 计算（OpenCreator「版本化对比」借鉴）。
+ * 独立文件无 DOM 依赖：app.js 用 window.ArtifactDiff 渲染，tests 用
+ * module.exports 直测。算法：公共前后缀修剪 + 中段 LCS（上限保护，
+ * 超限诚实降级为整块替换计数，不装作对齐了）。 */
+(function (root, factory) {
+  var api = factory();
+  if (typeof window !== "undefined") window.ArtifactDiff = api;
+  if (typeof module !== "undefined" && module.exports) module.exports = api;
+})(typeof self !== "undefined" ? self : this, function () {
+  "use strict";
+
+  var MID_CAP = 400;          // 中段行数单边上限
+  var MID_PRODUCT_CAP = 160000; // LCS DP 格子上限（400×400）
+
+  /* LCS 回溯产出统一 diff 行：[{t:"="|"-"/"+", s:行文本}]（只对中段）。 */
+  function lcsRows(A, B) {
+    var n = A.length, m = B.length;
+    var dp = [];
+    for (var k = 0; k <= n; k++) dp.push(new Uint32Array(m + 1));
+    for (var i = n - 1; i >= 0; i--)
+      for (var j = m - 1; j >= 0; j--)
+        dp[i][j] = A[i] === B[j] ? dp[i + 1][j + 1] + 1
+          : (dp[i + 1][j] >= dp[i][j + 1] ? dp[i + 1][j] : dp[i][j + 1]);
+    var rows = [];
+    i = 0; j = 0;
+    while (i < n && j < m) {
+      if (A[i] === B[j]) { rows.push({ t: "=", s: A[i] }); i++; j++; }
+      else if (dp[i + 1][j] >= dp[i][j + 1]) { rows.push({ t: "-", s: A[i] }); i++; }
+      else { rows.push({ t: "+", s: B[j] }); j++; }
+    }
+    while (i < n) { rows.push({ t: "-", s: A[i] }); i++; }
+    while (j < m) { rows.push({ t: "+", s: B[j] }); j++; }
+    return rows;
+  }
+
+  /* 对外主口：旧版 a、新版 b → {
+   *   prefix/suffix: 相同行数（渲染端折叠展示），
+   *   identical: 布尔，两版一致，
+   *   rows: 中段统一 diff 行（超限时为 null），
+   *   oversized: {a, b} 超限时中段行数（诚实整块计数） } */
+  function diff(a, b) {
+    a = String(a == null ? "" : a);
+    b = String(b == null ? "" : b);
+    var A = a.split("\n"), B = b.split("\n");
+    var p = 0;
+    while (p < A.length && p < B.length && A[p] === B[p]) p++;
+    var s = 0;
+    while (s < A.length - p && s < B.length - p &&
+           A[A.length - 1 - s] === B[B.length - 1 - s]) s++;
+    var midA = A.slice(p, A.length - s), midB = B.slice(p, B.length - s);
+    var out = { prefix: p, suffix: s, identical: !midA.length && !midB.length,
+                rows: null, oversized: null };
+    if (out.identical) return out;
+    if (midA.length > MID_CAP || midB.length > MID_CAP ||
+        midA.length * midB.length > MID_PRODUCT_CAP) {
+      out.oversized = { a: midA.length, b: midB.length };
+      return out;
+    }
+    out.rows = lcsRows(midA, midB);
+    return out;
+  }
+
+  /* rows → 摘要计数（+x/-y，渲染端徽章用）。 */
+  function counts(d) {
+    var add = 0, del = 0;
+    if (d.oversized) return { add: d.oversized.b, del: d.oversized.a };
+    (d.rows || []).forEach(function (r) {
+      if (r.t === "+") add++; else if (r.t === "-") del++;
+    });
+    return { add: add, del: del };
+  }
+
+  return { diff: diff, counts: counts, lcsRows: lcsRows };
+});