codebee 0.1.4 → 0.1.6

package/app/ui/app.js

@@ -488,10 +488,12 @@ function fmtModel(m) {
   return typeof m === "object" ? JSON.stringify(m) : String(m);
 }
 
-/* 极简 Markdown 渲染（标题/加粗/行内码/列表/表格/代码块） */
+/* 极简 Markdown 渲染（标题/加粗/行内码/列表/表格/代码块）。
+ * 围栏代码块走 codeBlockHTML（行号表格+高亮+代码主题）：裸 <pre> 只有
+ * --log-bg 底色没配浅字，暖色皮肤里深底配深字根本读不了。 */
 function md2html(md) {
   const lines = String(md || "").split(/\r?\n/);
-  let html = [], inCode = false, inTable = false, listOpen = false;
+  let html = [], inCode = false, codeBuf = null, inTable = false, listOpen = false;
   const inline = (t) => esc(t)
     .replace(/`([^`]+)`/g, "<code>$1</code>")
     .replace(/\*\*([^*]+)\*\*/g, "<b>$1</b>");
@@ -501,10 +503,11 @@ function md2html(md) {
     const line = raw.replace(/\s+$/, "");
     if (line.startsWith("```")) {
       closeList(); closeTable();
-      html.push(inCode ? "</pre>" : "<pre>");
+      if (inCode) { html.push(codeBlockHTML(codeBuf.join("\n"))); codeBuf = null; }
+      else codeBuf = [];
       inCode = !inCode; continue;
     }
-    if (inCode) { html.push(esc(raw)); continue; }
+    if (inCode) { codeBuf.push(raw); continue; }
     if (/^\|(.+)\|\s*$/.test(line)) {
       const cells = line.slice(1, -1).split("|").map((s) => s.trim());
       if (/^[-: ]+$/.test(cells.join(""))) continue; // 分隔行
@@ -524,7 +527,7 @@ function md2html(md) {
     html.push("<p>" + inline(line) + "</p>");
   }
   closeList(); closeTable();
-  if (inCode) html.push("</pre>");
+  if (inCode && codeBuf) html.push(codeBlockHTML(codeBuf.join("\n")));   // 未闭合围栏也按代码块收尾
   return html.join("\n");
 }
 
@@ -564,7 +567,9 @@ function renderHealthBanner(health) {
   el.className = "health-banner alerting";
   el.title = alerts.map((p) =>
     p.provider + (p.model ? " · " + p.model : "") +
-    t("：连续失败 ") + p.consecutive_failures + t(" 次（") + (p.last_error || t("未知错误")) + t("）")
+    (p.static
+      ? t("：") + (p.last_error || t("未知错误"))
+      : t("：连续失败 ") + p.consecutive_failures + t(" 次（") + (p.last_error || t("未知错误")) + t("）"))
   ).join("\n");
   if (!_healthBeeped) { _healthBeeped = true; beepAttention(); }
 }
@@ -572,7 +577,7 @@ function renderHealthBanner(health) {
 function healthBannerText(health) {
   return ((health && health.alerts) || []).map((p) => {
     const m = p.model ? " · " + p.model : "";
-    return "⚠ " + p.provider + m + " " + t("连接异常");
+    return "⚠ " + p.provider + m + " " + (p.static ? t("绑定链失效") : t("连接异常"));
   }).join(t("　"));
 }
 
@@ -581,19 +586,21 @@ function healthBannerClick() {
   if (!alerts.length) return;
   const rows = alerts.map((p) => {
     const model = p.model ? " · " + p.model : "";
-    return "<div style='margin-bottom:10px'>" +
-      "<b>" + esc(p.provider) + (p.model ? " · " + esc(p.model) : "") + "</b>" +
+    const statLine = p.static ? "" :
       "<div style='opacity:.75;font-size:12px;margin-top:2px'>" +
       t("连续失败") + " " + p.consecutive_failures + " " + t("次 · 首次失败 ") + (p.first_fail_at || "-") +
-      "</div>" +
+      "</div>";
+    return "<div style='margin-bottom:10px'>" +
+      "<b>" + esc(p.provider) + (p.model ? " · " + esc(p.model) : "") + "</b>" +
+      statLine +
       "<div style='color:#dc2626;font-size:12px;margin-top:2px;word-break:break-all'>" +
       esc(p.last_error || "") + "</div></div>";
   }).join("");
   const pid0 = alerts[0].provider_id || "";
   const model0 = alerts[0].model || "";
   const foot =
-    (model0 ? "<button class='btn ghost' onclick=\"healthDisableModel('" + esc(pid0) + "','" + esc(model0) + "')\">" + t("禁用该模型") + "</button>" : "") +
-    "<button class='btn ghost' onclick=\"healthDisableProvider('" + esc(pid0) + "')\">" + t("禁用该厂商") + "</button>" +
+    (pid0 && model0 ? "<button class='btn ghost' onclick=\"healthDisableModel('" + esc(pid0) + "','" + esc(model0) + "')\">" + t("禁用该模型") + "</button>" : "") +
+    (pid0 ? "<button class='btn ghost' onclick=\"healthDisableProvider('" + esc(pid0) + "')\">" + t("禁用该厂商") + "</button>" : "") +
     "<button class='btn ghost' onclick=\"healthOp('silence')\">" + t("静默本次告警") + "</button>" +
     "<button class='btn ghost' onclick=\"healthOp('reset')\">" + t("手动标记恢复") + "</button>" +
     "<button class='primary' onclick='closeModal()'>" + t("关闭") + "</button>";
@@ -637,6 +644,7 @@ async function healthDisableModel(pid, model) {
     S.provSig = "";
     closeModal(); render(); loadOrchestrator();
     toast(t("已禁用模型 {0} · {1}，链降级自动跳过；绑定页可重新启用").replace("{0}", pid).replace("{1}", model));
+    autoRebindSoon();
   } catch (e) {
     toast(t("操作失败：") + e.message, true);
   }
@@ -660,6 +668,7 @@ async function healthDisableProvider(pid) {
     S.provSig = "";
     closeModal(); render(); loadOrchestrator();
     toast(t("已禁用厂商 {0}：链降级自动跳过，绑定页可重新启用").replace("{0}", pid));
+    autoRebindSoon();
   } catch (e) {
     toast(t("操作失败：") + e.message, true);
   }
@@ -845,19 +854,19 @@ function renderBindings() {
     }).join("");
     const bound = provs.find((p) => p.id === b.provider_id);
     const offWarn = bound && bound.enabled === false
-      ? '<p class="hint warn">' + t("该供应商已停用：编排时不会注入它，将回落为 CLI 默认配置（模型链也不会生效）。") + '</p>' : "";
+      ? '<p class="hint warn">' + t("该供应商已停用：编排时不会注入它，模型链因此失效时相关步骤会直接判失败。") + '</p>' : "";
     const protoWarn = bound && !bindable.some((p) => p.id === bound.id)
       ? '<p class="hint warn">' + t("该供应商协议为 ") + esc(protoLabel(bound)) +
-        t("，当前没有可注入的 CLI，编排时会回落为 CLI 默认配置。") + '</p>' : "";
-    // 供应商停用但链上勾选了它家模型：链条目在解析时也会被整条跳过，
-    // 链空了照样回落本机默认——这是 2026-09-16 配额事故的隐藏形态，单说
-    // 「供应商下拉」警告不够，链本身的死活也要点名。
+        t("，当前没有可注入的 CLI，编排时相关步骤会直接判失败。") + '</p>' : "";
+    // 供应商停用但链上勾选了它家模型：链条目在解析时也会被整条跳过，链空了
+    // 相关步骤会直接判失败（2026-09-17 起；此前的静默回落本机默认正是 2026-09-16
+    // 配额事故的隐藏形态）——单说「供应商下拉」警告不够，链本身的死活也要点名。
     const chainDead = bindChain(b).some((c2) => c2.p && (() => {
       const pv = provs.find((p) => p.id === c2.p);
       return !pv || pv.enabled === false;
     })());
     const chainWarn = (!bound || bound.enabled !== false) && chainDead
-      ? '<p class="hint warn">' + t("模型链里有已停用/已删除的供应商：这些条目解析时会被跳过，链可能因此整体失效。") + '</p>' : "";
+      ? '<p class="hint warn">' + t("模型链里有已停用/已删除的供应商：这些条目解析时会被跳过，链可能因此整体失效，相关步骤将判失败。") + '</p>' : "";
     return '<div class="card"><div class="head"><span class="name">' + esc(c.name) + "</span>" +
       '<span class="tag">' + esc(c.orch_kind) + "</span></div>" +
       '<div class="field"><label>' + t("供应商") + '</label><select id="bindprov-' + esc(c.id) + '">' + opts + "</select></div>" +
@@ -961,6 +970,7 @@ async function batchProvOp(op) {
   try {
     await api("/api/models/provider-op", { method: "POST",
       body: JSON.stringify({ ids, op }) });
+    if (op !== "duplicate") autoRebindSoon();
   } catch (e) { toast(t("操作失败：") + e.message, true); }
   S.selProvs = {};
   S.modelsSig = null;
@@ -1147,6 +1157,7 @@ async function keyOpCall(pid, op, keyId, key, label) {
   try {
     await api("/api/models/key-op", { method: "POST",
       body: JSON.stringify({ provider_id: pid, op, key_id: keyId, key, label }) });
+    autoRebindSoon();   // 密钥启停/删除/解冻会改变厂商「推荐可用」判定，自动补绑一次
   } catch (e) { toast(t("操作失败：") + e.message, true); }
   // 操作期间轮询照跑（uiPrompt 弹框不阻塞轮询），S.modelsSig 还是旧值：必须
   // 清签名强制重绘，否则 KEY 写盘成功界面也看不到。
@@ -1263,6 +1274,10 @@ function provModelRow(pid, m, group) {
       esc((tm.error || "").slice(0, 24)) + "</span>") : "";
   const price = (m.price_in != null && m.price_out != null)
     ? '<span class="hint">¥' + esc(m.price_in) + "/¥" + esc(m.price_out) + "</span>" : "";
+  const imgcap = '<span class="tag imgcap' + (m.image_in ? " ok" : "") + '" title="' +
+    (m.image_in ? t("支持图片输入，点击关闭")
+                : t("纯文本模型，点击开启图片输入（内置智能体传图以此为准）")) + '"' +
+    ' onclick="toggleModelImage(\'' + esc(pid) + '\', \'' + esc(m.name) + '\')">' + t("图") + "</span>";
   const sel = modelSel(pid);
   return '<div class="prow' + (m.enabled ? "" : " off") + '" draggable="true" data-group="' +
     esc(group) + '" data-name="' + esc(m.name) + '">' +
@@ -1272,7 +1287,7 @@ function provModelRow(pid, m, group) {
     '<span class="drag" title="' + t("拖动调整优先级") + '"><svg class="ico" aria-hidden="true"><use href="#i-grip"></use></svg></span>' +
     '<span class="pprio">#' + m.priority + "</span>" +
     '<span class="pname" title="' + esc(m.name) + '">' + esc(m.name) + "</span>" +
-    price + tmHtml +
+    price + imgcap + tmHtml +
     '<span class="row-ops">' +
     '<button class="ghost small row-op" onclick="testModelBtn(\'' + esc(pid) + '\', \'' + esc(m.name) + '\')">' + t("测试") + '</button>' +
     '<button class="danger small row-op" title="' + t("从列表删除：刷新/重新导入不会再带回，可在分组底部恢复") + '"' +
@@ -1352,6 +1367,7 @@ async function modelOp(pid, name, op) {
   try {
     await api("/api/models/model-op", { method: "POST",
       body: JSON.stringify({ provider_id: pid, name, op }) });
+    autoRebindSoon();   // 模型停用/启用/删除会改变推荐源与死链判定，自动补绑一次
     const s = modelSel(pid);            // 单行操作后同步清掉该行勾选
     if (s[name]) { delete modelSelSet(pid)[name]; }
   } catch (e) { toast(t("操作失败：") + e.message, true); }
@@ -1359,6 +1375,21 @@ async function modelOp(pid, name, op) {
   poll();
 }
 
+function toggleModelImage(pid, name) {
+  const p = (S.providers || []).find((x) => x.id === pid);
+  const m = p && (p.models || []).find((x) => x.name === name);
+  api("/api/models/model-caps", { method: "POST",
+    body: JSON.stringify({ provider_id: pid, name, image_in: !(m && m.image_in) }) })
+    .then(() => { S.modelsSig = null; poll(); })
+    .catch((e) => toast(t("保存失败：") + e.message, true));
+}
+
+/* 反查模型是否声明图片输入（绑定页 chip/列表只读徽标用） */
+function modelHasImage(pid, name) {
+  const p = (S.providers || []).find((x) => x.id === pid);
+  return !!(p && (p.models || []).some((x) => x.name === name && x.image_in));
+}
+
 /* ---- 模型批量选择 ---- */
 function toggleModelSel(pid, name, on) {
   const s = modelSelSet(pid);
@@ -1403,6 +1434,7 @@ async function batchModelOp(pid, op) {
   try {
     await api("/api/models/model-op", { method: "POST",
       body: JSON.stringify({ provider_id: pid, names, op }) });
+    autoRebindSoon();
   } catch (e) { toast(t("操作失败：") + e.message, true); }
   clearModelSel(pid);
   poll();
@@ -1421,6 +1453,7 @@ async function toggleProviderEnabled(pid, enabled) {
   try {
     await api("/api/models/provider-op", { method: "POST",
       body: JSON.stringify({ ids: [pid], op: off ? "enable" : "disable" }) });
+    autoRebindSoon();
   } catch (e) { toast(t("操作失败：") + e.message, true); }
   S.modelsSig = null;
   poll();
@@ -1444,7 +1477,8 @@ async function refreshAllModels() {
     btn.disabled = false; btn.classList.remove("loading");
     btn.title = t("全部重新拉取模型列表");
   }, 1500);
-  setTimeout(poll, 2500); setTimeout(poll, 8000);
+  setTimeout(poll, 2500);
+  setTimeout(autoRebindSoon, 8000);   // 模型列表落盘后推荐源才完整，补绑一次
 }
 
 async function refreshProviderModels(id) {
@@ -1455,7 +1489,7 @@ async function refreshProviderModels(id) {
     else toast(t("已获取模型列表 · wire 适配测试后台进行中"));
   } catch (e) { toast(t("获取失败：") + e.message, true); }
   poll();
-  setTimeout(poll, 4000);  // 后台探测落盘后补一轮，适配徽标及时出现
+  setTimeout(autoRebindSoon, 4000);   // 模型列表落盘后补绑一次（后台 wire 探测同步进行）
 }
 
 /* 供应商编辑卡：协议可选「自动」；显式选定时它是主协议（用于需要唯一协议的
@@ -1511,6 +1545,7 @@ async function delProvider(id) {
   try {
     await api("/api/models/provider-op", { method: "POST",
       body: JSON.stringify({ ids: [id], op: "delete" }) });
+    autoRebindSoon();
   } catch (e) { toast(t("操作失败：") + e.message, true); }
   if (S.selModels) delete S.selModels[id];
   if (S.selProvs) delete S.selProvs[id];
@@ -1574,6 +1609,7 @@ async function doAddProvider() {
     S.modelsSig = null;
     closeModal();
     poll();
+    autoRebindSoon();   // 新增即启用：马上给空链/死链一次推荐机会
     if (p && body.api_key) refreshProviderModels(p.id);  // 有密钥才自动拉模型列表
   } catch (e) {
     res.textContent = t("保存失败：") + e.message;
@@ -1669,7 +1705,7 @@ async function doImport() {
     btn.textContent = t("完成");
     btn.disabled = false;
     btn.onclick = closeModal;
-    if (r.imported) { S.selProv = null; S.modelsSig = null; poll(); }
+    if (r.imported) { S.selProv = null; S.modelsSig = null; poll(); autoRebindSoon(); }
   } catch (e) {
     $("import-result").innerHTML = '<div class="msg bad">' + t("导入失败：") + esc(e.message) + "</div>";
     btn.disabled = false; btn.textContent = t("导入选中");
@@ -1786,6 +1822,9 @@ async function createTask() {
   try {
     const r = await api("/api/tasks", { method: "POST", body: JSON.stringify(payload) });
     msg.textContent = t("已创建，跳转运行页…");
+    // 先把新任务刷进 state 再跳：chatEngineIsDirect 靠 S.state.tasks 判引擎，
+    // 不刷的话对话页签不会就绪，自动选卡落不到「对话」
+    try { await refreshState(); } catch (e) { /* 刷失败等轮询兜底 */ }
     jumpToRun(r.run_id);
     $("f-goal").value = "";
     S.atts = []; renderAttachChips();   // 附件已移交任务待提交区，清空本地列表
@@ -2083,7 +2122,7 @@ function bindCtxMenus() {
       items.push({ label: t("复制工作目录路径"), fn: () => revealPath("tasks", taskId, false) });
       if (runId) items.push({ label: t("复制日志目录路径"), fn: () => revealPath("runs", runId, false) });
       const st = det.dataset.status || "";
-      if (st === "failed" || st === "cancelled") items.push({ label: t("↻ 重试任务"), fn: () => retryTask(taskId) });
+      if (st === "failed" || st === "cancelled") items.push({ label: t("↻ 继续任务"), fn: () => retryTask(taskId) });
       // 与详情页同一套说法：失败/取消叫「编辑重试」，其余叫「基于此任务新建」
       items.push({ label: (st === "failed" || st === "cancelled") ? t("✎ 编辑重试") : t("基于此任务新建"),
                    fn: () => newFromTask(taskId) });
@@ -3093,6 +3132,7 @@ function closeRun() {
   stopHiveTick();
   detailSideReset();
   $("run-detail").classList.add("hidden");
+  renderChatNav();   // 解除 main.chat-fill（对话为主的固定高度），恢复外层滚动
   if (document.body.classList.contains("settings-mode")) {
     document.querySelector("#sub-runs .panel:first-child").classList.remove("hidden");
   } else {
@@ -3152,7 +3192,55 @@ function applyRdTabs() {
   });
   document.querySelectorAll("#run-detail .rd-pane").forEach((p) =>
     p.classList.toggle("hidden", p.dataset.pane !== S.rdTab));
-}
+  // 对话页签不放日志抽屉：会盖住贴底输入条（手动切来/自动选卡都覆盖）
+  if (S.rdTab === "chat" && !$("rd-log").classList.contains("hidden")) window.rdLogClose();
+  renderChatNav();
+}
+
+/* 直连任务「对话为主」布局：收起常规页签条，右上角一排小胶囊按需打开
+ * 蜂巢/步骤/成果等分区；离开对话时给「返回对话」入口（用户 2026-09-17 拍板：
+ * 对话场景其它页签用处不大，默认关掉、需要再点开）。 */
+function renderChatNav() {
+  const nav = $("rd-chat-nav"), detail = $("run-detail");
+  if (!nav || !detail) return;
+  const direct = !detail.classList.contains("hidden") && !!S.lastRun &&
+    chatEngineIsDirect(S.lastRun);
+  detail.classList.toggle("chat-mode", direct);
+  // 对话为主时锁死外层滚动（main 是滚动根）；离开详情必须解锚，否则任务列表滚不动
+  const mainEl = document.querySelector("main");
+  if (mainEl) mainEl.classList.toggle("chat-fill", direct);
+  if (!direct) { nav.classList.add("hidden"); nav.innerHTML = ""; return; }
+  const labels = { hive: t("蜂巢"), steps: t("步骤"), result: t("成果"),
+    git: "Git", bible: t("圣经"), bookmeta: t("作品信息") };
+  const avail = rdTabAvail();
+  let pills = "";
+  for (const k of ["hive", "steps", "result", "git", "bible", "bookmeta"]) {
+    if (!avail[k]) continue;
+    // 徽章直接镜像隐藏页签上的（蜂巢在岗数/步骤数/待裁决/成果数），不另设状态源
+    const badge = document.querySelector('#rd-tabs .rd-tab[data-tab="' + k + '"] .rd-badge');
+    pills += '<button class="cn-pill' + (S.rdTab === k ? " on" : "") +
+      '" onclick="rdChatNavGo(\'' + k + '\')">' + labels[k] +
+      (badge && badge.textContent ? "<b>" + esc(badge.textContent) + "</b>" : "") + "</button>";
+  }
+  nav.innerHTML = (S.rdTab !== "chat"
+    ? '<button class="cn-back" onclick="rdChatNavBack()">' +
+      '<svg class="ico" aria-hidden="true"><use href="#i-arrow-left"></use></svg>' +
+      t("返回对话") + "</button>"
+    : "") +
+    '<span class="cn-pills">' + pills + "</span>";
+  nav.classList.remove("hidden");
+}
+window.rdChatNavGo = function (tab) {
+  S.rdTab = tab;
+  S.rdTabPin = true;   // 用户主动去看其它分区：别被自动选卡拽回对话
+  applyRdTabs();
+};
+window.rdChatNavBack = function () {
+  S.rdTab = "chat";
+  S.rdTabPin = false;
+  S.rdTabSig = "";
+  applyRdTabs();
+};
 
 /* 徽章：蜂巢=在岗数（运行中）、步骤=总步数、版本=待裁决、成果=文件数（loadArtifacts 里刷） */
 function rdTabBadges() {
@@ -3173,8 +3261,11 @@ function rdTabBadges() {
 function rdTabsSync(ctx) {
   if (ctx) S._rdCtx = ctx;
   if (ctx && !S.rdTabPin) {
+    // 对话页签可用性入签名：刚建的任务要等 state 刷进来 direct 才判定成立，
+    // chat 从不可用变可用时必须触发一次重新选卡（否则落在步骤/蜂巢不跳对话）
+    const chatAvail = $("rd-chat") && !$("rd-chat").classList.contains("hidden");
     const sig = (S.detailTaskKey || S.detailRunId || "") + "|" + (ctx.status || "") +
-      "|" + (ctx.gitState || "") + "|" + (ctx.running ? 1 : 0);
+      "|" + (ctx.gitState || "") + "|" + (ctx.running ? 1 : 0) + "|" + (chatAvail ? 1 : 0);
     if (S.rdTabSig !== sig) {
       S.rdTabSig = sig;
       const avail = rdTabAvail();
@@ -3370,11 +3461,13 @@ const BOOKMETA_PLATFORMS = [
 ];
 const BOOKMETA_FIELDS = {
   fanqie: [["book_name", "作品名"], ["signing_mode", "签约模式"], ["target_reader", "目标读者"],
-    ["category", "分类"], ["tags_theme", "主题标签"], ["tags_role", "角色标签"],
-    ["tags_plot", "情节标签"], ["protagonist_1", "主角名1"],
-    ["protagonist_2", "主角名2"], ["summary", "作品简介"]],
+    ["category", "主分类"], ["tags_theme", "主题标签"], ["tags_role", "角色标签"],
+    ["tags_plot", "情节标签"], ["content_plot", "内容·情节"], ["content_emotion", "内容·情感"],
+    ["content_character", "内容·人设"], ["content_world", "内容·世界观"],
+    ["protagonist_1", "主角名1"], ["protagonist_2", "主角名2"], ["summary", "作品简介"]],
   qimao: [["book_name", "作品名称"], ["target_reader", "目标读者"], ["category_main", "一级分类"],
-    ["category_sub", "二级分类"], ["tags", "作品标签"], ["protagonist_1", "主角名1"],
+    ["category_sub", "二级分类"], ["tags_style", "风格标签"], ["tags_role", "角色标签"],
+    ["tags_plot", "情节标签"], ["tags_bg", "背景标签"], ["protagonist_1", "主角名1"],
     ["protagonist_2", "主角名2"], ["status", "作品状态"], ["summary", "作品简介"]],
 };
 
@@ -3486,6 +3579,7 @@ window.bmGen = async function (taskId, platform) {
     await api("/api/tasks/" + encodeURIComponent(taskId) + "/book-meta",
       { method: "POST", body: JSON.stringify({ platform }) });
     toast(t("已开始生成，完成后这里会自动更新"));
+    await refreshState(); render();   // 立即翻到「生成中」，不等 SSE 推送/下一轮轮询
   } catch (e) { toast(t("生成失败：") + e.message, true); }
 };
 
@@ -3604,7 +3698,7 @@ function _renderGitSnapshot(run, task) {
         '<span class="chip failed">' + t("检出失败") + "</span>" +
         '<code class="git-branch">codebee/' + esc(tid || t("（无主运行）")) + t("（") + esc(t("未创建")) + t("）") + "</code></div>" +
         (lastErr ? '<div class="hint warn">' + esc(lastErr) + "</div>" : "") +
-        '<div class="hint">' + esc(t("处理后点「重试任务」，运行会重新检出任务分支。")) + "</div>";
+        '<div class="hint">' + esc(t("处理后点「继续任务」，运行会重新检出任务分支。")) + "</div>";
       rdTabsSync();
       return;
     }
@@ -4021,7 +4115,7 @@ function drawInspector() {
       main.innerHTML = '<div class="insp-branch"><code>codebee/' + esc(d.task.id || "") +
         t("（") + esc(t("未创建")) + t("）") + '</code></div>' +
         (lastErr ? '<div class="hint warn">' + esc(lastErr) + "</div>" : "") +
-        '<span class="insp-hint">' + esc(t("处理后点「重试任务」，运行会重新检出任务分支。")) + "</span>";
+        '<span class="insp-hint">' + esc(t("处理后点「继续任务」，运行会重新检出任务分支。")) + "</span>";
     } else {
       // 没指定代码版本：没有任务分支，卡里只留一句说明
       chipEl.classList.add("hidden");
@@ -4650,7 +4744,8 @@ const hiveTails = {};                    // "runid|rel" -> 最近一行输出缓
 function stopHiveTick() { if (hiveTimer) { clearInterval(hiveTimer); hiveTimer = null; } }
 
 /* run.steps -> 阶段泳道流水线：规划→起草→评审→修订→打磨→合成，先后关系一眼可见；
- * 运行中蜜蜂摆动+秒表走动；轨道光点流向下一阶段；点格即看实时输出。 */
+ * 运行中蜜蜂摆动+秒表走动+蜜光呼吸；彗尾光点流向下一阶段；点格即看实时输出；
+ * 入场瀑布只在步骤结构真变时重播（签名闸门，轮询空转不重建 DOM）。 */
 function hiveStage(role) {
   const r = String(role || "");
   if (/^(plan|outline)/.test(r)) return t("规划");
@@ -4711,7 +4806,7 @@ window.renderHive = function (run) {
   if (sub) sub.textContent = running.length
     ? t("在岗") + " " + running.length + " / " + steps.length : t("全部空闲");
   const activeIdx = lanes.map((l) => byStage[l].some((s) => s.status === "running")).lastIndexOf(true);
-  const cell = (s) => {
+  const cell = (s, laneIdx, cellIdx) => {
     // 五归一：取消/超时的格子不再冒充「完成」——与步骤芯片同三色体系
     const st = s.status === "running" || s.status === "queued" ? "running"
       : s.status === "failed" ? "failed"
@@ -4724,30 +4819,37 @@ window.renderHive = function (run) {
     const key = run.id + "|" + (s.log || "");
     if (st !== "running") delete hiveTails[key];
     const tailText = st === "running" ? (hiveTails[key] || concl) : concl;
-    const title = [s.role, who, s.started_at ? t("开始于 ") + s.started_at : "",
+    const title = [s.role, who,
+                   (s.duration_s != null ? s.duration_s + "s" : ""),
+                   s.started_at ? t("开始于 ") + s.started_at : "",
                    (s.note ? "◆ " + s.note : "")].filter(Boolean).join(" · ")
       + (concl && st !== "running" ? "\n" + t("结论：") + concl : "");
-    return '<div class="hive-cell st-' + st + '" title="' + esc(title) + '" ' +
+    // --d：入场瀑布逐格延迟（泳道间 110ms + 同泳道逐格 45ms），样式端消费
+    return '<div class="hive-cell st-' + st + (st === "running" ? " hc-breathe" : "") + '"' +
+      ' style="--d:' + (laneIdx * 110 + cellIdx * 45) + 'ms"' +
+      ' title="' + esc(title) + '" ' +
       'onclick="hiveOpenLog(\'' + esc(run.id) + "', '" + esc(s.log || "") + '\')">' +
       '<div class="hc-head">' +
-      '<svg class="ico hc-bee" aria-hidden="true"><use href="#i-bee"></use></svg>' +
+      '<img class="hc-bee" src="icons/bee.svg" alt="" aria-hidden="true">' +
       '<span class="hc-role">' + esc(s.role || "") + "</span>" +
       '<span class="hc-who">' + esc(who) + "</span></div>" +
       '<div class="hc-tail" data-log="' + esc(s.log || "") + '">' +
       esc(tailText) + "</div>" +
       '<div class="hc-meta"><span class="hc-elapsed" data-started="' + esc(s.started_at || "") + '">' +
       (s.duration_s != null ? s.duration_s + "s" : hiveElapsed(s.started_at)) + "</span>" +
-      (st === "running" ? '<span class="hc-live">● ' + t("工作中") + "</span>" : "") +
+      (st === "running" ? '<span class="hc-live"><i class="live-dot"></i>' + t("工作中") + "</span>" : "") +
       (st === "timeout" ? '<span class="hc-dead">⏱ ' + t("超时") + "</span>" : "") +
       (st === "cancelled" ? '<span class="hc-dead">' + t("已取消") + "</span>" : "") +
       "</div></div>";
   };
-  const dots = (list) => list.slice(-12).map((s) => {
+  const dots = (list, laneIdx) => list.slice(-12).map((s, di) => {
     const dc = s.status === "running" ? "run" : s.status === "failed" ? "fail"
       : s.status === "cancelled" ? "cancel" : s.status === "timeout" ? "time" : "done";
     const stx = { running: t("运行中"), failed: t("失败"), cancelled: t("已取消"),
                   timeout: t("超时"), done: t("完成") }[dc] || s.status;
-    return '<i class="ld ld-' + dc + '" title="' + esc((s.role || "") + " · " + stx) + '"></i>';
+    // --d：与格子同款级联延迟——入场时整条轨道按执行顺序"哗"地点亮（进度回放感）
+    return '<i class="ld ld-' + dc + '" style="--d:' + (laneIdx * 110 + di * 45) + 'ms"' +
+      ' title="' + esc((s.role || "") + " · " + stx) + '"></i>';
   }).join("");
   $("rd-hive-cells").innerHTML = lanes.map((stage, i) => {
     const list = byStage[stage];
@@ -4755,13 +4857,44 @@ window.renderHive = function (run) {
     // 无 running（终态回看）：全部视为已完成泳道；有 running 时 activeIdx 之前算完成
     const cls = hasRun ? "lane-active"
       : (activeIdx === -1 || i < activeIdx ? "lane-done" : "lane-idle");
+    // 泳道头视觉 v2：阶段序号徽章（01/02…流水线站序）+ 已完成进度（settled/total）
+    const settled = list.filter((s) => !["running", "queued"].includes(s.status)).length;
     return '<div class="hive-lane ' + cls + '">' +
-      '<div class="lane-head"><span class="lane-name">' + esc(stage) + '</span>' +
+      '<div class="lane-head">' +
+      '<span class="lane-idx">' + String(i + 1).padStart(2, "0") + "</span>" +
+      '<span class="lane-name">' + esc(stage) + '</span>' +
       '<span class="lane-n">×' + list.length + "</span>" +
-      (hasRun ? '<span class="lane-live">● ' + t("进行中") + "</span>" : "") + "</div>" +
-      '<div class="lane-track">' + dots(list) + "</div>" +
-      '<div class="lane-cells">' + list.slice(-8).map(cell).join("") + "</div></div>";
-  }).join('<div class="lane-flow" aria-hidden="true"></div>');
+      (settled ? '<span class="lane-prog">' + settled + "/" + list.length + "</span>" : "") +
+      (hasRun ? '<span class="lane-live"><i class="live-dot"></i>' + t("进行中") + "</span>" : "") + "</div>" +
+      '<div class="lane-track">' + dots(list, i) + "</div>" +
+      '<div class="lane-cells">' + list.slice(-8).map((s, ci) => cell(s, i, ci)).join("") + "</div></div>";
+  }).join('<div class="lane-flow" aria-hidden="true">'
+    + '<svg class="flow-line flow-line-down" viewBox="0 0 36 44" aria-hidden="true">'
+    + '<path class="flow-path" d="M14 2 C14 16 22 28 22 42"/><path class="flow-tip" d="M16 36 L22 43 L28 36"/></svg>'
+    + '<svg class="flow-line flow-line-up" viewBox="0 0 36 44" aria-hidden="true">'
+    + '<path class="flow-path" d="M22 2 C22 16 14 28 14 42"/><path class="flow-tip" d="M8 36 L14 43 L20 36"/></svg>'
+    + '<span class="flow-bee"><img src="icons/bee.svg" alt="" aria-hidden="true"></span>'
+    + '</div>');
+  // 入场瀑布闸门：只按"结构"（泳道数/格数/状态构成）签名；运行中尾巴/秒表每 2s
+  // 变化不能触重播。签名没变就不动 DOM——格子不闪、动画不重启、悬停不弹手。
+  const sig = lanes.map((l) => l + ":" + byStage[l].length + "(" +
+    byStage[l].map((s) => s.status[0] || "?").join("") + ")").join("|");
+  const cellsBox = $("rd-hive-cells");
+  if (cellsBox.dataset.hiveSig !== sig) {
+    const fresh = cellsBox.dataset.hiveSig == null;   // 首次展开详情也照播，先落框架再逐格亮起
+    cellsBox.dataset.hiveSig = sig;
+    // hive-enter 只在下一帧就摘（Rune/Hermes 式一闪而过的瀑布），全程保留会锁死
+    // 入场帧；1400ms 定时是 RAF 被后台标签页冻结时的兜底。
+    if (!fresh) cellsBox.classList.remove("hive-enter");
+    cellsBox.classList.add("hive-enter");
+    if (cellsBox._hiveEnterRAF) cancelAnimationFrame(cellsBox._hiveEnterRAF);
+    cellsBox._hiveEnterRAF = requestAnimationFrame(() => {
+      requestAnimationFrame(() => cellsBox.classList.remove("hive-enter"));
+      cellsBox._hiveEnterRAF = null;
+    });
+    if (cellsBox._hiveEnterT) clearTimeout(cellsBox._hiveEnterT);
+    cellsBox._hiveEnterT = setTimeout(() => cellsBox.classList.remove("hive-enter"), 1400);
+  }
   const live = running.length && (run.status === "running" || run.status === "queued");
   if (hiveClock) { clearInterval(hiveClock); hiveClock = null; }
   if (live) {
@@ -4773,12 +4906,8 @@ window.renderHive = function (run) {
         el.textContent = hiveElapsed(el.dataset.started);
       });
     }, 1000);
-    // 点开任务第一眼就在干活：自动展开第一个在岗步骤的实时日志。
-    // 每 run 只自动开一次；用户手动收起后不再打扰。
-    if (S.hiveAutoLog !== run.id && !currentLog) {
-      const first = running.find((s) => s.log);
-      if (first) { S.hiveAutoLog = run.id; toggleLog(run.id, first.log); }
-    }
+    // 日志抽屉一律手动打开（点蜂巢格/步骤行）：自动弹开会盖住对话输入条，
+    // 用户要求所有页面默认不展示日志（2026-09-17）
   } else stopHiveTick();
   rdTabsSync();   // 蜂巢显隐直接决定「蜂巢」标签可用性
 };
@@ -4993,6 +5122,38 @@ function chatEngineIsDirect(run) {
   return !!(t && t.engine === "direct");
 }
 
+/* 对话正文：``` 围栏渲染成真代码块（复用 codeBlockHTML：行号+高亮+代码主题），
+ * 其余文本保持 pre-wrap 原样（行内 `code` 与 **加粗** 轻量翻译）。模型输出先
+ * 全量 esc 再插标记；未闭合围栏按代码块收尾，流式输出中途也不撒裸反引号。 */
+function chatBodyHTML(text) {
+  const lines = String(text || "").split(/\r?\n/);
+  const out = [];
+  let txt = [], code = null;
+  const flushTxt = () => {
+    if (!txt.length) return;
+    out.push('<div class="chat-body">' + txt.map((l) => {
+      let h = esc(l);
+      h = h.replace(/`([^`]+)`/g, "<code>$1</code>");
+      h = h.replace(/\*\*([^*]+)\*\*/g, "<b>$1</b>");
+      return h;
+    }).join("\n") + "</div>");
+    txt = [];
+  };
+  for (const raw of lines) {
+    const line = raw.replace(/\s+$/, "");
+    if (line.startsWith("```")) {
+      if (code) { out.push(codeBlockHTML(code.join("\n"))); code = null; }
+      else { flushTxt(); code = []; }
+      continue;
+    }
+    if (code) code.push(raw);
+    else txt.push(raw);
+  }
+  if (code) out.push(codeBlockHTML(code.join("\n")));
+  flushTxt();
+  return out.join("");
+}
+
 async function renderChat(run, active) {
   const box = $("rd-chat");
   if (!box) return;
@@ -5013,36 +5174,59 @@ async function renderChat(run, active) {
   // 指向当前详情正在展示的那条 run——拉取期间切了详情就丢弃响应
   if (!S.lastRun || S.lastRun.id !== runForFetch) return;
   const flow = $("rd-chat-flow");
+  // 时间显示统一收敛到 HH:MM（日期在 meta 条里，全量戳塞气泡就是噪音）；
+  // 附件兼容 字符串路径 / {name|path} 对象 两种形态（对象直接拼会成 [object Object]）
+  const chatTime = (v) => { const s = String(v || "");
+    return /^\d{4}-\d{2}-\d{2}[ T]/.test(s) ? s.slice(11, 16) : s; };
+  const attName = (a) => { const p = typeof a === "string" ? a
+    : ((a && (a.name || a.path)) || "");
+    return String(p).split(/[\\/]/).pop() || ""; };
   flow.innerHTML = items.map((it) => {
     if (it.kind === "user") {
-      // 用户消息：右侧浅灰圆角块，元信息在块内顶部
+      // 用户消息：右侧浅灰圆角块，元信息在块内顶部。
+      // 附件胶囊可点开预览：data-att 带 _attachments/ 相对路径（老数据裸文件名
+      // 在前端钉回 _attachments/，与服务端 norm_rel 同口径），事件委托绑在
+      // rd-chat-flow 上——时间线整块 innerHTML 重建也不丢监听
+      const atts = (it.attachments || []).map((a) => {
+        const nm = attName(a);
+        if (!nm) return null;
+        let rel = typeof a === "string" ? a : ((a && (a.path || a.name)) || nm);
+        rel = String(rel).replace(/\\/g, "/");
+        if (!rel.startsWith("_attachments/")) rel = "_attachments/" + rel.split("/").pop();
+        return { nm, rel };
+      }).filter(Boolean);
       return '<div class="chat-row me">' +
         '<div class="chat-bubble me">' +
-        '<div class="chat-meta">' + esc(it.who || "") + " " + esc(it.at || "") +
+        '<div class="chat-meta">' + esc(it.who || "") + " " + esc(chatTime(it.at)) +
         (it.consumed ? "" : " · " + t("待送达")) + "</div>" +
         esc(it.text || t("（仅附件）")) +
-        ((it.attachments || []).length
-          ? '<div class="chat-atts">' + it.attachments.map((a) =>
-              '<span class="att-chip2">' + esc(String(a).split(/[\\/]/).pop()) + "</span>").join("") + "</div>"
+        (atts.length
+          ? '<div class="chat-atts">' + atts.map((a) =>
+              '<span class="att-chip2 att-open" data-att="' + esc(a.rel) +
+              '" title="' + esc(t("点击查看")) + '">' + esc(a.nm) + "</span>").join("") + "</div>"
           : "") +
         "</div></div>";
     }
     // 协议尾行是给编排器判收的机器标记，不该出现在聊天正文里（真源在提示词约定）
     const body = String(it.text || "").replace(/\n*DIRECT_DONE:.*\s*$/s, "").trim();
-    // 运行中的步骤还没有正文（output/summary 都空）：给占位，不渲染空气泡
-    const shown = body || (it.status === "running" ? t("正在执行…") : t("（本轮无文本输出）"));
+    // 运行中还没有正文：三点打字动画（终态无正文才落「无文本输出」占位）
+    const bodyHtml = body ? chatBodyHTML(body)
+      : (it.status === "running"
+        ? '<span class="chat-typing" aria-label="' + esc(t("正在执行…")) + '"><i></i><i></i><i></i></span>'
+        : esc(t("（本轮无文本输出）")));
+    // 元信息只留 名字+时间（+失败标记）：路由/供应商细节属于「步骤」页签，塞这里就是噪音
+    const metaBad = it.status === "failed" || it.status === "cancelled";
     // 智能体回复：头像 + 整幅正文（不套气泡框），元信息小字落在正文下方
     return '<div class="chat-row">' +
       '<span class="chat-avatar" aria-hidden="true"><svg class="ico"><use href="#i-bee"></use></svg></span>' +
       '<div class="chat-bubble agent">' +
-      '<pre class="chat-body">' + esc(shown) + "</pre>" +
-      '<div class="chat-meta">' + esc(it.who || "") + " " + esc(it.at || "") +
-      (it.note ? " · " + esc(it.note) : "") +
-      (it.status && it.status !== "done" ? " · " + esc(it.status) : "") + "</div></div></div>";
+      '<div class="chat-body">' + bodyHtml + "</div>" +
+      '<div class="chat-meta">' + esc(it.who || "") + " " + esc(chatTime(it.at)) +
+      (metaBad ? " · " + t(it.status === "failed" ? "失败" : "已取消") : "") + "</div></div></div>";
   }).join("") || '<div class="hint">' + esc(t("还没有对话内容")) + "</div>";
   const hint = $("rd-chat-hint");
   if (hint) hint.textContent = active
-    ? t("运行中：消息随下一步送达（插不进正在跑的这一步）")
+    ? t("运行中：新消息会排队，本轮回答完后依次送达")
     : t("已结束：发送后将自动开新一轮接着做");
   flow.scrollTop = flow.scrollHeight;
 }
@@ -5050,12 +5234,28 @@ async function renderChat(run, active) {
 function drawChatAtts() {
   const box = $("rd-chat-att-list");
   if (!box) return;
+  // 点名字开预览（待提交区原文走 /api/attachments/<id>），× 才是移除
   box.innerHTML = chatAtts.map((a, i) =>
-    '<span class="att-chip2">' + esc(a.name) + '<b onclick="chatRemoveAtt(' + i + ')" title="' +
-    esc(t("移除")) + '">×</b></span>').join("");
+    '<span class="att-chip2 att-view" data-att-id="' + esc(a.id || "") +
+    '" data-att-name="' + esc(a.name) + '" title="' + esc(t("点击查看")) + '">' + esc(a.name) +
+    '<b onclick="chatRemoveAtt(' + i + ')" title="' + esc(t("移除")) + '">×' +
+    '</b></span>').join("");
 }
 window.chatRemoveAtt = function (i) { chatAtts.splice(i, 1); drawChatAtts(); };
 
+/* 对话附件点击预览：已落盘的走 run 工作目录 /api/runs/<id>/file（rel 为
+ * _attachments/ 相对路径），待提交的走 /api/attachments/<id>；
+ * 弹窗与成品预览同款——图片直接看图、文本看码、二进制给下载。 */
+window.chatAttPopup = function (rel) {
+  if (!rel || !chatRunId) return;
+  return _fpPreviewUrl("/api/runs/" + encodeURIComponent(chatRunId) +
+    "/file?name=" + encodeURIComponent(rel), rel);
+};
+window.chatPendingPopup = function (id, name) {
+  if (!id) return;
+  return _fpPreviewUrl("/api/attachments/" + encodeURIComponent(id), name || "attachment");
+};
+
 async function chatUploadFiles(files) {
   for (const f of files) {
     try {
@@ -5083,24 +5283,33 @@ window.chatSend = async function () {
   btn.disabled = true;
   try {
     if (active) {
+      // 运行中：消息进信箱排队（时间线上带「待送达」标记），本轮跑完自动续轮送达
       await api("/api/runs/" + encodeURIComponent(chatRunId) + "/messages", {
         method: "POST",
         body: JSON.stringify({ text, attachments: chatAtts.map((a) => a.id) }),
       });
-      toast(t("已入箱：随下一步送达"));
+      toast(t("已排队：随下一步一起送达"));
     } else {
       const r = await api("/api/runs/" + encodeURIComponent(chatRunId) + "/chat", {
         method: "POST",
         body: JSON.stringify({ text, attachments: chatAtts.map((a) => a.id) }),
       });
       toast(t("已开新一轮，接着做…"));
-      if (r && r.run_id) { chatSig = ""; jumpToRun(r.run_id); return; }
+      if (r && r.run_id) {
+        if (S.detailTaskKey) { S.taskSig = ""; renderTaskDetail(); }
+        else jumpToRun(r.run_id);
+      }
     }
+    // 发送成功一律清空输入框（只清输入，时间线里的历史回复不动）；
+    // 此前 /chat 分支提前 return 跳过了清空，发出去的字一直留在框里
     ta.value = "";
+    ta.style.height = "";
     chatAtts = []; drawChatAtts();
     chatSig = "";   // 强制重画时间线
-    const d = await api("/api/runs/" + encodeURIComponent(chatRunId));
-    if (d.run) renderChat(d.run, d.run.status === "running" || d.run.status === "queued");
+    if (active) {
+      const d = await api("/api/runs/" + encodeURIComponent(chatRunId));
+      if (d.run) renderChat(d.run, d.run.status === "running" || d.run.status === "queued");
+    }
   } catch (e) { toast(t("发送失败：") + e.message, true); }
   finally { btn.disabled = false; }
 };
@@ -5115,6 +5324,12 @@ function bindChat() {
     e.target.value = "";
   });
   send.addEventListener("click", window.chatSend);
+  // 自动伸高：跟内容走、有上限（160px 后内部滚动）；清空由 chatSend 归零。
+  // 高度只由用户输入驱动，轮询重画不碰它——框框不再忽大忽小
+  ta.addEventListener("input", () => {
+    ta.style.height = "auto";
+    ta.style.height = Math.min(ta.scrollHeight, 160) + "px";
+  });
   ta.addEventListener("keydown", (e) => {
     if (e.key === "Enter" && !e.shiftKey && !e.isComposing) { e.preventDefault(); window.chatSend(); }
   });
@@ -5128,6 +5343,19 @@ function bindChat() {
       return f && !f.name ? new File([f], "paste-" + Date.now() + ".png", { type: f.type }) : f;
     }).filter(Boolean));
   });
+  // 附件胶囊点击预览：委托绑在静态容器上——时间线轮询整块重建 innerHTML、
+  // 输入条胶囊增删重画，都不丢监听。时间线胶囊走已落盘文件，输入条胶囊
+  // （× 移除按钮除外）走待提交区
+  $("rd-chat-flow").addEventListener("click", (e) => {
+    const chip = e.target.closest(".att-open");
+    if (chip) window.chatAttPopup(chip.dataset.att);
+  });
+  const attBox = $("rd-chat-att-list");
+  if (attBox) attBox.addEventListener("click", (e) => {
+    if (e.target.closest("b")) return;   // × 自己的 onclick 负责移除
+    const chip = e.target.closest("[data-att-id]");
+    if (chip) window.chatPendingPopup(chip.dataset.attId, chip.dataset.attName);
+  });
 }
 
 /* ---------------------------------------------------------- 外观：皮肤 + 明暗（换肤） */
@@ -5136,6 +5364,7 @@ function bindChat() {
  * 皮肤改色只需要动 style.css，预览与真实界面不会各自漂移。 */
 const SKINS = [
   { id: "ocean", name: "深海", desc: "藏青底色 + 天蓝强调，夜间长时间盯任务更沉静（默认）" },
+  { id: "hermes", name: "墨金", desc: "暖墨底色 + 金色发丝线，Hermes 式古典优雅" },
   { id: "classic", name: "经典", desc: "黑白灰 + 蓝色强调，ChatGPT 式清爽配色" },
   { id: "forest", name: "森野", desc: "墨绿底色 + 青翠强调，偏自然的护眼配色" },
   { id: "amber", name: "暖阳", desc: "暖棕底色 + 琥珀强调，纸感暖调" },
@@ -5554,20 +5783,20 @@ function bindSelById(id) {
 function bindRepaint() { S.bindSig = null; renderBindings(); }
 
 /* 一键推荐绑定：给每个链为空的 CLI 按协议适配规则预填一条主模型。
- * 推荐顺序：显式协议原生匹配 > auto 且 wire_caps 命中；默认模型停用的厂商
- * 降权（当前键位是坏的，除非只剩它，否则不当首选——失效链重推荐实测）；
- * 同分按 priority / 数组序稳定。只预填草稿态（dirty），逐条看清后各自保存
+ * 推荐顺序：显式协议原生匹配 > auto 且 wire_caps 命中；同分按 priority /
+ * 数组序稳定。默认模型停用的厂商直接不推荐——它当前键位就是坏的，绑上去
+ * 解析照样失败；没有合适的就什么都不绑（2026-09-17 用户拍板，不再保留
+ * 「只剩它也上」的兜底）。只预填草稿态（dirty），逐条看清后各自保存
  * 或「全部保存」，健康链绝不被覆盖。 */
 function recommendFor(c) {
-  const allow = bindAllowedProtocols(c.orch_kind);
-  const provs = (S.providers || []).filter((p) => chainProvUsable(p, allow));
+  // 目录页「默认模型」下拉用 orch_kind || id 判协议（仅管理条目没有 orch_kind），
+  // 推荐口径与下拉过滤保持一致；绑定页条目恒有 orch_kind，不受影响
+  const allow = bindAllowedProtocols(c.orch_kind || c.id);
+  const badDefault = (p) => (p.models || []).some((m) => m.name === p.model &&
+    (m.hidden || m.enabled === false));
+  const provs = (S.providers || []).filter((p) => !badDefault(p) && chainProvUsable(p, allow));
   if (!provs.length) return null;
-  const score = (p) => {
-    const native = allow.indexOf(p.protocol) >= 0;
-    const badDefault = (p.models || []).some((m) => m.name === p.model &&
-      (m.hidden || m.enabled === false)) ? 500 : 0;
-    return (native ? 0 : 1) * 1000 + badDefault + (p.priority || 0);
-  };
+  const score = (p) => (allow.indexOf(p.protocol) >= 0 ? 0 : 1) * 1000 + (p.priority || 0);
   provs.sort((a, b) => score(a) - score(b));
   const p = provs[0];
   const models = (p.models || []).filter((m) => !m.hidden && m.enabled !== false);
@@ -5605,48 +5834,38 @@ function chainDeadReasons(c, chain) {
   return dead;
 }
 
+/* 单条绑定链的推荐修复动作：需要改返回新链，不动返回 null。
+ * 空链 → 预填推荐；整条死透（或只有链首且已死）→ 重推荐；链首死但链内还有
+ * 活的备选 → 新链首插最前（原降级序保留，推荐项已在链内则升首去重）。 */
+function bindRepairAction(c, st) {
+  const rec = recommendFor(c);
+  if (!st.chain.length) return rec ? [rec] : null;
+  const dead = chainDeadReasons(c, st.chain);
+  const allDead = dead.every((d) => d);
+  const headDead = dead[0] !== ""; // 空 p = CLI 默认凭据，是有意配置不算死
+  if (allDead) return rec ? [rec] : null;
+  if (headDead && rec && chainKey(st.chain) !== chainKey([rec]))
+    return [rec].concat(st.chain.filter((x) => !(x.p === rec.p && x.m === rec.m)));
+  return null;
+}
+
 function autoBindAll() {
   const targets = (S.catalog || []).filter((c) => c.installed && c.orch_kind);
   let filled = 0, skipped = 0, noProv = 0, refilled = 0;
   for (const c of targets) {
     const st = bindSelById(c.id);
-    if (!st.chain.length) {
-      const rec = recommendFor(c);
-      if (!rec) { noProv++; continue; }
-      st.chain = [rec];
-      st.dirty = true;
-      filled++;
+    const act = bindRepairAction(c, st);
+    if (!act) {
+      // 没动它：分清「健康链无需推荐」和「没有可推荐的」两种落空
+      if (!st.chain.length) { noProv++; continue; }
+      const dead = chainDeadReasons(c, st.chain);
+      if (dead.every((d) => d)) noProv++; else skipped++;
       continue;
     }
-    // 链非空：只处理死链——整条链全部死透（或只有链首且已死）才重推荐，
-    // 部分存活的长链保留（还降级得动，不擅自覆盖用户手工配的结构）
-    const dead = chainDeadReasons(c, st.chain);
-    const aliveN = dead.filter((d) => !d).length;
-    const allDead = aliveN === 0;
-    const headDead = dead[0] !== ""; // 空 p = CLI 默认凭据，是有意配置不算死
-    const rec = recommendFor(c);
-    if (allDead && rec) {
-      st.chain = [rec];
-      st.dirty = true;
-      refilled++;
-    } else if (allDead) {
-      noProv++;
-    } else if (headDead && rec && chainKey(st.chain) !== chainKey([rec])) {
-      // 链首死但链内还有活的备选：只把推荐的新链首插到最前面（原降级序保留）
-      const hasRec = st.chain.some((x) => x.p === rec.p && x.m === rec.m);
-      if (!hasRec) {
-        st.chain = [rec].concat(st.chain);
-        st.dirty = true;
-        refilled++;
-      } else {
-        // 推荐项已在链内：把它升到链首
-        st.chain = [rec].concat(st.chain.filter((x) => x !== rec));
-        st.dirty = true;
-        refilled++;
-      }
-    } else {
-      skipped++;
-    }
+    const wasEmpty = !st.chain.length;
+    st.chain = act;
+    st.dirty = true;
+    if (wasEmpty) filled++; else refilled++;
   }
   bindRepaint();
   if (filled && refilled) {
@@ -5664,6 +5883,56 @@ function autoBindAll() {
   }
 }
 
+/* 厂商/模型停用·启用·删除后自动补一次推荐绑定（2026-09-17 用户拍板）：
+ * 绑定链——空链预填、死链重推荐、死链首插新首，与「一键推荐绑定」同规则，
+ * 但直接落盘（自动场景没有人工确认环节）；目录页——空默认模型直填。
+ * 没有合适的推荐就保持原样，什么都不绑。绑定页上用户手改中的草稿（dirty）
+ * 不碰；一处都没改成静默返回，不打扰停用/启用的操作反馈。 */
+let _autoRebindRunning = false, _autoRebindAgain = false;
+async function autoRebindSoon() {
+  if (_autoRebindRunning) { _autoRebindAgain = true; return; }
+  _autoRebindRunning = true;
+  try {
+    await poll();   // 拿停用/启用落盘后的最新 providers / bindings / catalog
+    let fixed = 0;
+    for (const c of (S.catalog || []).filter((x) => x.installed && x.orch_kind)) {
+      const st = bindSelById(c.id);
+      if (st.dirty) continue;   // 用户手改中，不覆盖草稿
+      const act = bindRepairAction(c, st);
+      if (!act) continue;
+      const b = (S.bindings || {})[c.id] || {};
+      try {
+        await api("/api/models/binding", { method: "POST", body: JSON.stringify({
+          agent_id: c.id, provider_id: act[0].p,
+          chain: act.map((x) => ({ provider_id: x.p, model: x.m })),
+          difficulty_routing: !!b.difficulty_routing }) });
+        st.chain = act; st.dirty = false; st.key = chainKey(act);
+        fixed++;
+      } catch (e) { /* 单条失败不打断，等下次变更再补 */ }
+    }
+    for (const c of (S.catalog || []).filter((x) =>
+        x.installed && x.config_writable && !fmtModel(x.model))) {
+      const rec = recommendFor(c);
+      if (!rec) continue;
+      try {
+        const r = await api("/api/catalog/" + encodeURIComponent(c.id) + "/model",
+          { method: "POST", body: JSON.stringify({ model: rec.m }) });
+        c.model = r.model || rec.m;
+        fixed++;
+      } catch (e) { /* 同上 */ }
+    }
+    if (fixed) {
+      S.catSig = null; S.bindSig = null;
+      render();
+      toast(t("厂商/模型变动，已自动重绑 %1 处。").replace("%1", fixed));
+    }
+  } catch (e) { /* 自动补绑失败静默：不打断用户的停用/启用操作 */ }
+  finally {
+    _autoRebindRunning = false;
+    if (_autoRebindAgain) { _autoRebindAgain = false; autoRebindSoon(); }
+  }
+}
+
 async function saveAllBindings() {
   const targets = (S.catalog || []).filter((c) => c.installed && c.orch_kind);
   const dirty = targets.filter((c) => (S.bindSel[c.id] || {}).dirty);
@@ -5698,6 +5967,8 @@ function bindModelBox(c, provId) {
                 : ""));
         return '<span class="ochip' + (i === 0 ? " primary" : "") + '">' +
           "<b>" + (i === 0 ? t("主") : t("备")) + "</b>" + esc(pname) + " · " + esc(c2.m) +
+          (modelHasImage(c2.p, c2.m)
+            ? ' <span class="tag ok" title="' + esc(t("支持图片输入")) + '">' + t("图") + "</span>" : "") +
           (dead ? ' <span class="hint warn">⚠ ' + esc(t("协议不匹配，解析时跳过")) + "</span>" : badge) +
           (i > 0 ? '<button class="mini" data-m="' + esc(c2.m) + '" data-p="' + esc(c2.p) +
                   '" title="' + t("设为主模型") + '" onclick="bindPromote(\'' + esc(c.id) + '\', this)">' +
@@ -5707,7 +5978,7 @@ function bindModelBox(c, provId) {
           "</span>";
       }).join("")
     : '<span class="hint">' + t("未设置") + (provId
-        ? t("（按供应商/难度自动解析——供应商协议不匹配或被停用时解析为空，回落 CLI 本机默认）")
+        ? t("（按供应商/难度自动解析——供应商协议不匹配或被停用时解析为空，相关步骤将判失败）")
         : t("（用 CLI 默认模型——不会注入任何供应商凭据）")) + "</span>";
   return '<div class="field"><label>' + t("运行时模型链（跨厂商，最多 ") + MAX_ORCH_MODELS + t(" 条）") + "</label>" +
     '<div class="orch-row">' + chips +
@@ -5750,6 +6021,8 @@ function bindPanel(c) {
         return '<label class="oitem' + (dead ? " dim" : "") + '"><input type="checkbox" value="' + esc(m) + '" data-p="' + esc(g.id) + '"' +
           (has ? " checked" : "") + (dead ? " disabled" : "") +
           " onchange=\"bindPick('" + esc(c.id) + "', this, this.checked)\">" + esc(m) +
+          (modelHasImage(g.id, m)
+            ? ' <span class="tag ok" title="' + esc(t("支持图片输入")) + '">' + t("图") + "</span>" : "") +
           (dead ? ' <span class="hint warn">' + esc(t("无可用 wire，解析时跳过")) + "</span>" : "") +
           "</label>";
       }).join("") +
@@ -5895,6 +6168,45 @@ async function saveModel(id) {
   poll();
 }
 
+/* 一键绑定推荐模型（智能体目录页）：给「默认模型」还空着的已安装智能体按
+ * 协议适配规则（复用绑定页 recommendFor 评分）挑一家厂商的启用模型并直接
+ * 写入该 CLI 自身配置（写入侧先自动 .bak 备份）。已配置的不动——目录页的
+ * 默认模型会写进 CLI 全局配置，手工设置过的值（含 CLI 订阅自带的默认）不
+ * 该被一键覆盖；要换模型逐卡下拉改就行。 */
+async function catAutoBindAll() {
+  const targets = (S.catalog || []).filter((c) => c.installed && c.config_writable);
+  if (!targets.length) { toast(t("没有支持写入默认模型的已安装智能体。"), true); return; }
+  const empty = targets.filter((c) => !fmtModel(c.model));
+  if (!empty.length) { toast(t("所有已安装智能体都已配置默认模型，无需绑定。")); return; }
+  let done = 0, failed = 0, noProv = 0, firstErr = "";
+  for (const c of empty) {
+    const rec = recommendFor(c);
+    if (!rec) { noProv++; continue; }
+    try {
+      const r = await api("/api/catalog/" + encodeURIComponent(c.id) + "/model",
+        { method: "POST", body: JSON.stringify({ model: rec.m }) });
+      c.model = r.model || rec.m;
+      done++;
+    } catch (e) {
+      failed++;
+      if (!firstErr) firstErr = c.name + "：" + e.message;
+    }
+  }
+  S.catSig = null;
+  renderCatalog();
+  if (done && failed) {
+    toast(t("已为 %1 个智能体写入推荐模型，%2 个失败。").replace("%1", done).replace("%2", failed) +
+      (firstErr ? " " + firstErr : ""), true);
+  } else if (done) {
+    toast(t("已为 %1 个智能体写入推荐模型（原配置已自动备份 .bak）。").replace("%1", done));
+  } else if (failed) {
+    toast(t("推荐模型写入失败：") + firstErr, true);
+  } else {
+    toast(t("没有可推荐的：先到「模型接入」页导入与 CLI 协议匹配的供应商。"), true);
+  }
+  poll();
+}
+
 /* 一键打开：web 类后台起服务并自动开浏览器；console 类新开终端窗口跑交互 TUI。
    用的模型就是目录页「默认模型」已写入该 CLI 配置文件的那份；密钥由服务端按编排同款规则注入 */
 async function openAgent(id) {
@@ -6957,9 +7269,24 @@ async function loadSelfupdate(force) {
     SU = await api("/api/selfupdate" + (force ? "?force=1" : ""));
   } catch (e) { SU = null; }
   renderSu();
+  maybeWhatsnew();
   return SU;
 }
 
+/* 升级重启后的一次性「本次更新内容」：localStorage 记住已展示的版本，
+ * 版本变化且有本地 changelog 小节时弹窗（首次使用只记账不弹）。 */
+function maybeWhatsnew() {
+  if (!SU || !SU.current) return;
+  const prev = localStorage.getItem("su.myver");
+  localStorage.setItem("su.myver", SU.current);
+  if (prev && prev !== SU.current && SU.whatsnew) {
+    openModal(t("本次更新内容"),
+      "<p class=\"hint\">" + t("已更新到") + " <b>v" + esc(SU.current) + "</b></p>" +
+      "<pre class=\"su-notes\">" + esc(SU.whatsnew) + "</pre>",
+      "<button class=\"small\" onclick=\"closeModal()\">" + t("知道了") + "</button>");
+  }
+}
+
 function renderSu() {
   const info = $("su-info");
   if (!info) return;
@@ -6970,6 +7297,10 @@ function renderSu() {
   if (SU.has_update) {
     html += "<p class=\"hint\"><b>" + t("发现新版本") + " v" + SU.latest +
       t("　") + "<a href=\"#\" onclick=\"event.preventDefault();suApply()\">" + t("立即升级") + "</a></b></p>";
+    if (SU.notes) {
+      html += "<div class=\"hint\"><b>" + t("新版本更新内容") + t("：") + "</b>" +
+        "<pre class=\"su-notes\">" + esc(SU.notes) + "</pre></div>";
+    }
   } else if (SU.mode === "npm" && !SU.note) {
     html += "<p class=\"hint\">" + t("已是最新版。") + "</p>";
   }
@@ -8028,6 +8359,7 @@ document.addEventListener("DOMContentLoaded", () => {
   $("btn-reload-catalog").addEventListener("click", async () => {
     await api("/api/catalog/reload", { method: "POST" }); poll(); refreshSessionAgents();
   });
+  $("btn-catalog-autobind").addEventListener("click", catAutoBindAll);
   $("btn-import").addEventListener("click", openImportDialog);
   $("btn-add-provider").addEventListener("click", openAddProviderDialog);
   $("prov-search").addEventListener("input", () => {