codebee 0.1.34 → 0.1.36

package/app/core/portscan.py

@@ -5,7 +5,9 @@
 - **端口→进程→项目归属推断**：netstat/ss 拿端口→PID，再从进程 CWD 向上走找
   .git/package.json 等项目根——知道该进程属于哪个项目/用户
 - **本地 vs LAN 区分**：127.0.0.1 与 0.0.0.0/LAN 的安全边界
-- **温和关闭**：SIGTERM only（Windows taskkill /PID 不带 /F），关闭前重验 PID
+- **温和关闭、强杀兜底**：先 SIGTERM（Windows taskkill /PID 不带 /F）并
+  验证端口真的释放；控制台/服务进程对 WM_CLOSE 无反应，温和无效升级
+  强杀，终裁以端口释放为准（关闭前/强杀前都重验 PID）
 
 跨平台（Windows netstat + PowerShell / POSIX ss + /proc）纯标准库。
 """
@@ -15,7 +17,9 @@ import json
 import logging
 import os
 import re
+import signal
 import subprocess
+import time
 
 log = logging.getLogger(__name__)
 
@@ -156,8 +160,46 @@ def listening_ports(with_names=True):
     return _ports_linux()
 
 
+def _held_by(port, pid):
+    """端口当前是否仍被指定 PID 监听（轻量扫描，不起 PowerShell）。"""
+    return any(pp["port"] == int(port) and pp["pid"] == int(pid)
+               for pp in listening_ports(with_names=False))
+
+
+def _wait_release(port, pid, deadline_s):
+    """轮询等待该 PID 释放端口；释放即 True，超时 False。"""
+    end = time.time() + deadline_s
+    while True:
+        if not _held_by(port, pid):
+            return True
+        if time.time() >= end:
+            return False
+        time.sleep(0.3)
+
+
+def _win_force_kill(pid):
+    """Windows 强杀：TerminateProcess 直杀根进程（os.kill 的 SIGTERM 语义，
+    毫秒级不挂），taskkill /F /T 短等待兜底扫子孙（同 runner._kill_tree 策略；
+    taskkill 病态挂死时靠 timeout 放弃，不拖死调用方）。"""
+    try:
+        os.kill(pid, signal.SIGTERM)   # Windows 语义 = TerminateProcess
+    except OSError:
+        pass                           # 可能已被温和信号杀掉
+    try:
+        subprocess.run(["taskkill", "/F", "/T", "/PID", str(pid)],
+                       timeout=8, capture_output=True)
+    except Exception:
+        pass                           # 兜底失败不阻塞终裁验证
+
+
 def close_port(port):
-    """温和关闭端口上的进程。返回 (ok, message)。关闭前重验 PID 绑定。"""
+    """关闭端口上的进程。返回 (ok, message)。
+
+    温和优先（POSIX SIGTERM / Windows WM_CLOSE）并验证端口真的释放。控制台/
+    服务进程对 WM_CLOSE 无反应，taskkill 不带 /F 对它们必败——2026-09-21
+    用户实测「扫描端口后关不掉」根因，且旧实现不看返回码假报成功。因此：
+    温和无效升级强杀，强杀前重验同一 PID 仍监听（防 PID 复用误杀），终裁
+    以端口释放为准，绝不假报成功。"""
     for p in listening_ports():
         if p["port"] != port:
             continue
@@ -169,20 +211,32 @@ def close_port(port):
         if p.get("process", "").lower() in _SYSTEM_PROCS:
             return False, "系统服务，不关闭"
         # 重验 PID 仍在监听该端口（防 PID 复用竞态）；轻量扫描省掉 PowerShell
-        still = any(pp["port"] == port and pp["pid"] == pid
-                    for pp in listening_ports(with_names=False))
-        if not still:
+        if not _held_by(port, pid):
             return False, "PID %d 已不在端口 %d 上监听（竞态）" % (pid, port)
         if os.name == "posix":
             try:
                 os.kill(pid, 15)   # SIGTERM
-                return True, "已发送 SIGTERM（PID %d）" % pid
             except OSError as e:
                 return False, str(e)[:160]
-        try:
-            subprocess.run(["taskkill", "/PID", str(pid)],
-                           timeout=10, capture_output=True)
-            return True, "已发送关闭信号（PID %d）" % pid
-        except Exception as e:
-            return False, str(e)[:160]
+        else:
+            try:
+                subprocess.run(["taskkill", "/PID", str(pid)],
+                               timeout=10, capture_output=True)
+            except Exception:
+                pass               # 温和失败不在此定论，交给验证+升级
+        if _wait_release(port, pid, 3):
+            return True, "已关闭（PID %d），端口 %d 已释放" % (pid, port)
+        # 温和无效（无窗口进程拒收 WM_CLOSE / 忽略 SIGTERM）→ 升级强杀
+        if not _held_by(port, pid):
+            return True, "已关闭（PID %d），端口 %d 已释放" % (pid, port)
+        if os.name == "posix":
+            try:
+                os.kill(pid, 9)    # SIGKILL
+            except OSError as e:
+                return False, str(e)[:160]
+        else:
+            _win_force_kill(pid)
+        if _wait_release(port, pid, 3):
+            return True, "温和信号无效，已强制结束（PID %d），端口 %d 已释放" % (pid, port)
+        return False, "PID %d 未响应关闭，端口 %d 仍被监听，请手动处理" % (pid, port)
     return False, "端口 %d 未找到监听进程" % port

package/app/core/skills.py

@@ -391,17 +391,25 @@ def relevance_top(lessons, task, limit):
     if not probe:
         return lessons[:limit]
 
-    # 使用反馈闭环（pmb「量化记忆真实帮助」借鉴）：被选中次数多的教训排前
+    # 使用反馈闭环（pmb「量化记忆真实帮助」+ tradememory「按结局加权召回」）：
+    # 相关性优先；同分比 outcome 胜负（注入后任务过审 +1 / 未过 -1），再比 hits。
     def rank(x):
         grams = _text_bigrams(x.get("title")) | _text_bigrams(x.get("content"))
         overlap = -len(probe & grams)
+        karma = int(x.get("won") or 0) - int(x.get("lost") or 0)
         lid = x.get("id") or ""
-        return (overlap, -int(x.get("hits") or 0), lid)
+        return (overlap, -karma, -int(x.get("hits") or 0), lid)
 
     return sorted(lessons, key=rank)[:limit]
 
 
-def block_for(task, scope_override=None, *, stable_order=False):
+# 运行级注入登记（outcome 加权用）：run_id → 注入的教训 id 列表。
+# 容量有界防泄漏；run 收尾 learn_from_run 时消费清除。
+_INJECTED = {}
+_INJECTED_MAX = 200
+
+
+def block_for(task, scope_override=None, *, stable_order=False, run_id=None):
     """生成注入提示词的经验块。命中即计数。返回 (文本, 命中的 id 列表)。
 
     3A：内置包 + 用户自建包都参与 scope 匹配；3B：带 persona 的包先注入
@@ -414,6 +422,9 @@ def block_for(task, scope_override=None, *, stable_order=False):
     39 个全文注入会先把 9000 字全局上限吃光，项目教训排在末尾被整段截掉。
     两道预算：①wildcard 包单包限额（定向命中的包不受限）；②教训保底——
     包区最多吃到「全局上限 − 教训长度」，教训永远完整注入。
+
+    run_id（tradememory 借鉴·outcome 加权）：登记本次注入的教训，run 收尾
+    按结局（过审 +1 / 未过 -1）回写 won/lost——好教训在排序中胜出。
     """
     scope = scope_override or task.get("type") or "*"
     parts, used, lesson_ids = [], [], []
@@ -464,9 +475,35 @@ def block_for(task, scope_override=None, *, stable_order=False):
         text = text[:MAX_INJECT_CHARS] + "\n…（已截断）"
     if lesson_ids:
         bump_hits(lesson_ids)  # 包 id 不参与教训热度，命中数据只保留一份真源
+        if run_id:
+            with _LOCK:
+                if len(_INJECTED) >= _INJECTED_MAX:
+                    _INJECTED.clear()   # 有界兜底：登记超量整体作废（丢信号不丢内存）
+                _INJECTED[str(run_id)] = list(lesson_ids)
     return text, used
 
 
+def note_outcome(run_id, passed):
+    """run 收尾回写注入教训的胜负（tradememory outcome 加权）。
+
+    passed=True → won+1（这条教训在场时任务过审）；False → lost+1。
+    只清算登记在案的教训；幂等（同一 run 消费后清除登记）。"""
+    rid = str(run_id or "")
+    if not rid:
+        return
+    with _LOCK:
+        ids = _INJECTED.pop(rid, None)
+        if not ids:
+            return
+        data = _load()
+        idset = set(ids)
+        for it in (data.get("lessons") or []):
+            if it.get("id") in idset:
+                key = "won" if passed else "lost"
+                it[key] = int(it.get(key) or 0) + 1
+        _save(data)
+
+
 def bump_hits(ids):
     ids = [i for i in (ids or []) if i]
     if not ids:
@@ -569,6 +606,14 @@ def learn_from_run(run_id, use_orchestrator=True):
     run = store.get_run(run_id)
     if not run:
         return 0
+    # outcome 加权（tradememory）：本 run 注入过的教训按结局记胜负——
+    # 失败 run 说明在场教训没防住这个问题（lost+1），过审则 won+1。
+    # 放最前：无论后续是否沉淀新教训，胜负都要落账。
+    try:
+        verdict = run.get("verdict") or {}
+        note_outcome(run_id, bool(verdict.get("pass")))
+    except Exception:
+        pass
     task = store.get_task(run.get("task_id")) if run.get("task_id") else None
     if not task:
         return 0

package/app/core/zentao.py

@@ -620,6 +620,33 @@ def _pairs_to_list(pairs, id_key, name_key):
     return out
 
 
+def _module_items(d):
+    """老版模块树形状兼容（2026-09-21 真机反馈「响应形状不认识」）：
+    sons/modules 数组、{id: {name,...}} 字典、children/sons 嵌套树，统一
+    递归展开成 [{id,name}] 平铺清单（id=0 是树根容器，跳过）。"""
+    out = []
+
+    def walk(node):
+        if isinstance(node, list):
+            for x in node:
+                walk(x)
+        elif isinstance(node, dict):
+            if node.get("id") not in (None, "", 0):
+                out.append(node)
+                for k in ("children", "sons"):
+                    if isinstance(node.get(k), (list, dict)):
+                        walk(node[k])
+            else:
+                for v in node.values():
+                    walk(v)
+
+    if isinstance(d, dict):
+        walk(d.get("sons") or d.get("modules") or d.get("tree") or d)
+    elif isinstance(d, list):
+        walk(d)
+    return out
+
+
 def _old_route(api, method, p, q, body):
     """路径翻译 + 请求 + 归一。会话死抛 _OldSessionDead。"""
 
@@ -698,16 +725,14 @@ def _old_route(api, method, p, q, body):
     m = re.match(r"^/products/(\d+)/modules$", p)
     if m and method == "GET":
         d = go(get("/tree-browse-%s-module.json" % m.group(1)), "（拉模块清单）")
-        items = []
-        if isinstance(d, dict):
-            items = d.get("sons") or d.get("modules") or []
-        elif isinstance(d, list):
-            items = d
-        return {"_list": [x for x in items if isinstance(x, dict) and x.get("id")]}
+        return {"_list": [x for x in _module_items(d) if isinstance(x, dict) and x.get("id")]}
 
     if p == "/products" and method == "GET":
         d = go(get("/api-getmodel-product-getpairs.json"), "（拉产品清单）")
-        pairs = d.get("products") if isinstance(d, dict) and isinstance(d.get("products"), dict) else d
+        prods = d.get("products") if isinstance(d, dict) else None
+        if isinstance(prods, list):     # 部分老版回数组形状 [{id,name,...}]
+            return {"_list": [x for x in prods if isinstance(x, dict) and x.get("id")]}
+        pairs = prods if isinstance(prods, dict) else d
         return {"_list": _pairs_to_list(pairs, "id", "name")}
 
     if p == "/users" and method == "GET":

package/app/pet.py

@@ -1090,7 +1090,8 @@ class PetApp:
             dg = snap.get("digest") or {}
             self.seen_digests, notify = digest_alert(self.seen_digests, dg)
             if notify:
-                self._show_bubble(digest_bubble_text(dg, self.lang), secs=9.0)
+                self._show_bubble(digest_bubble_text(dg, self.lang), secs=9.0,
+                                  action="digest")
                 self.last_busy = now
                 if st == "sleep":
                     self.mood_kind, self.mood_until = "cheer", now + MOOD_HOLD_S
@@ -1257,8 +1258,14 @@ class PetApp:
             self._tip_body = tk.Label(tip, text="", bg="#1B2430",
                                       fg="#ECF2F8",
                                       font=("Microsoft YaHei UI", 9),
-                                      justify="left", wraplength=280)
+                                      justify="left", wraplength=280,
+                                      cursor="hand2")
             self._tip_body.pack(anchor="w", padx=10, pady=(2, 8))
+            # 点清单即打开网页（含群摘要「点我细看」行——此前清单窗没有任何
+            # 点击绑定，文案写着「点我细看」点了却没反应，用户实测反馈）
+            for w in (self._tip_head, self._tip_body):
+                w.bind("<ButtonPress-1>",
+                       lambda e: self._open_ui("#goto=__wxdigest"))
             self._tip = tip
         self._tip_update()
         try:
@@ -1312,11 +1319,14 @@ class PetApp:
             text = self._L("alert") % bad.get("title", "?")
         self._show_bubble(text)
 
-    def _show_bubble(self, text, secs=5.0, force=False):
+    def _show_bubble(self, text, secs=5.0, force=False, action=""):
+        """action：气泡承诺的「点我细看」要兑现（2026-09-21 用户实测点不动——
+        气泡窗口没绑点击，蜜蜂左键也只开首页）。digest=直达群摘要页。"""
         if not force and time.time() < self.quiet_until:
             return   # 「安静一会」期间不碎碎念（系统确认语用 force 放行）
         self._destroy_win("_bubble")
         self.hop_until = time.time() + 0.7   # 冒泡蹦一下，像在说话
+        self._bubble_action = action
         tk = self.tk
         bub = tk.Toplevel(self.root)
         bub.overrideredirect(True)
@@ -1324,10 +1334,14 @@ class PetApp:
             bub.attributes("-topmost", True)
         except Exception:
             pass
-        tk.Label(bub, text=text, bg="#FFF8E1", fg="#4A3200",
-                 bd=1, relief="solid",
-                 font=("Microsoft YaHei UI", 9), justify="left",
-                 wraplength=230, padx=8, pady=5).pack()
+        lab = tk.Label(bub, text=text, bg="#FFF8E1", fg="#4A3200",
+                       bd=1, relief="solid",
+                       font=("Microsoft YaHei UI", 9), justify="left",
+                       wraplength=230, padx=8, pady=5, cursor="hand2")
+        lab.pack()
+        # 气泡本体可点：点了按承诺跳转（点蜜蜂也走同一逻辑，见 _on_release）
+        for w in (bub, lab):
+            w.bind("<Button-1>", lambda e: self._bubble_click())
         x = self.root.winfo_x() + self.win_w - 40
         y = max(0, self.root.winfo_y() - 8)
         bub.update_idletasks()
@@ -1338,6 +1352,29 @@ class PetApp:
         self._bubble_until = time.time() + secs
         self.root.after(int(secs * 1000), self._hide_bubble)
 
+    def _bubble_action_live(self):
+        """最近一条气泡是否还在展示期且带跳转承诺。"""
+        if time.time() > getattr(self, "_bubble_until", 0):
+            return ""
+        return getattr(self, "_bubble_action", "") or ""
+
+    def _bubble_click(self):
+        # 点了立刻消失并清展示期（_hide_bubble 是到点才收的延迟逻辑，别用）；
+        # 先记 action 再清——_open_by_bubble_action 读的就是这个展示期
+        action = self._bubble_action_live()
+        self._destroy_win("_bubble")
+        self._bubble_until = 0
+        if action == "digest":
+            self._open_digest()
+        else:
+            self._open_ui()
+
+    def _open_by_bubble_action(self):
+        if self._bubble_action_live() == "digest":
+            self._open_digest()
+        else:
+            self._open_ui()
+
     def _hide_bubble(self):
         if time.time() < self._bubble_until:
             self.root.after(500, self._hide_bubble)
@@ -1476,7 +1513,8 @@ class PetApp:
             self._clamp_pos()
             self._save_cfg(x=self.root.winfo_x(), y=self.root.winfo_y())
         else:
-            self._open_ui()
+            # 展示期内气泡承诺过「点我细看」就兑现（digest 直达），否则开首页
+            self._open_by_bubble_action()
 
     def _bye(self, write_setting=False):
         """退出。write_setting=True（右键菜单「关闭桌宠」）先把 pet_enabled=False

package/app/ui/app.js

@@ -59,7 +59,9 @@ function renderTypeOptions() {
   const prev = sel.value;  sel.innerHTML = (S.flows || []).map((f) => {
     return '<option value="' + esc(f.id) + '">' + esc(t(f.name)) + t("（") + flowDesc(f) + (f.builtin ? "" : t(" · 自定义")) + t("）") + "</option>";
   }).join("");
-  if (prev && flowById(prev)) sel.value = prev;
+  // 保住用户手动选择（typeTouched）；出厂默认 direct 不算选择——prefs 迟到
+  // 竞态下要让位给偏好记忆，否则「上次类型」永远恢复不了（高负载下实测）
+  if (prev && flowById(prev) && (S.typeTouched || prev !== "direct")) sel.value = prev;
   // 偏好记忆：上次创建用的类型优先于出厂默认「直接执行」（老数据/已删流程回落）
   else if (S.lastPrefs && S.lastPrefs.type && flowById(S.lastPrefs.type)) sel.value = S.lastPrefs.type;
   // 首屏默认落在「直接执行」（快档位：单 CLI 直达，无拆解/评审）；
@@ -153,6 +155,7 @@ function toggleTypeMenu(force) {
 }
 
 function pickType(id) {
+  S.typeTouched = true;   // 用户手动选过：flows 重渲染时优先保住，不让位偏好记忆
   const sel = $("f-type");
   if (sel && sel.value !== id) {
     sel.value = id;
@@ -412,6 +415,16 @@ function operationLabel(path, opts) {
     [/\/market\//, "更新插件"],
     [/\/models\/binding$/, "更新智能体绑定"],
     [/\/models\//, "更新模型配置"],
+    [/\/zentao\/test$/, "测试禅道连接"],
+    [/\/zentao\/products$/, "拉取禅道产品"],
+    [/\/zentao\/users$/, "拉取禅道账号"],
+    [/\/zentao\/modules$/, "拉取模块清单"],
+    [/\/zentao\/scan$/, "禅道扫描 Bug"],
+    [/\/zentao\/config$/, "保存禅道配置"],
+    [/\/wxdigest\/groups$/, "刷新群列表"],
+    [/\/wxdigest\/scan$/, "扫描群摘要"],
+    [/\/wxdigest\/config$/, "保存群摘要设置"],
+    [/\/ports\/close$/, "关闭端口进程"],
   ];
   const hit = rules.find((it) => it[0].test(clean));
   return t(hit ? hit[1] : "提交操作");
@@ -5733,20 +5746,20 @@ function renderChapterScores(run) {
     cs.map((c) => {
       const means = c.means || {};
       const dims = Object.keys(means).map((d) =>
-        '<span class="cs-dim' + (means[d] >= 7 ? "" : " low") + '">' + esc(d) + " " + means[d] + "</span>").join("");
+        '<span class="ch-dim' + (means[d] >= 7 ? "" : " low") + '">' + esc(d) + " " + means[d] + "</span>").join("");
       const ev = (c.event_check || []).map((line) => {
         const ok = /已完成/.test(line), bad = /未完成/.test(line);
-        return '<div class="cs-ev' + (ok ? " ok" : bad ? " bad" : "") + '">' + esc(line) + "</div>";
+        return '<div class="ch-ev' + (ok ? " ok" : bad ? " bad" : "") + '">' + esc(line) + "</div>";
       }).join("");
-      return '<div class="cs-row' + (c.passed ? "" : " fail") + '">' +
-        '<div class="cs-head"><b>' + esc(t("第") + " " + c.chapter + " " + t("章")) + '</b>' +
-        '<span class="cs-title">' + esc(c.title || "") + "</span>" +
+      return '<div class="ch-row' + (c.passed ? "" : " fail") + '">' +
+        '<div class="ch-head"><b>' + esc(t("第") + " " + c.chapter + " " + t("章")) + '</b>' +
+        '<span class="ch-title">' + esc(c.title || "") + "</span>" +
         '<span class="tag">' + (c.passed ? t("达标") : t("未达标")) + "</span>" +
         (c.reused ? '<span class="tag">' + t("沿用") + "</span>" : "") +
-        '<span class="cs-meta">' + Number(c.words || 0) + t(" 字") +
+        '<span class="ch-meta">' + Number(c.words || 0) + t(" 字") +
         (c.rounds > 1 ? " · " + c.rounds + t(" 轮") : "") + "</span></div>" +
-        (dims ? '<div class="cs-dims">' + dims + "</div>" : "") +
-        (ev ? '<div class="cs-evs"><span class="hint">' + t("逐项目标核对：") + "</span>" + ev + "</div>" : "") +
+        (dims ? '<div class="ch-dims">' + dims + "</div>" : "") +
+        (ev ? '<div class="ch-evs"><span class="hint">' + t("逐项目标核对：") + "</span>" + ev + "</div>" : "") +
         "</div>";
     }).join("");
 }
@@ -8904,14 +8917,14 @@ async function testZentao() {
     }
   }
   if (r.ok) {
-    try {
-      // 测试成功即保存当前连接并拉产品清单，用户无需再理解“先保存再拉取”的顺序。
-      await api("/api/zentao/config", { method: "POST", operation: false,
-        body: JSON.stringify(ztFormPayload()) });
-      await loadZentao();
-      await ztFetchCatalog(true);
-      toast(t("连接成功，已保存；现在可直接从禅道选择产品"));
-    } catch (e) { toast(t("连接成功，但保存配置失败：") + e.message, true); }
+    // 测试成功即保存当前连接；产品/账号清单后台拉（真机禅道慢，await 会把
+    // 确认按钮按住几十秒——「保存为啥要这么久」根因），拉到后下拉自动就位。
+    api("/api/zentao/config", { method: "POST", operation: false,
+      body: JSON.stringify(ztFormPayload()) })
+      .then(() => loadZentao())
+      .catch(() => {});
+    toast(t("连接成功，已保存；正在拉取产品清单…"));
+    ztFetchCatalog(true).catch(() => {});
   }
 }
 
@@ -8959,19 +8972,39 @@ function mkCharsText(n) {
   return t("约 ") + n + " " + t("字");
 }
 
-function mkCardHtml(p) {
+function mkCardHtml(p, section) {
   let ops;
   if (p.builtin) ops = '<button class="ghost small" disabled>' + t("已内置") + "</button>";
   else if (p.installed) ops = '<span class="tag ok">' + t("已安装") + "</span>" +
     '<button class="ghost small" onclick="mkRemove(\'' + esc(p.id) + '\')">' + t("卸载") + "</button>";
   else ops = '<button class="primary small" onclick="mkInstall(\'' + esc(p.id) + '\')">' + t("安装") + "</button>";
+  // 已装插件卡片直接给启停开关（对齐 ZCode 插件管理形态：启停不用去经验库翻）
+  const toggle = p.installed
+    ? '<label class="switch" title="' + (p.enabled ? t("已启用") : t("已停用")) + '">' +
+      '<input type="checkbox"' + (p.enabled ? " checked" : "") +
+      ' onchange="mkTogglePack(\'' + esc(p.id) + '\', this.checked)"></label>'
+    : "";
+  const sec = section ? '<span class="tag mk-sec">' + esc(section) + "</span>" : "";
   return '<div class="card mk-card"><div class="head">' +
     '<span class="name">' + esc(t(p.name)) + "</span>" +
-    '<span class="tag">' + esc(t(p.category || "")) + "</span>" +
+    '<span class="tag">' + esc(t(p.category || "")) + "</span>" + sec +
     "</div>" +
     '<div class="note">' + esc(t(p.desc || "")) + "</div>" +
     '<div class="mk-meta"><span title="' + esc(t("运行该类型任务时自动注入提示词，无需手动调用")) + '">' + t("适用：") + esc(mkScopeText(p.scopes)) + "</span><span>" + esc(mkCharsText(p.chars)) + "</span></div>" +
-    '<div class="ops">' + ops + "</div></div>";
+    '<div class="ops">' + ops + toggle + "</div></div>";
+}
+
+/* 已装插件启停：走经验库包启停（同一条链），停用后该插件不再注入任务提示词 */
+async function mkTogglePack(id, enabled) {
+  try {
+    await api("/api/skills/pack-op", { method: "POST",
+      body: JSON.stringify({ id, op: enabled ? "enable" : "disable" }) });
+    toast(enabled ? t("已启用") : t("已停用（不再注入任务提示词）"));
+    loadMarket();
+  } catch (e) {
+    toast(e.message || t("操作失败"), true);
+    loadMarket();
+  }
 }
 
 function renderMarket() {
@@ -9001,7 +9034,22 @@ function renderMarket() {
     (p.name || "").toLowerCase().indexOf(q) >= 0 || (p.desc || "").toLowerCase().indexOf(q) >= 0);
   const cnt = $("mk-count");
   if (cnt && mkActiveView() === "local") cnt.textContent = t("共 ") + items.length + t(" 个");
-  grid.innerHTML = items.map(mkCardHtml).join("") || '<div class="empty">' + t("没有符合条件插件") + "</div>";
+  // 分区渲染（对齐 ZCode 插件管理形态）：内置 / 已安装 / 可安装三组，
+  // 各组小标题+卡片；「全部」以外状态只出命中的那组
+  if (st === "all" && !cat && !q) {
+    const builtin = items.filter((p) => p.builtin);
+    const inst = items.filter((p) => !p.builtin && p.installed);
+    const avail = items.filter((p) => !p.builtin && !p.installed);
+    const sec = (title, list) => list.length
+      ? '<h3 class="sec-title">' + title + " " + list.length + "</h3>" +
+        '<div class="mk-grid">' + list.map((p) => mkCardHtml(p, t(title))).join("") + "</div>"
+      : "";
+    grid.innerHTML =
+      sec(t("内置"), builtin) + sec(t("已安装"), inst) + sec(t("可安装"), avail) ||
+      '<div class="empty">' + t("没有符合条件插件") + "</div>";
+    return;
+  }
+  grid.innerHTML = items.map((p) => mkCardHtml(p)).join("") || '<div class="empty">' + t("没有符合条件插件") + "</div>";
 }
 
 async function mkInstall(id) {
@@ -9879,10 +9927,10 @@ async function scanPorts() {
 }
 
 async function closePort(port) {
-  if (!confirm(t("向占用端口 %1 的进程发送温和关闭信号？（系统进程会被拒绝）").replace("%1", port))) return;
+  if (!confirm(t("结束占用端口 %1 的进程？先温和关闭，无效会自动强制结束（系统进程会被拒绝）").replace("%1", port))) return;
   try {
     const r = await api("/api/ports/close", { method: "POST", body: JSON.stringify({ port }) });
-    toast(r.message || (r.ok ? t("已发送关闭信号") : t("未能关闭")), !r.ok);
+    toast(r.message || (r.ok ? t("已关闭") : t("未能关闭")), !r.ok);
     scanPorts();
   } catch (e) {
     toast(e.message || t("关闭失败"), true);
@@ -11649,16 +11697,24 @@ async function beeRefreshGroups() {
   const old = btn.textContent;
   btn.textContent = t("刷新中…");
   try {
+    // 后端 refresh_groups 读的是已保存配置的 reader_python；用户选完候选
+    // 直接点刷新（不点保存）时服务端还是旧值——先静默落盘再刷新
+    // （「填了路径仍报请先填」根因）
+    if (!(await beeSaveCore())) { return; }
     const r = await api("/api/wxdigest/groups", { method: "POST", body: "{}", timeout: 180000 });
     if (Bee.view) Bee.view.reader_groups_cache = r.groups || [];
     toast(t("群列表已更新：") + (r.groups || []).length);
   } catch (e) { toast(t("刷新失败：") + (e.message || e), true); }
-  btn.disabled = false;
-  btn.textContent = old;
-  beeRenderGroups();
+  finally {
+    btn.disabled = false;
+    btn.textContent = old;
+    beeRenderGroups();
+  }
 }
 
-async function beeSave() {
+async function beeSaveCore() {
+  /* 把表单当前值落到服务端；成功返回 true，失败已 toast。不碰勾选态
+     （beeSave 的 selGroups 置空依赖随后的 beeRefresh 重建，这里没有）。 */
   try {
     const r = await api("/api/wxdigest/config", { method: "POST", body: JSON.stringify({
       enabled: $("bee-enabled").checked,
@@ -11670,11 +11726,16 @@ async function beeSave() {
       groups: Bee.selGroups || [],
     }) });
     if (Bee.view) Bee.view.config = r.config;
-    Bee.selGroups = null;   // 下次渲染用保存后的值重建勾选态
-    Bee.pyDirty = false;    // 保存成功：服务端值与所见一致，恢复轮询回填
-    toast(t("群摘要设置已保存"));
-    beeRefresh();
-  } catch (e) { toast(t("保存失败：") + (e.message || e), true); }
+    Bee.pyDirty = false;   // 保存成功：服务端值与所见一致，恢复轮询回填
+    return true;
+  } catch (e) { toast(t("保存失败：") + (e.message || e), true); return false; }
+}
+
+async function beeSave() {
+  if (!(await beeSaveCore())) return;
+  Bee.selGroups = null;   // 下次渲染用保存后的值重建勾选态
+  toast(t("群摘要设置已保存"));
+  beeRefresh();
 }
 
 async function beeScan() {
@@ -11682,13 +11743,15 @@ async function beeScan() {
   if (!btn || btn.disabled) return;
   btn.disabled = true;
   try {
+    // 微信直连拉取依赖 reader_python，先静默落盘（同 beeRefreshGroups）
+    if (!(await beeSaveCore())) { return; }
     const r = await api("/api/wxdigest/scan", { method: "POST", body: "{}", timeout: 300000 });
     if (r.ok && r.made) toast(t("扫描完成，生成") + " " + r.made + t(" 条新摘要"));
     else if (r.ok) toast(t("扫描完成，暂无新内容"));
     else toast(t("扫描有问题：") + (r.error || ""), true);
     beeRefresh();
   } catch (e) { toast(t("扫描失败：") + (e.message || e), true); }
-  btn.disabled = false;
+  finally { btn.disabled = false; }
 }
 
 (function () {

package/app/ui/i18n.js

@@ -1281,6 +1281,8 @@
     "约 ": "about ",
     "字": "chars",
     "已内置": "Built-in",
+    "已启用": "Enabled",
+    "已停用（不再注入任务提示词）": "Disabled — no longer injected into task prompts",
     "没有符合条件插件": "No plugins match the filters",
     "该插件已安装过": "Already installed",
     "安装成功，运行任务时自动注入提示词；可到「经验库」启停或查看": "Installed — auto-injected into prompts when tasks run; enable/disable or view it in the skill library",
@@ -1327,6 +1329,16 @@
     "更新插件": "Update plugin",
     "更新模型配置": "Update model settings",
     "更新智能体绑定": "Update agent binding",
+    "测试禅道连接": "Test ZenTao connection",
+    "拉取禅道产品": "Fetch ZenTao products",
+    "拉取禅道账号": "Fetch ZenTao accounts",
+    "拉取模块清单": "Fetch module list",
+    "禅道扫描 Bug": "Scan ZenTao bugs",
+    "保存禅道配置": "Save ZenTao settings",
+    "刷新群列表": "Refresh group list",
+    "扫描群摘要": "Scan digests",
+    "保存群摘要设置": "Save digest settings",
+    "关闭端口进程": "Close port process",
     "提交操作": "Submit operation",
     "{0} 项处理中": "{0} in progress",
     "{0} 项失败": "{0} failed",
@@ -1950,8 +1962,8 @@
     "关闭": "Close",
     "没有发现监听端口": "No listening ports found",
     "扫描失败：": "Scan failed: ",
-    "向占用端口 %1 的进程发送温和关闭信号？（系统进程会被拒绝）": "Send a gentle close signal to the process holding port %1? (system processes are refused)",
-    "已发送关闭信号": "Close signal sent",
+    "结束占用端口 %1 的进程？先温和关闭，无效会自动强制结束（系统进程会被拒绝）": "Kill the process holding port %1? Gentle close first, forced kill if ignored (system processes are refused)",
+    "已关闭": "Closed",
     "未能关闭": "Could not close",
     "关闭失败": "Close failed",