codebee 0.1.21 → 0.1.22

package/app/core/skills.py

@@ -390,52 +390,14 @@ def relevance_top(lessons, task, limit):
     if not probe:
         return lessons[:limit]
 
-    def rank(x):
-        grams = _text_bigrams(x.get("title")) | _text_bigrams(x.get("content"))
-        return (-len(probe & grams), x.get("id") or "")
-
-    # 使用反馈闭环（pmb「量化记忆真实帮助」借鉴）：被选中次数多的教训排前
-    hits = _load_hits()
-    def rank(x):
-        grams = _text_bigrams(x.get("title")) | _text_bigrams(x.get("content"))
-        overlap = -len(probe & grams)
-        lid = x.get("id") or ""
-        return (overlap, -hits.get(lid, 0), lid)
-
-    return sorted(lessons, key=rank)[:limit]
-
-
-def _hits_path():
-    return paths.DATA_DIR / "skill_hits.json"
-
-
-def _load_hits():
-    """读取教训使用计数（{lesson_id: 次数}）。文件缺失/损坏返回空 dict。"""
-    try:
-        p = _hits_path()
-        if p.is_file():
-            import json
-            return json.loads(p.read_text(encoding="utf-8"))
-    except Exception:
-        pass
-    return {}
-
-
-def _bump_hits(ids):
-    """注入后递增使用计数并持久化（fire-and-forget，失败静默）。"""
-    try:
-        import json
-        p = _hits_path()
-        hits = _load_hits()
-        for lid in ids:
-            if lid:
-                hits[lid] = hits.get(lid, 0) + 1
-        p.parent.mkdir(parents=True, exist_ok=True)
-        tmp = p.with_suffix(".tmp")
-        tmp.write_text(json.dumps(hits, ensure_ascii=False), encoding="utf-8")
-        tmp.replace(p)
-    except Exception:
-        pass
+    # 使用反馈闭环（pmb「量化记忆真实帮助」借鉴）：被选中次数多的教训排前
+    def rank(x):
+        grams = _text_bigrams(x.get("title")) | _text_bigrams(x.get("content"))
+        overlap = -len(probe & grams)
+        lid = x.get("id") or ""
+        return (overlap, -int(x.get("hits") or 0), lid)
+
+    return sorted(lessons, key=rank)[:limit]
 
 
 def block_for(task, scope_override=None, *, stable_order=False):
@@ -448,7 +410,7 @@ def block_for(task, scope_override=None, *, stable_order=False):
     前缀缓存（同一任务 8 章应看到完全相同的技能块）。内容不变，只稳排序。
     """
     scope = scope_override or task.get("type") or "*"
-    parts, used = [], []
+    parts, used, lesson_ids = [], [], []
 
     for p in all_packs():
         if scope not in p["scopes"] and "*" not in p["scopes"]:
@@ -471,9 +433,10 @@ def block_for(task, scope_override=None, *, stable_order=False):
         if stable_order:
             lessons.sort(key=lambda x: x.get("id") or "")
         lines = []
-        for x in lessons:
-            lines.append("- **%s**：%s" % (x["title"], x["content"]))
-            used.append(x["id"])
+        for x in lessons:
+            lines.append("- **%s**：%s" % (x["title"], x["content"]))
+            used.append(x["id"])
+            lesson_ids.append(x["id"])
         parts.append("### 【本项目已沉淀的教训（历史评审反复出现，务必规避）】\n" + "\n".join(lines))
 
     if not parts:
@@ -481,10 +444,8 @@ def block_for(task, scope_override=None, *, stable_order=False):
     text = "## 经验库（写作/工程规范 + 历史教训，必须遵守）\n\n" + "\n\n".join(parts)
     if len(text) > MAX_INJECT_CHARS:
         text = text[:MAX_INJECT_CHARS] + "\n…（已截断）"
-    if used:
-        _bump_hits(used)   # 使用反馈闭环：被选中的教训递增计数，下次排序升权
-    if used:
-        bump_hits(used)
+    if lesson_ids:
+        bump_hits(lesson_ids)  # 包 id 不参与教训热度，命中数据只保留一份真源
     return text, used
 
 

package/app/core/task_compile.py

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+"""任务编译器：把用户任务和预置流程编译成统一、可审计的运行规格。"""
+from __future__ import annotations
+
+from . import dispatch, flows
+
+SCHEMA_VERSION = 1
+DIFFICULTIES = ("easy", "default", "hard")
+
+
+def _difficulty(task, flow):
+    explicit = str((task or {}).get("difficulty") or "").strip().lower()
+    if explicit in DIFFICULTIES:
+        return explicit, "用户指定"
+    try:
+        threshold = float((task or {}).get("threshold")
+                          if (task or {}).get("threshold") is not None
+                          else (flow or {}).get("threshold") or 7.0)
+    except (TypeError, ValueError):
+        threshold = 7.0
+    if threshold >= 8.5:
+        return "hard", "高质量门槛"
+    if threshold <= 6.0:
+        return "easy", "快速交付门槛"
+    if str((task or {}).get("type") or "").lower() in (
+            "research", "tech_proposal", "rank_scan"):
+        return "hard", "研究/方案类默认需要深度"
+    return "default", "标准难度"
+
+
+def _capabilities(task, dimension, engine):
+    caps = [dimension]
+    if engine == "code" or (task or {}).get("verify_command"):
+        caps.extend(["filesystem", "verification"])
+    if (task or {}).get("serial"):
+        caps.extend(["long_context", "continuity"])
+    if (task or {}).get("attachments"):
+        caps.append("attachments")
+    return list(dict.fromkeys(caps))
+
+
+def compile_task(task):
+    """返回统一任务规格；输入缺失或字段异常时保持可编排的安全兜底。"""
+    raw = dict(task or {})
+    ttype = str(raw.get("type") or "direct").strip().lower()
+    flow = flows.get_flow(ttype) or {}
+    engine = str(raw.get("engine") or flow.get("engine") or
+                 ("code" if ttype == "code" else "review")).strip()
+    if engine not in flows.ENGINES:
+        engine = flow.get("engine") or ("code" if ttype == "code" else "review")
+    difficulty, difficulty_reason = _difficulty(raw, flow)
+    dimension = dispatch.task_dimension(ttype, raw.get("role") or "")
+    rubric = raw.get("rubric") or flow.get("rubric") or []
+    if isinstance(rubric, str):
+        rubric = [x.strip() for x in rubric.replace("，", ",").split(",") if x.strip()]
+    rubric = [str(x).strip() for x in rubric if str(x).strip()][:8]
+    deliverable = str(raw.get("manuscript") or flow.get("manuscript") or "").strip()
+    serial = raw.get("serial") if isinstance(raw.get("serial"), dict) else None
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "type": ttype,
+        "title": str(raw.get("title") or "")[:120],
+        "goal": str(raw.get("goal") or "")[:2000],
+        "engine": engine,
+        "dimension": dimension,
+        "difficulty": difficulty,
+        "difficulty_reason": difficulty_reason,
+        "capabilities": _capabilities(raw, dimension, engine),
+        "deliverable": deliverable,
+        "quality_dimensions": rubric,
+        "serial": serial,
+        "explicit_agent": str(raw.get("implementer") or "").strip(),
+        "has_verification": bool(raw.get("verify_command")),
+    }
+
+
+def summary(spec):
+    """给运行日志/UI 的短说明，不包含用户正文。"""
+    spec = spec or {}
+    return "%s/%s/%s（能力：%s）" % (
+        spec.get("type") or "direct", spec.get("engine") or "direct",
+        spec.get("difficulty") or "default",
+        "、".join(spec.get("capabilities") or []) or "通用")

package/app/pet.py

@@ -30,8 +30,10 @@ import http.client
 import json
 import math
 import os
+import queue
 import random
 import sys
+import threading
 import time
 import webbrowser
 from pathlib import Path
@@ -39,7 +41,8 @@ from pathlib import Path
 # --------------------------------------------------------------- 纯逻辑（可测试）
 
 ACTIVE_STATUSES = ("queued", "running")
-BAD_STATUSES = ("failed", "cancelled")
+GOOD_STATUSES = ("done",)
+BAD_STATUSES = ("failed", "cancelled", "timeout")
 POLL_MS = 4000          # 轮询间隔
 POLL_TIMEOUT = 2.5      # 单次拉取超时（秒）
 MAX_MISS = 15           # 连续拉不到服务 N 次后自离（约 1 分钟，防孤儿常驻）
@@ -49,20 +52,32 @@ HOVER_MS = 250          # 指针轮询周期
 HOVER_DELAY_MS = 350    # 悬停多久后才弹任务清单（扫过不弹）
 
 
+def _safe_int(value, default=0, minimum=0):
+    """外部状态里的计数可能是空值或脏字符串；统一兜底并限制为非负数。"""
+    try:
+        number = int(value)
+    except (TypeError, ValueError, OverflowError):
+        number = int(default)
+    return max(minimum, number)
+
+
 def parse_snapshot(raw):
     """把 /api/pet_state 响应裁成蜜蜂关心的最小集。字段缺失一律兜底，不抛。"""
     raw = raw if isinstance(raw, dict) else {}
-    st = raw.get("settings") or {}
+    st = raw.get("settings") if isinstance(raw.get("settings"), dict) else {}
+    workers = raw.get("workers") if isinstance(raw.get("workers"), dict) else {}
+    digest = raw.get("digest") if isinstance(raw.get("digest"), dict) else {}
+    task_rows = raw.get("tasks") if isinstance(raw.get("tasks"), list) else []
     tasks = []
-    for t in (raw.get("tasks") or [])[:300]:
+    for t in task_rows[:300]:
         if not isinstance(t, dict):
             continue
         tasks.append({
             "id": str(t.get("id") or ""),
             "title": str(t.get("title") or t.get("id") or ""),
             "run_status": str(t.get("run_status") or ""),
-            "steps_done": int(t.get("steps_done") or 0),
-            "steps_total": int(t.get("steps_total") or 0),
+            "steps_done": _safe_int(t.get("steps_done")),
+            "steps_total": _safe_int(t.get("steps_total")),
             "step_current": str(t.get("step_current") or ""),
             "error": str(t.get("error") or ""),
         })
@@ -73,15 +88,14 @@ def parse_snapshot(raw):
             "pet_skin": str(st.get("pet_skin") or DEFAULT_SKIN),
         },
         "workers": {
-            "running": int((raw.get("workers") or {}).get("running") or 0),
-            "queued": int((raw.get("workers") or {}).get("queued") or 0),
+            "running": _safe_int(workers.get("running")),
+            "queued": _safe_int(workers.get("queued")),
         },
         "tasks": tasks,
         "digest": {
-            "unseen": int((raw.get("digest") or {}).get("unseen") or 0),
-            "latest": (raw.get("digest") or {}).get("latest")
-                      if isinstance((raw.get("digest") or {}).get("latest"), dict)
-                      else None,
+            "unseen": _safe_int(digest.get("unseen")),
+            "latest": digest.get("latest")
+                      if isinstance(digest.get("latest"), dict) else None,
         },
     }
 
@@ -105,10 +119,12 @@ def derive_state(prev_active_ids, tasks):
         by_id = {t["id"]: t for t in tasks}
         for tid in prev_active_ids:
             t = by_id.get(tid)
-            if t is None or t["run_status"] not in BAD_STATUSES:
-                info["good"].append(t or {"id": tid, "title": tid})
-            else:
+            if t is None:
+                continue
+            if t["run_status"] in BAD_STATUSES:
                 info["bad"].append(t)
+            elif t["run_status"] in GOOD_STATUSES:
+                info["good"].append(t)
         if info["bad"]:
             return "alert", info
         if info["good"]:
@@ -276,7 +292,10 @@ def _http_json(port, path, body=None):
             method = "POST"
         conn.request(method, path, body=payload, headers=headers)
         resp = conn.getresponse()
-        return json.loads(resp.read().decode("utf-8"))
+        data = resp.read()
+        if not 200 <= resp.status < 300:
+            raise RuntimeError("CodeBee API 返回 HTTP %d" % resp.status)
+        return json.loads(data.decode("utf-8"))
     finally:
         conn.close()
 
@@ -405,6 +424,14 @@ class PetApp:
         self.hop_until = 0.0                        # 冒气泡时的蹦跶动作截止
         self.next_chatter = time.time() + random.uniform(90, 240)
         self.seen_digests = 0   # 本轮已通知过的摘要未读数（涨了才报，不重复轰炸）
+        self._polling = False
+        self._poll_results = queue.Queue(maxsize=1)
+        self._settings_lock = threading.Lock()
+        self._settings_pending = {}
+        self._settings_desired = {}
+        self._settings_confirmed = {}
+        self._settings_seq = 0
+        self._settings_worker_running = False
 
         if self.frames:
             self._build_sprite()
@@ -583,10 +610,7 @@ class PetApp:
             return
         self.skin = skin
         self._save_cfg(skin=skin)
-        try:
-            _http_json(self.port, "/api/settings", body={"pet_skin": skin})
-        except Exception:
-            pass
+        self._post_settings({"pet_skin": skin})
         self._rebuild_sprite()
 
     def _rebuild_sprite(self):
@@ -841,16 +865,92 @@ class PetApp:
         else:
             self._show([self.pbar_bg, self.pbar_fg], False)
 
-    # ---- 数据轮询（4s 一拍）----
+    def _post_settings(self, body):
+        """合并并串行发送设置，保证快速连点时最后一次选择最终生效。"""
+        patch = dict(body or {})
+        if not patch:
+            return
+        with self._settings_lock:
+            self._settings_seq += 1
+            seq = self._settings_seq
+            for key, value in patch.items():
+                self._settings_pending[key] = (seq, value)
+                self._settings_desired[key] = (seq, value)
+            if self._settings_worker_running:
+                return
+            self._settings_worker_running = True
+
+        def send():
+            while True:
+                with self._settings_lock:
+                    if not self._settings_pending:
+                        self._settings_worker_running = False
+                        return
+                    current = dict(self._settings_pending)
+                    self._settings_pending.clear()
+                try:
+                    _http_json(self.port, "/api/settings",
+                               body={key: item[1] for key, item in current.items()})
+                    with self._settings_lock:
+                        for key, item in current.items():
+                            self._settings_confirmed[key] = max(
+                                item[0], self._settings_confirmed.get(key, 0))
+                except Exception:
+                    # 新值优先；失败的旧值只补回尚未被新点击覆盖的键。
+                    with self._settings_lock:
+                        for key, item in current.items():
+                            self._settings_pending.setdefault(key, item)
+                    time.sleep(1.0)
+        threading.Thread(target=send, name="pet-settings", daemon=True).start()
+
+    def _reconcile_desired_settings(self, snap, confirmed_at_poll_start):
+        """只覆盖写入确认前已发出的旧轮询；确认后的快照以服务端为准。"""
+        with self._settings_lock:
+            for key, item in list(self._settings_desired.items()):
+                seq, value = item
+                if confirmed_at_poll_start.get(key, 0) >= seq:
+                    del self._settings_desired[key]
+                else:
+                    snap["settings"][key] = value
+
+    # ---- 数据轮询（4s 一拍；网络请求不占 Tk 主线程）----
     def _tick(self):
         self._touch_lock()
-        snap = None
+        if self._polling:
+            return
+        self._polling = True
+        with self._settings_lock:
+            confirmed_at_poll_start = dict(self._settings_confirmed)
+
+        def fetch():
+            snap = None
+            error = None
+            try:
+                snap = parse_snapshot(_http_json(self.port, "/api/pet_state"))
+            except Exception as exc:
+                error = exc
+            try:
+                self._poll_results.put_nowait(
+                    (snap, error, confirmed_at_poll_start))
+            except queue.Full:
+                pass
+
+        threading.Thread(target=fetch, name="pet-poll", daemon=True).start()
+        self.root.after(50, self._collect_poll)
+
+    def _collect_poll(self):
         try:
-            snap = parse_snapshot(_http_json(self.port, "/api/pet_state"))
-            self.miss = 0
-        except Exception:
+            snap, error, confirmed_at_poll_start = self._poll_results.get_nowait()
+        except queue.Empty:
+            self.root.after(50, self._collect_poll)
+            return
+        self._polling = False
+        if error is not None:
             self.miss += 1
+        else:
+            self.miss = 0
         if snap is not None:
+            self._reconcile_desired_settings(snap, confirmed_at_poll_start)
             if not snap["settings"]["pet_enabled"]:
                 return self._bye()
             self.snap = snap
@@ -1187,10 +1287,7 @@ class PetApp:
         return m
 
     def _set_mode(self, mode):
-        try:
-            _http_json(self.port, "/api/settings", body={"pet_mode": mode})
-        except Exception:
-            pass
+        self._post_settings({"pet_mode": mode})
 
     def _set_lang(self, lang):
         self.lang = lang

package/app/ui/app.js

@@ -297,6 +297,93 @@ function urlAuth(u) {
 }
 
 /* ---------------------------------------------------------- 工具 */
+let _requestBusyCount = 0;
+let _lastActionButton = null;
+let _lastActionAt = 0;
+const _requestBusyButtons = new WeakMap();
+
+/* 记录发起请求的按钮。写请求统一在 api() 里挂忙碌态，避免每个业务入口各写一套；
+ * 确认框的按钮不覆盖原始操作按钮，但会续期，使“确认后执行”仍反馈在原按钮上。 */
+document.addEventListener("click", (e) => {
+  const btn = e.target && e.target.closest ? e.target.closest("button") : null;
+  if (!btn) return;
+  if (btn.classList.contains("request-busy")) {
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    return;
+  }
+  _lastActionAt = performance.now();
+  if (!btn.closest("#ask")) _lastActionButton = btn;
+}, true);
+
+function requestBusyStart(opts) {
+  const method = String((opts && opts.method) || "GET").toUpperCase();
+  if (opts && opts.busy === false) return null;
+  if ((method === "GET" || method === "HEAD") && !(opts && opts.busy)) return null;
+
+  _requestBusyCount++;
+  let bar = $("request-progress");
+  if (!bar && document.body) {
+    bar = document.createElement("div");
+    bar.id = "request-progress";
+    bar.className = "request-progress";
+    bar.setAttribute("role", "status");
+    bar.setAttribute("aria-label", t("操作处理中"));
+    bar.setAttribute("aria-hidden", "true");
+    document.body.appendChild(bar);
+  }
+  if (bar) {
+    bar.classList.add("active");
+    bar.setAttribute("aria-hidden", "false");
+  }
+
+  let btn = opts && opts.busyElement;
+  if (typeof btn === "string") btn = document.querySelector(btn);
+  if (!btn && performance.now() - _lastActionAt < 2000) btn = _lastActionButton;
+  if (!btn || !document.documentElement.contains(btn)) btn = null;
+  if (btn) {
+    let state = _requestBusyButtons.get(btn);
+    if (!state) {
+      state = {
+        count: 0,
+        ariaBusy: btn.getAttribute("aria-busy"),
+        ariaDisabled: btn.getAttribute("aria-disabled"),
+      };
+      _requestBusyButtons.set(btn, state);
+    }
+    state.count++;
+    btn.classList.add("request-busy");
+    btn.setAttribute("aria-busy", "true");
+    btn.setAttribute("aria-disabled", "true");
+  }
+  return { button: btn };
+}
+
+function requestBusyEnd(token) {
+  if (!token) return;
+  _requestBusyCount = Math.max(0, _requestBusyCount - 1);
+  const btn = token.button;
+  const state = btn && _requestBusyButtons.get(btn);
+  if (state) {
+    state.count--;
+    if (state.count <= 0) {
+      btn.classList.remove("request-busy");
+      if (state.ariaBusy === null) btn.removeAttribute("aria-busy");
+      else btn.setAttribute("aria-busy", state.ariaBusy);
+      if (state.ariaDisabled === null) btn.removeAttribute("aria-disabled");
+      else btn.setAttribute("aria-disabled", state.ariaDisabled);
+      _requestBusyButtons.delete(btn);
+    }
+  }
+  if (_requestBusyCount === 0) {
+    const bar = $("request-progress");
+    if (bar) {
+      bar.classList.remove("active");
+      bar.setAttribute("aria-hidden", "true");
+    }
+  }
+}
+
 async function api(path, opts) {
   opts = opts || {};
   // 可选超时：长请求（如外部插件下载）传 opts.timeout，网络卡死时也能
@@ -306,21 +393,30 @@ async function api(path, opts) {
     ctrl = new AbortController();
     var timer = setTimeout(() => ctrl.abort(), opts.timeout);
   }
-  let res;
+  const busyToken = requestBusyStart(opts);
+  const fetchOpts = Object.assign({}, opts);
+  delete fetchOpts.timeout;
+  delete fetchOpts.busy;
+  delete fetchOpts.busyElement;
   try {
-    res = await fetch(path, Object.assign({ headers: authHeaders() }, opts, ctrl ? { signal: ctrl.signal } : {}));
-  } catch (e) {
-    if (ctrl && e.name === "AbortError") throw new Error(t("请求超时，请重试或检查网络"));
-    throw e;
+    let res;
+    try {
+      res = await fetch(path, Object.assign({ headers: authHeaders() }, fetchOpts,
+        ctrl ? { signal: ctrl.signal } : {}));
+    } catch (e) {
+      if (ctrl && e.name === "AbortError") throw new Error(t("请求超时，请重试或检查网络"));
+      throw e;
+    }
+    if (res.status === 401) { showTokenGate(t("令牌不正确或已更换，请重新输入")); throw new Error(t("需要访问令牌")); }
+    let data = null;
+    try { data = await res.json(); } catch (e) { /* ignore */ }
+    if (res.status === 423 && data && data.control) setControl(data.control);
+    if (!res.ok) throw new Error((data && data.error) || ("HTTP " + res.status));
+    return data;
   } finally {
     if (timer) clearTimeout(timer);
+    requestBusyEnd(busyToken);
   }
-  if (res.status === 401) { showTokenGate(t("令牌不正确或已更换，请重新输入")); throw new Error(t("需要访问令牌")); }
-  let data = null;
-  try { data = await res.json(); } catch (e) { /* ignore */ }
-  if (res.status === 423 && data && data.control) setControl(data.control);
-  if (!res.ok) throw new Error((data && data.error) || ("HTTP " + res.status));
-  return data;
 }
 
 /* 轻提示：3.5s 自动消失 */
@@ -783,7 +879,7 @@ async function ctrlClick() {
 function startCtrlHeartbeat() {
   setInterval(() => {
     if (S.control && S.control.mine) {
-      api("/api/control/heartbeat", { method: "POST", body: "{}" })
+      api("/api/control/heartbeat", { method: "POST", body: "{}", busy: false })
         .then((d) => setControl(d.control)).catch(() => {});
     }
   }, 15000);
@@ -1687,7 +1783,7 @@ async function openImportDialog() {
     '<button class="ghost" onclick="closeModal()">' + t("取消") + '</button>');
   let data;
   try {
-    data = await api("/api/models/sources");
+    data = await api("/api/models/sources", { busy: true });
   } catch (e) {
     $("modal-body").innerHTML = '<div class="msg bad">' + t("扫描失败：") + esc(e.message) + "</div>";
     return;
@@ -2586,7 +2682,7 @@ async function retryTask(id) {
 async function continueSerial(id) {
   let info;
   try {
-    info = await api("/api/tasks/" + encodeURIComponent(id) + "/continue-info");
+    info = await api("/api/tasks/" + encodeURIComponent(id) + "/continue-info", { busy: true });
   } catch (e) { toast(t("无法续写：") + e.message, true); return; }
   if (!info || !info.can) {
     toast(t("无法续写：") + ((info && info.reason) || t("当前状态不支持")), true);
@@ -6378,6 +6474,7 @@ function bindVoiceInput() {
         if (e.results[i].isFinal) text += e.results[i][0].transcript;
       }
       if (text) {
+        text = voiceFixup(text);
         ta.value = (ta.value ? ta.value.replace(/\s+$/, "") + " " : "") + text;
         ta.dispatchEvent(new Event("input", { bubbles: true }));
       }
@@ -6389,6 +6486,24 @@ function bindVoiceInput() {
   });
 }
 
+/* 语音识别结果纠偏（借鉴 lexicon 个人词典）：设置里维护的专有名词表
+ * （localStorage orch.voice_terms，一行一个「错误→正确」或直接「术语」），
+ * 识别结果做逐词替换。人名/书名/项目名是识别高频错位，词表是最小可用解。 */
+function voiceFixup(text) {
+  let terms = [];
+  try {
+    const raw = localStorage.getItem("orch.voice_terms") || "";
+    terms = raw.split("\n").map((l) => l.trim()).filter(Boolean);
+  } catch (e) {}
+  for (const t of terms) {
+    const m = t.split("→");
+    if (m.length === 2 && m[0].trim() && m[1].trim()) {
+      text = text.split(m[0].trim()).join(m[1].trim());
+    }
+  }
+  return text;
+}
+
 /* ---------------------------------------------------------- 外观：皮肤 + 明暗（换肤） */
 /* 调色板全部在 style.css（html[data-skin="X"]，每套含夜间/日间两版变量）；这里只放顺序
  * 与文案。卡片预览色块用 skinPalette 从 CSS 变量实时取值，不在 JS 里重复写色值——
@@ -6796,7 +6911,7 @@ function updateChip(c) {
 async function autoCheckUpdates() {
   if (Date.now() - (S.updateCheckAt || 0) < 5 * 60 * 1000) return;
   S.updateCheckAt = Date.now();
-  try { await api("/api/catalog/check-updates", { method: "POST" }); } catch (e) { /* 忽略 */ }
+  try { await api("/api/catalog/check-updates", { method: "POST", busy: false }); } catch (e) { /* 忽略 */ }
   poll();
 }
 
@@ -6954,7 +7069,7 @@ async function autoRebindSoon() {
       if (!act) continue;
       const b = (S.bindings || {})[c.id] || {};
       try {
-        await api("/api/models/binding", { method: "POST", body: JSON.stringify({
+        await api("/api/models/binding", { method: "POST", busy: false, 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 }) });
@@ -8882,7 +8997,7 @@ function suLastUpgradeRun() {
 
 async function loadSelfupdate(force) {
   try {
-    SU = await api("/api/selfupdate" + (force ? "?force=1" : ""));
+    SU = await api("/api/selfupdate" + (force ? "?force=1" : ""), { busy: !!force });
   } catch (e) { SU = null; }
   renderSu();
   maybeWhatsnew();
@@ -9198,6 +9313,7 @@ async function savePetSkin(skin) {
 async function exportDiagBundle() {
   const b = $("diag-export");
   if (b) b.disabled = true;
+  const busyToken = requestBusyStart({ method: "GET", busy: true, busyElement: b });
   try {
     const r = await fetch("/api/diagnostics/bundle", { headers: authHeaders() });
     if (!r.ok) throw new Error("HTTP " + r.status);
@@ -9213,6 +9329,7 @@ async function exportDiagBundle() {
   } catch (e) {
     toast(t("诊断包导出失败：") + e.message, true);
   } finally {
+    requestBusyEnd(busyToken);
     if (b) b.disabled = false;
   }
 }
@@ -9220,7 +9337,7 @@ async function exportDiagBundle() {
 /* 一键反馈 Issue：拉脱敏摘要 → 预填 GitHub Issue 新建页（用户亲手提交，不自动回传） */
 async function reportIssue() {
   try {
-    const s = await api("/api/diagnostics/issue-summary");
+    const s = await api("/api/diagnostics/issue-summary", { busy: true });
     const url = "https://github.com/Vercel-By-WXP/CodeBee/issues/new" +
       "?title=" + encodeURIComponent(s.title || "") +
       "&body=" + encodeURIComponent(s.body || "");

package/app/ui/i18n.js

@@ -1273,6 +1273,7 @@
     "安装中…": "Installing…",
     "正在下载安装，插件包较大时需要约一分钟…": "Downloading and installing — large plugin packages can take about a minute…",
     "请求超时，请重试或检查网络": "Request timed out — try again or check your network",
+    "操作处理中": "Working on it",
     "该插件含脚本/钩子/MCP 组件，仅支持纯技能类插件": "Contains scripts/hooks/MCP components — only pure skill plugins are supported",
     " 个供应商（google 等协议）仅登记，不支持注入 CLI，未出现在上面的下拉中。": " provider(s) (google etc.) are registry-only, can't inject into CLIs, and are hidden from the dropdown above.",
     " 个降级备选）。": " fallback(s)).",