codebee 0.1.25 → 0.1.27

package/CHANGELOG.md

@@ -6,6 +6,28 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 
 ## 未发布
 
+## v0.1.27（2026-09-21）
+
+### ✨ 新功能
+
+- 连载任务防穿帮：新增「资源账本」——每章评审自动登记新出现的道具、伤情、承诺与伏笔，写下一章前自动注入提醒核对，角色不会上一章断臂下一章就挥剑。
+- 连载评审逐项核对：每章按大纲要点逐项判定「已完成/未完成/待核实」并引用正文证据，铺垫不再被当成已完成。
+- 新建任务记住你的偏好：上次选择的任务类型、轮数、阈值、章节数等下次自动预填（只记参数，不记内容）。
+
+### 🛠 问题修复
+
+- 代码任务提速：验证命令失败时先直接修复再评审（首轮不再白跑一次评审），连续失败两轮后才请评审参与诊断。
+
+## v0.1.26（2026-09-21）
+
+### ✨ 新功能
+
+- 顶栏新增统一操作状态中心：创建、删除、绑定、插件等用户写操作会显示进行中、完成或失败状态，并保留时间与错误原因，慢请求不再像页面卡死。
+
+### 🛠 问题修复
+
+- 后台维护写请求、任务澄清探测和轮询请求默认静默，避免把后台动作误显示成用户操作；移动端状态弹层自适应屏幕并支持减少动画。
+
 ## v0.1.25（2026-09-21）
 
 ### ✨ 新功能

package/README.md

@@ -23,6 +23,27 @@ Kimi Code、MiMo Code、Grok Build、Pi、DeepSeek Harness……），提供
 <!-- relnotes:start -->
 ### ✨ 新功能 · New
 
+- 连载任务防穿帮：新增「资源账本」——每章评审自动登记新出现的道具、伤情、承诺与伏笔，写下一章前自动注入提醒核对。
+- Serial tasks now keep a resource ledger: props, injuries, promises, and plot threads are tracked per chapter and injected before writing the next one.
+
+- 连载评审逐项核对：每章按大纲要点逐项判定「已完成/未完成/待核实」并引用正文证据，铺垫不再被当成已完成。
+- Chapter reviews now check every outline beat against the actual text — foreshadowing no longer counts as done.
+
+- 新建任务记住你的偏好：上次选择的任务类型、轮数、阈值、章节数等下次自动预填（只记参数，不记内容）。
+- The new-task form now remembers your last-used type, rounds, threshold, and chapter settings (parameters only, never content).
+
+### 🛠 问题修复 · Fixes
+
+- 代码任务提速：验证命令失败时先直接修复再评审（首轮不再白跑一次评审），连续失败两轮后才请评审参与诊断。
+- Code tasks get faster: when verification fails, the agent fixes first and review joins only after repeated failures.
+
+### 上一版亮点 · Previous release
+
+- 顶栏新增统一操作状态中心：创建、删除、绑定、插件等写操作会显示进行中、完成或失败状态，并保留时间与错误原因。
+- A unified operation center now shows create, delete, binding, and plugin actions as running, completed, or failed, with timestamps and error details.
+
+### 上一版亮点 · Previous release
+
 - 文档类任务更专业：汇报先给结论、邮件先答复再铺陈、技术方案从问题开场并保留被否决的真实备选、文档验收标准可逐条勾选。
 - Smarter document tasks: reports lead with conclusions, emails answer first, proposals open at the problem and keep a real rejected alternative, docs get testable acceptance criteria.
 

package/app/core/modelhub.py

@@ -2784,6 +2784,7 @@ def test_model(provider_id, model_name, key_id=""):
 # 这类网关两种 wire 挂在不同路径，同 base 探测必 404，只能按已知映射补候选。
 _KNOWN_WIRE_BASES = (
     (("api.z.ai",), "/api/anthropic", "https://api.z.ai/api/paas/v4"),
+    (("open.bigmodel.cn",), "/api/anthropic", "https://open.bigmodel.cn/api/paas/v4"),
 )
 
 

package/app/core/pipeline.py

@@ -1091,10 +1091,25 @@ def _run_code(run, task, agents, ev, stats, mode):
 
     def review_and_score():
         verify_pass, verify_ran = _run_verify(run_id, task, workdir, ev)
+        # gate 验证（借鉴 pi-subagents 的 gate:"npm test"）：verify 失败时先跳过
+        # 模型评审直接进修复轮——评审此时只能复述「验证没过」，白烧一次调用。
+        # 连续失败 >=2 轮后恢复评审参与诊断（模型能看出编译错误之外的病灶）。
+        if not verify_pass and verify_ran:
+            verify_fail_streak[0] += 1
+            if verify_fail_streak[0] < 2:
+                return {"pass": False, "scores": {},
+                        "issues": [{"severity": "high", "title": "验证命令未通过",
+                                    "detail": "验证命令 `%s` 未通过：先修复使验证转绿，无需等评审。"
+                                              % task.get("verify_command")}],
+                        "summary": "gate：验证未通过，跳过模型评审直接修复"}, verify_pass, verify_ran
+        else:
+            verify_fail_streak[0] = 0
         # 先让确定性验证落盘，再执行模型评审；终态判断会同时使用两份证据。
         review_json = _run_review(run_id, task, workdir, modelhub.bind_agent(reviewer, difficulty), ev)
         return review_json, verify_pass, verify_ran
 
+    verify_fail_streak = [0]   # gate：verify 连败计数（>=2 轮恢复评审参与诊断）
+
     attempt_note = route.get("implementer", "") if mode == "auto" else ""
     round_no = 0
     review_json, verify_pass, verify_ran = None, True, False
@@ -1707,6 +1722,43 @@ def _plot_modules(workdir):
             "鼓励化用，不要照抄原句）\n\n" + txt)
 
 
+LEDGER_FILE = os.path.join(".codebee", "resource-ledger.md")
+_LEDGER_MAX_CHARS = 6000   # 账本注入上限：太老的状态让评审官收敛 recent 优先
+
+
+def _parse_tagged_lines(text, tag):
+    """从模型回复提取 <tag>...</tag> 块的非空行列表（缺失/空块返回 []）。"""
+    m = re.search(r"<%s>([\s\S]*?)</%s>" % (tag, tag), text or "")
+    if not m:
+        return []
+    return [ln.strip(" -*") for ln in m.group(1).splitlines() if ln.strip(" -*")]
+
+
+def _append_ledger(workdir, chapter, lines):
+    """资源账本追加：本章评审提炼的道具/伤情/承诺/伏笔增量，供下章起草注入。"""
+    p = os.path.abspath(os.path.join(str(workdir or ""), LEDGER_FILE))
+    if not _inside(workdir, p):
+        raise ValueError("ledger 路径越界")
+    os.makedirs(os.path.dirname(p), exist_ok=True)
+    with open(p, "a", encoding="utf-8") as f:
+        if f.tell() == 0:
+            f.write("# 资源账本（每章评审自动追加：道具/伤情/承诺/伏笔的现状，"
+                    "写新章前必须核对，防止跨章穿帮）\n\n")
+        f.write("## 第 %d 章\n%s\n" % (chapter, "\n".join("- " + x for x in lines)))
+
+
+def _read_ledger(workdir):
+    """读取资源账本注入文本（截至上一章）。不存在返回「（暂无记录）」。"""
+    p = os.path.abspath(os.path.join(str(workdir or ""), LEDGER_FILE))
+    if not _inside(workdir, p) or not os.path.isfile(p):
+        return "（暂无记录，本章建立的新道具/伤情/承诺/伏笔会被账本自动登记）"
+    try:
+        txt = _read_text_any_enc(p)[-_LEDGER_MAX_CHARS:].strip()
+    except OSError:
+        return "（暂无记录）"
+    return txt or "（暂无记录）"
+
+
 def _shrink_context_block(sk_block, bible, budget=12000):
     """分层上下文降级（长提示词在容量受限通道上会挂起/秒拒，2026-09-17 讯飞实测）。
 
@@ -1793,6 +1845,9 @@ __OUTLINE__
 ## 前情提要（此前各章结尾摘录，衔接用）
 __PREV__
 
+## 资源账本（道具/伤情/承诺/伏笔的现状登记，写本章前必须核对）
+__LEDGER__
+
 - 写完文件后，最终回复只输出一行：`第 __I__ 章完成（约 __WORDS__ 字）`——不要在回复里复述或解释正文。"""
 
 SERIAL_REVISE_PROMPT = """你是一名网文作者。第 __I__ 章没有通过评审，请修订文件 `__FILE__`（直接改写该文件）。文件必须以 UTF-8 编码保存（PowerShell 显式加 -Encoding UTF8，禁止依赖默认编码）。
@@ -1992,12 +2047,15 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
         bible = task["context"] + ("\n\n" + bible if bible else "")
 
 
-    def crit_prompt_for(text, note=""):
+    def crit_prompt_for(text, note="", event_check=""):
         tpl = _ensure_critique_placeholders(
             _tpl(task, "critique_prompt", NOVEL_CRITIQUE_PROMPT))
         if note:
             tpl = tpl.replace("你是严格的评审",
                               "你是严格的评审（背景：%s，请结合全书目标评审本章节）" % note, 1)
+        if event_check:
+            # 逐项目标审稿（借鉴 AI-Novel-Writer v1.1）：本章大纲要点逐项核对
+            tpl = tpl.replace("## 待评审稿件", "%s\n\n## 待评审稿件" % event_check, 1)
         # stable_order：评审分轮次调用，hits 中途变化会打碎前缀缓存（§07 T1.2'）
         sk, _ = skills.block_for(task, stable_order=True)
         if sk:
@@ -2074,6 +2132,22 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
         i = start + k - 1        # 全书章号：文件名/步骤角色/评分记录都按全书编号
         ch = outline["chapters"][k - 1]
         ch_file = "chapter-%02d.md" % i
+        # 逐项目标审稿（借鉴 AI-Novel-Writer）：本章大纲要点随评审下发，评审
+        # 以 <event_check> 回逐项判定；资源账本（借鉴角色资源账本）以 <ledger>
+        # 回本章道具/伤情/承诺/伏笔增量，评审达标后追加账本文件供下章注入。
+        event_block = (
+            "## 本章大纲核对（逐项目标审稿）\n"
+            "本章按大纲应完成：\n- 剧情要点：%s\n- 章末钩子：%s\n"
+            "评审时逐项判定「已完成 / 未完成 / 待核实」，判定必须引用正文证据"
+            "（原文短句或位置），写在回复末尾的 <event_check> 块内（每项一行）。"
+            "「铺垫了但没发生」不算已完成；未完成的项必须反映到对应维度评分。\n"
+            "另在 <event_check> 块之后输出 <ledger> 块（没有新变化就整个省略）："
+            "逐行列出本章新出现或状态变化的 道具/伤情/承诺/伏笔，格式："
+            "类型|名称|现状（一句话）。\n\n"
+            % (ch.get("beats") or "按大纲推进", ch.get("hook") or "留下悬念"))
+        ev_check_lines = [[]]     # 每章重置：第一份非空评审的逐项判定
+        ledger_lines = []         # 本章全部评审的账本增量并集
+        ledger_txt = _read_ledger(workdir)   # 截至上一章的资源账本（起草注入）
         prev = ""
         draft_sid = ""  # §07 T1.1：本轮 draft/复用章的会话 id（revise 复用；reuse 时为空）
         if i > 1:
@@ -2101,8 +2175,14 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
         rounds_used = 1
         means = {}
 
-        def run_critique(text, rnd, note_extra="", critic_sids=None):
-            """一轮多维评审：返回 (cj_by_agent, scored)。变体赛马与主循环共用。"""
+        # 逐项目标审稿 + 资源账本的每章聚合桶（run_critique 内解析填充；
+        # event_check 取第一份非空，ledger 全评审增量求并）
+        ev_check_lines = [[]]
+        ledger_lines = []
+
+        def run_critique(text, rnd, note_extra="", critic_sids=None, event_check=""):
+            """一轮多维评审：返回 (cj_by_agent, scored)。变体赛马与主循环共用。
+            event_check：本章大纲核对块（逐项目标审稿），随评审下发并回收标记块。"""
             cj_map, sids = {}, dict(critic_sids or {})
             scored = 0   # 真正给出分数的评审数；失败/不可解析不得当成 0 分计入
             for agent in critics:
@@ -2125,12 +2205,20 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                                         note=("小说第 %d 章" % i) + (
                                             "｜你的专属评审视角：%s（其他评审会覆盖其余视角，"
                                             "请深挖你的镜头，但所有维度仍需打分）" % lens)
-                                        if lens else "") + note_extra,
+                                        if lens else "",
+                                        event_check=event_check) + note_extra,
                                     workdir, readonly=True, ev=ev,
                                     resume=sids.get(agent["id"]))
                     cj = _critique_json(res, dims)
                     if cj.get("scores"):
                         scored += 1
+                    # 逐项目标审稿 + 资源账本：解析评审回复里的标记块（借鉴
+                    # AI-Novel-Writer 逐项核对/角色资源账本）。多评审取第一份
+                    # 非空即可，聚合时已在前两处赋值处去重。
+                    evl = _parse_tagged_lines(res.get("text"), "event_check")
+                    if evl and not ev_check_lines[0]:
+                        ev_check_lines[0] = evl
+                    ledger_lines.extend(_parse_tagged_lines(res.get("text"), "ledger"))
                     # §07 T1.1：记录该评审的会话 id（第 2 轮复用）
                     csid = _resume_sid(agent, res.get("sid"))
                     if csid:
@@ -2150,7 +2238,8 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                     res = _run_step(run_id, role, modelhub.bind_agent(spare, difficulty),
                                     crit_prompt_for(
                                         text,
-                                        note="小说第 %d 章" % i) + note_extra,
+                                        note="小说第 %d 章" % i,
+                                        event_check=event_check) + note_extra,
                                     workdir, readonly=True, ev=ev)
                     cj = runner.extract_json(res.get("text") or "")
                     if isinstance(cj, dict) and isinstance(cj.get("scores"), dict) \
@@ -2222,6 +2311,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                         .replace("__GOAL__", task["goal"])
                         .replace("__OUTLINE__", outline_txt)
                         .replace("__PREV__", prev)
+                        .replace("__LEDGER__", ledger_txt)
                         .replace("__TITLE__", ch["title"])
                         .replace("__BEATS__", ch["beats"] or "按大纲推进")
                         .replace("__HOOK__", ch.get("hook") or "留下悬念")
@@ -2474,7 +2564,8 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
             if rnd == 1 and race_cj is not None:
                 cj_by_agent, scored = race_cj, race_scored
             else:
-                cj_by_agent, scored, sids_now = run_critique(text, rnd, critic_sids=critic_sids)
+                cj_by_agent, scored, sids_now = run_critique(
+                    text, rnd, critic_sids=critic_sids, event_check=event_block)
                 critic_sids.update(sids_now)
             if not scored:
                 # 「评不上」≠「评了 0 分」：全部评审失败时中止本轮，
@@ -2538,12 +2629,23 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                 impl, implement_reason="章节修订：%s" %
                 (impl.get("label") or impl.get("id")))
             _check_cancel(ev)
-        chapter_scores.append({"chapter": i, "title": ch["title"], "means": means,
-                               "passed": bool(means) and all(v >= threshold_ch for v in means.values()),
-                               "rounds": rounds_used,
-                               "words": _wc(_read_chapter(workdir, i))})
+        cs_new = {"chapter": i, "title": ch["title"], "means": means,
+                  "passed": bool(means) and all(v >= threshold_ch for v in means.values()),
+                  "rounds": rounds_used,
+                  "words": _wc(_read_chapter(workdir, i))}
+        if ev_check_lines[0]:
+            cs_new["event_check"] = ev_check_lines[0][:8]   # 逐项目标审稿结果
+        chapter_scores.append(cs_new)
         # 每章即时持久化：长篇中断/超时后可断点续跑，不丢已完成章的分数
         store.update_run(run_id, chapter_scores=chapter_scores)
+        # 资源账本（借鉴角色资源账本）：评审提出的道具/伤情/承诺/伏笔增量
+        # 追加到 .codebee/resource-ledger.md，下一章起草时注入，防跨章穿帮。
+        # 失败静默——账本是增强不是硬依赖。
+        if ledger_lines:
+            try:
+                _append_ledger(workdir, i, ledger_lines)
+            except Exception:
+                pass
         # findings 沉淀（借鉴 agentmemory 持久记忆）：章节标题+要点追加到
         # .codebee/findings.md——后续章节起草时随圣经/模块库注入，弥补
         # 前情提要只看近 2 章结尾的中期记忆空洞。失败静默。

package/app/core/prefs.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+"""偏好记忆（借鉴 chinese-novelist-skill 的偏好记忆，2026-09-21）：记住用户
+上次创建任务时选择的类型与参数，新建任务时预填「最近一次的选择」而不是
+写死的出厂默认——高频用户不用每次重调轮数/阈值/章节。
+
+只记参数不记内容（目标/标题绝不落库）；单文件带锁读写，损坏即弃。
+"""
+from __future__ import annotations
+
+import json
+import threading
+
+from . import paths
+
+_LOCK = threading.Lock()
+
+SAVE_KEYS = ("type", "rounds", "threshold", "best_of", "chapters",
+             "words_per_chapter", "variants")
+_LIMITS = {"rounds": (1, 5), "threshold": (1.0, 10.0), "best_of": (1, 3),
+           "chapters": (1, 2000), "words_per_chapter": (200, 20000),
+           "variants": (1, 3)}
+
+
+def _file():
+    # 动态取路径：DATA_DIR 可被测试重定向，模块级缓存会绑死首次导入的目录
+    return paths.DATA_DIR / "last-prefs.json"
+
+
+def _clamp(key, value):
+    """数值钳制：历史文件被手改出天际值时按参数合法域兜底。"""
+    lo, hi = _LIMITS.get(key), (0, 10 ** 9)
+    lo, hi = lo if lo else hi
+    try:
+        return max(lo, min(hi, type(lo)(value) if isinstance(lo, int)
+                           else float(value)))
+    except (TypeError, ValueError):
+        return None
+
+
+def record(payload):
+    """从创建任务的 payload 提取可复用参数（存在才覆盖，单键独立保留）。"""
+    if not isinstance(payload, dict):
+        return
+    with _LOCK:
+        cur = load()
+        for key in SAVE_KEYS:
+            v = payload.get(key)
+            if v is None:
+                continue
+            if key == "type":
+                v = str(v)[:32]
+                if v:
+                    cur["type"] = v
+                continue
+            c = _clamp(key, v)
+            if c is not None:
+                cur[key] = c
+        tmp = _file().with_suffix(".tmp")
+        try:
+            paths.DATA_DIR.mkdir(parents=True, exist_ok=True)
+            tmp.write_text(json.dumps(cur, ensure_ascii=False, indent=2),
+                           encoding="utf-8")
+            tmp.replace(_file())
+        except OSError:
+            pass
+
+
+def load():
+    """读最近偏好；文件缺失/损坏返回 {}。"""
+    try:
+        data = json.loads(_file().read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except (OSError, ValueError):
+        return {}

package/app/core/runner.py

@@ -397,15 +397,18 @@ def pretty_cli_log(text, max_event_chars=4000):
     return "\n".join(out)
 
 
-def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
-                timeout=DEFAULT_TIMEOUT, cancel_event=None, log_path=None,
-                stall_timeout=0):
+def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
+                timeout=DEFAULT_TIMEOUT, cancel_event=None, log_path=None,
+                stall_timeout=0, repeat_abort=None):
     """通用子进程执行：并发读管道防死锁；超时/取消杀整棵进程树。
 
     stall_timeout：停滞看门狗（秒，0=关闭）——超过该时长 stdout/stderr 无任何
     新输出即判卡死，提前杀树返回（timed_out=True + stalled=True）。只对输出
-    持续流动的 CLI 开（codex JSONL 事件流）；claude json 到结束才一次性输出，
-    开了会把正常长任务误杀。
+    持续流动的 CLI 开（codex JSONL 事件流）；claude json 到结束才一次性输出，
+    开了会把正常长任务误杀。
+
+    repeat_abort：可选 (marker, count)。同一致命错误达到次数即提前杀树，处理
+    CLI 自身不断打印重连消息、因此永远触发不了静默看门狗的假运行。
 
     返回 {ok, exit_code, stdout, stderr, duration, cancelled, timed_out, stalled}。
     """
@@ -468,7 +471,7 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                         pass
             threading.Thread(target=_feed, daemon=True).start()
         start = time.time()
-        cancelled = timed_out = stalled = False
+        cancelled = timed_out = stalled = repeat_aborted = False
         while True:
             try:
                 proc.wait(timeout=0.4)
@@ -485,14 +488,27 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                 _kill_tree(proc.pid)
                 _drain_streams(proc, t_out, t_err, timeout=5)
                 break
-            if stall_timeout and time.time() - stamp[0] > stall_timeout:
+            if stall_timeout and time.time() - stamp[0] > stall_timeout:
                 # 停滞看门狗：长静默多为卡死（网关挂起/CLI 假死），与其耗满总
                 # 超时不如提前杀——错误按超时归类，走既有的换模型/换将链路
                 stalled = True
                 timed_out = True
                 _kill_tree(proc.pid)
-                _drain_streams(proc, t_out, t_err, timeout=5)
-                break
+                _drain_streams(proc, t_out, t_err, timeout=5)
+                break
+            if repeat_abort:
+                try:
+                    marker, limit = repeat_abort
+                    recent = decode_output(b"".join(out_chunks)[-8000:] +
+                                           b"\n" + b"".join(err_chunks)[-8000:])
+                    if marker and recent.count(str(marker)) >= int(limit):
+                        repeat_aborted = True
+                        timed_out = True
+                        _kill_tree(proc.pid)
+                        _drain_streams(proc, t_out, t_err, timeout=5)
+                        break
+                except (TypeError, ValueError):
+                    pass
         duration = round(time.time() - start, 1)
         t_out.join(timeout=5)
         t_err.join(timeout=5)
@@ -505,9 +521,11 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                     stream.close()
             except Exception:
                 pass
-        if cancelled:
-            stderr += "\n[已被用户取消]"
-        elif stalled:
+        if cancelled:
+            stderr += "\n[已被用户取消]"
+        elif repeat_aborted:
+            stderr += "\n[同一网络错误重复 %s 次，已提前终止进程树]" % repeat_abort[1]
+        elif stalled:
             stderr += "\n[输出停滞 %ss，已终止进程树]" % stall_timeout
         elif timed_out:
             stderr += "\n[超时 %ss，已终止进程树]" % timeout
@@ -1050,10 +1068,12 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                 att["model"], prompt,
                 images=images if kind == "codex" else None,
                 workdir=workdir)
-            try:
-                res = run_process(argv=argv, stdin_text=stdin_text, cwd=workdir, env=env,
-                                  timeout=timeout, cancel_event=cancel_event, log_path=log_path,
-                                  stall_timeout=stall_t)
+            try:
+                repeat_guard = (("Reconnecting... waiting for network", 5)
+                                if kind == "codex" else None)
+                res = run_process(argv=argv, stdin_text=stdin_text, cwd=workdir, env=env,
+                                  timeout=timeout, cancel_event=cancel_event, log_path=log_path,
+                                  stall_timeout=stall_t, repeat_abort=repeat_guard)
             finally:
                 # 超长指令临时文件：CLI 进程已结束（管道已收），即刻清场不污染工作目录
                 for tf in tmp_files:
@@ -1089,10 +1109,11 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                     parsed_err = _parse_claude_json(res["stdout"] or "")
                     if parsed_err and parsed_err.get("is_error") and parsed_err.get("text"):
                         out["error"] = "claude 返回 is_error: " + parsed_err["text"][:500]
-                if kind == "codex" and att.get("provider_id"):
-                    el = out["error"].lower()
-                    if (("wire_api" in el and "no longer supported" in el)
-                            or "no route matched" in el):
+                if kind == "codex" and att.get("provider_id"):
+                    el = out["error"].lower()
+                    if (("wire_api" in el and "no longer supported" in el)
+                            or "no route matched" in el
+                            or "同一网络错误重复" in out["error"]):
                         # codex 撞 chat-only 供应商（0.154 只讲 responses）：
                         # 自动冷却该供应商 30 分钟，链展开/路由绑定分随之
                         # 自动绕开——不用人工改绑定（2026-09-17 mo-so 实测）

package/app/main.py

@@ -308,6 +308,10 @@ class Handler(BaseHTTPRequestHandler):
                 # 一键反馈 Issue 的预填摘要（标题+正文，全程脱敏，用户亲手提交）
                 from core import telemetry
                 return self._json(200, telemetry.issue_report(days=30))
+            if path == "/api/prefs":
+                # 偏好记忆：上次创建任务的类型/参数（新建表单预填用）
+                from core import prefs
+                return self._json(200, {"prefs": prefs.load()})
             if path == "/api/ports":
                 # 端口占用诊断（借鉴 leftopen）：谁在听、PID/进程/项目归属、
                 # 是否仅本机。?port=N 只看单端口。只读，不碰任何进程。
@@ -2051,7 +2055,15 @@ class Handler(BaseHTTPRequestHandler):
         return 200, {"task_id": task["id"], "run_id": run["id"]}
 
     def _api_create_task(self):
-        status, resp = self._create_and_start(self._body())
+        body = self._body()
+        status, resp = self._create_and_start(body)
+        if status == 200:
+            # 偏好记忆（借鉴 chinese-novelist-skill）：记住本次选择，下次新建预填
+            try:
+                from core import prefs
+                prefs.record(body)
+            except Exception:
+                pass
         return self._json(status, resp)
 
     def _api_task_clarify(self):

package/app/pet.py

@@ -359,6 +359,85 @@ def global_lock_held():
     return False
 
 
+# 浏览器进程白名单：找已打开的 CodeBee 窗口时只认这些主进程的顶层窗口，
+# 避免把桌宠自身（标题也是 CodeBee）或 start-public.bat 起的「CodeBee」
+# 控制台窗口误当成浏览器置前。
+_BROWSER_EXES = {
+    "msedge.exe", "chrome.exe", "chromium.exe", "firefox.exe",
+    "iexplore.exe", "opera.exe", "brave.exe", "vivaldi.exe",
+    "browser.exe", "waterfox.exe", "palemoon.exe", "seamonkey.exe",
+    "centbrowser.exe", "360chrome.exe", "qqbrowser.exe",
+    "sogouexplorer.exe", "maxthon.exe",
+}
+
+
+def _window_process_name(hwnd):
+    """取顶层窗口所属进程的可执行文件名（小写）；失败返回空串。"""
+    try:
+        import ctypes
+        from ctypes import wintypes
+        user32 = ctypes.windll.user32
+        kernel32 = ctypes.windll.kernel32
+        pid = wintypes.DWORD()
+        user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
+        if not pid.value:
+            return ""
+        kernel32.OpenProcess.restype = wintypes.HANDLE
+        # PROCESS_QUERY_LIMITED_INFORMATION=0x1000：只需取映像路径
+        h = kernel32.OpenProcess(0x1000, False, pid.value)
+        if not h:
+            return ""
+        try:
+            buf = ctypes.create_unicode_buffer(1024)
+            size = wintypes.DWORD(1024)
+            if kernel32.QueryFullProcessImageNameW(h, 0, buf,
+                                                   ctypes.byref(size)):
+                return Path(buf.value).name.lower()
+        finally:
+            kernel32.CloseHandle(h)
+    except Exception:
+        pass
+    return ""
+
+
+def _focus_codebee_window(ignore_hwnd=None):
+    """Windows：已打开过 CodeBee 浏览器页时，把那个窗口找出来还原并置前，
+    避免每点一次桌宠就新开一个浏览器窗口。返回 True 表示已找到并尝试置前；
+    False 表示没有现成窗口，调用方应回退 webbrowser.open 新开。"""
+    try:
+        import ctypes
+        from ctypes import wintypes
+        user32 = ctypes.windll.user32
+        EnumWindowsProc = ctypes.WINFUNCTYPE(
+            wintypes.BOOL, wintypes.HWND, wintypes.LPARAM)
+        found = []
+
+        def _cb(hwnd, _lp):
+            if hwnd == ignore_hwnd or not user32.IsWindowVisible(hwnd):
+                return True
+            if _window_process_name(hwnd) not in _BROWSER_EXES:
+                return True
+            length = user32.GetWindowTextLengthW(hwnd)
+            if length <= 0:
+                return True
+            buf = ctypes.create_unicode_buffer(length + 1)
+            user32.GetWindowTextW(hwnd, buf, length + 1)
+            if "CodeBee" in buf.value:
+                found.append(hwnd)
+            return True
+
+        user32.EnumWindows(EnumWindowsProc(_cb), 0)
+        if not found:
+            return False
+        target = found[0]
+        if user32.IsIconic(target):
+            user32.ShowWindow(target, 9)      # SW_RESTORE：最小化先还原
+        user32.SetForegroundWindow(target)
+        return True
+    except Exception:
+        return False
+
+
 class PetApp:
     """蜜蜂窗口：蜜蜂本体（精灵/手绘）+ 状态机动画 + 悬停任务清单 + 右键菜单。"""
 
@@ -1296,7 +1375,12 @@ class PetApp:
 
     def _open_ui(self):
         try:
-            webbrowser.open("http://127.0.0.1:%d" % self.port)
+            url = "http://127.0.0.1:%d" % self.port
+            # 已开过就不新开：Windows 上先找现有 CodeBee 浏览器窗口置前，
+            # 找不到（没开/标签不在前台）才回退 webbrowser.open 新开。
+            if os.name == "nt" and _focus_codebee_window(self.root.winfo_id()):
+                return
+            webbrowser.open(url)
         except Exception:
             pass
 

package/app/ui/app.js

@@ -2,10 +2,15 @@
 "use strict";
 
 const $ = (id) => document.getElementById(id);
-const S = { state: null, catalog: null, catSig: "", providers: null, bindings: null, modelsSig: "", bindSig: "", tab: "tasks", detailRunId: null, pollTimer: null, showArchived: false, /* 会话内开关：每次加载默认隐藏已归档、图标不选中（不持久化，见 btn-side-arch） */ selProvs: {}, selModels: {}, selRuns: {}, bindSel: {}, catalogChecking: false, updateCheckAt: 0, control: null, sseLive: false, es: null, flows: null, orch: null, skills: null, orchSig: "", settings: null, sessionAgents: new Set(), atts: [], gitInfo: null, gitWb: null, gitWbKey: "", gitWbAt: 0, gitWbBusy: false, creatingTask: false, inspKey: null, inspData: null, inspSig: "", inspAt: 0, inspTab: "git", inspAutoSig: "", rdTab: null, rdTabSig: "", rdTabPin: false, _rdCtx: {} };
+const S = { state: null, catalog: null, catSig: "", providers: null, bindings: null, modelsSig: "", bindSig: "", tab: "tasks", detailRunId: null, pollTimer: null, showArchived: false, /* 会话内开关：每次加载默认隐藏已归档、图标不选中（不持久化，见 btn-side-arch） */ selProvs: {}, selModels: {}, selRuns: {}, bindSel: {}, catalogChecking: false, updateCheckAt: 0, control: null, sseLive: false, es: null, flows: null, orch: null, skills: null, orchSig: "", settings: null, sessionAgents: new Set(), atts: [], gitInfo: null, gitWb: null, gitWbKey: "", gitWbAt: 0, gitWbBusy: false, creatingTask: false, inspKey: null, inspData: null, inspSig: "", inspAt: 0, inspTab: "git", inspAutoSig: "", rdTab: null, rdTabSig: "", rdTabPin: false, _rdCtx: {}, lastPrefs: null };
 
 /* ---------------------------------------------------------- 任务类型（流程） */
 async function loadFlows() {
+  // 偏好记忆（借鉴 chinese-novelist-skill）：并行拉最近一次的任务参数，
+  // renderTypeOptions/onTypeChange 用它预填类型与轮数/阈值等（拉失败不挡首屏）
+  api("/api/prefs").then((r) => { S.lastPrefs = (r && r.prefs) || {}; })
+    .then(() => renderTypeOptions())
+    .catch(() => {});
   try {
     const r = await api("/api/flows");
     S.flows = r.flows || [];
@@ -43,11 +48,12 @@ function flowDesc(f) {
 function renderTypeOptions() {
   const sel = $("f-type");
   if (!sel || !S.flows) return;
-  const prev = sel.value;
-  sel.innerHTML = (S.flows || []).map((f) => {
+  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;
+  // 偏好记忆：上次创建用的类型优先于出厂默认「直接执行」（老数据/已删流程回落）
+  else if (S.lastPrefs && S.lastPrefs.type && flowById(S.lastPrefs.type)) sel.value = S.lastPrefs.type;
   // 首屏默认落在「直接执行」（快档位：单 CLI 直达，无拆解/评审）；
   // 老数据或该流程被删时保持首项，不硬造一个不存在的值
   else if (flowById("direct")) sel.value = "direct";
@@ -160,9 +166,11 @@ function onTypeChange() {
   if (goal && flow && flow.goal_hint) goal.placeholder = t(flow.goal_hint);
   if (isReview && flow) {
     if (flow.manuscript) $("f-manuscript").value = flow.manuscript;
-    if (flow.rounds) $("f-rounds").value = flow.rounds;
-    if (flow.threshold) $("f-threshold").value = flow.threshold;
-    if (flow.best_of) $("f-bestof").value = flow.best_of;
+    // 偏好记忆（借鉴 chinese-novelist-skill）：上次创建用过的参数优先于流程出厂默认
+    const lp = S.lastPrefs || {};
+    $("f-rounds").value = lp.rounds || flow.rounds || 2;
+    $("f-threshold").value = (lp.threshold != null ? lp.threshold : (flow.threshold || 7.0));
+    $("f-bestof").value = lp.best_of || flow.best_of || 1;
     const rubric = $("f-rubric");
     const previousFlow = rubric.dataset.flowId || "";
     if (!S.flowRubricDrafts) S.flowRubricDrafts = {};
@@ -175,10 +183,10 @@ function onTypeChange() {
         : (flow.rubric || []).join(", ");
       rubric.dataset.flowId = flow.id;
     }
-    // 连载参数预填（用户可改/可清空 = 单稿件模式）
+    // 连载参数预填（用户可改/可清空 = 单稿件模式）；偏好记忆的最近值优先
     if (flow.serial) {
-      if (!$("f-chapters").value) $("f-chapters").value = flow.serial.chapters || "";
-      if (!$("f-words-per-ch").value) $("f-words-per-ch").value = flow.serial.words_per_chapter || "";
+      if (!$("f-chapters").value) $("f-chapters").value = lp.chapters || flow.serial.chapters || "";
+      if (!$("f-words-per-ch").value) $("f-words-per-ch").value = lp.words_per_chapter || flow.serial.words_per_chapter || "";
     } else clearSerialFields();
   } else {
     // 隐藏控件仍保留 DOM 值；换流程时清理，避免章节/圣经状态污染下一次提交。
@@ -301,6 +309,125 @@ let _requestBusyCount = 0;
 let _lastActionButton = null;
 let _lastActionAt = 0;
 const _requestBusyButtons = new WeakMap();
+const _operations = [];
+let _operationSeq = 0;
+
+function operationLabel(path, opts) {
+  if (opts && opts.operation === false) return "";
+  if (opts && typeof opts.operation === "string") return t(opts.operation);
+  if (opts && opts.busy === false && opts.operation !== true) return "";
+  const method = String((opts && opts.method) || "GET").toUpperCase();
+  if (method === "GET" || method === "HEAD") return "";
+  // 只自动记录刚由用户点击触发的写操作；后台维护请求需显式传 operation 才显示。
+  if (!(opts && opts.operation === true) &&
+      (!_lastActionAt || performance.now() - _lastActionAt >= 2000)) return "";
+  const clean = String(path || "").split("?")[0];
+  const rules = [
+    [/^\/api\/tasks$/, "创建任务"],
+    [/\/tasks\/[^/]+\/delete$/, "删除任务"],
+    [/\/tasks\/[^/]+\/archive$/, "归档任务"],
+    [/\/tasks\/[^/]+\/retry$/, "重试任务"],
+    [/\/tasks\/[^/]+\/continue$/, "创建续写任务"],
+    [/\/tasks\/[^/]+\/rename$/, "重命名任务"],
+    [/\/runs\/[^/]+\/cancel$/, "取消运行"],
+    [/\/runs\/[^/]+\/delete$/, "删除运行"],
+    [/\/runs\/(delete-batch|clear)$/, "清理运行记录"],
+    [/\/attachments(?:\/[^/]+)?$/, "上传附件"],
+    [/\/selfupdate\/apply$/, "升级 CodeBee"],
+    [/\/market\//, "更新插件"],
+    [/\/models\/binding$/, "更新智能体绑定"],
+    [/\/models\//, "更新模型配置"],
+  ];
+  const hit = rules.find((it) => it[0].test(clean));
+  return t(hit ? hit[1] : "提交操作");
+}
+
+function operationStart(path, opts) {
+  const label = operationLabel(path, opts);
+  if (!label) return null;
+  const op = { id: ++_operationSeq, label, status: "running", at: Date.now(), error: "" };
+  _operations.unshift(op);
+  if (_operations.length > 12) _operations.length = 12;
+  renderOperationCenter();
+  return op.id;
+}
+
+function operationFinish(id, status, error) {
+  if (!id) return;
+  const op = _operations.find((it) => it.id === id);
+  if (!op) return;
+  op.status = status;
+  op.error = String(error || "").slice(0, 240);
+  op.endedAt = Date.now();
+  renderOperationCenter();
+}
+
+function operationTime(ts) {
+  try { return new Date(ts).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }); }
+  catch (e) { return ""; }
+}
+
+function renderOperationCenter() {
+  const button = $("btn-ops");
+  const list = $("op-list");
+  if (!button || !list) return;
+  button.classList.toggle("hidden", !_operations.length);
+  const running = _operations.filter((it) => it.status === "running").length;
+  const failed = _operations.filter((it) => it.status === "failed").length;
+  button.classList.toggle("running", running > 0);
+  button.classList.toggle("failed", !running && failed > 0);
+  button.classList.toggle("done", !running && !failed && _operations.length > 0);
+  const pill = $("op-pill-text");
+  if (pill) pill.textContent = running ? t("{0} 项处理中").replace("{0}", running)
+    : failed ? t("{0} 项失败").replace("{0}", failed) : t("操作完成");
+  list.innerHTML = _operations.map((op) => {
+    const status = op.status === "running" ? t("处理中")
+      : op.status === "failed" ? t("失败") : t("已完成");
+    const remove = op.status === "running" ? "" :
+      '<button type="button" class="op-dismiss" aria-label="' + esc(t("移除")) +
+      '" title="' + esc(t("移除")) + '" onclick="dismissOperation(event,' + op.id + ')">' +
+      '<svg class="ico" aria-hidden="true"><use href="#i-x"></use></svg></button>';
+    return '<div class="op-row ' + op.status + '"><span class="op-state" aria-hidden="true"></span>' +
+      '<div class="op-copy"><div><b>' + esc(op.label) + '</b><span>' + esc(status) + " · " +
+      esc(operationTime(op.endedAt || op.at)) + '</span></div>' +
+      (op.error ? '<p title="' + esc(op.error) + '">' + esc(op.error) + "</p>" : "") +
+      "</div>" + remove + "</div>";
+  }).join("");
+}
+
+function toggleOperationCenter(force) {
+  const panel = $("op-center");
+  const button = $("btn-ops");
+  if (!panel || !button) return;
+  const open = force === undefined ? panel.classList.contains("hidden") : !!force;
+  panel.classList.toggle("hidden", !open);
+  button.setAttribute("aria-expanded", open ? "true" : "false");
+}
+
+function clearFinishedOperations() {
+  for (let i = _operations.length - 1; i >= 0; i--) {
+    if (_operations[i].status === "done") _operations.splice(i, 1);
+  }
+  renderOperationCenter();
+  if (!_operations.length) toggleOperationCenter(false);
+}
+
+function dismissOperation(event, id) {
+  if (event) event.stopPropagation();
+  const i = _operations.findIndex((it) => it.id === id && it.status !== "running");
+  if (i >= 0) _operations.splice(i, 1);
+  renderOperationCenter();
+  if (!_operations.length) toggleOperationCenter(false);
+}
+
+window.toggleOperationCenter = toggleOperationCenter;
+window.clearFinishedOperations = clearFinishedOperations;
+window.dismissOperation = dismissOperation;
+
+document.addEventListener("click", (e) => {
+  const wrap = $("op-wrap");
+  if (wrap && !wrap.contains(e.target)) toggleOperationCenter(false);
+});
 
 /* 记录发起请求的按钮。写请求统一在 api() 里挂忙碌态，避免每个业务入口各写一套；
  * 确认框的按钮不覆盖原始操作按钮，但会续期，使“确认后执行”仍反馈在原按钮上。 */
@@ -394,10 +521,12 @@ async function api(path, opts) {
     var timer = setTimeout(() => ctrl.abort(), opts.timeout);
   }
   const busyToken = requestBusyStart(opts);
+  const operationToken = operationStart(path, opts);
   const fetchOpts = Object.assign({}, opts);
   delete fetchOpts.timeout;
   delete fetchOpts.busy;
   delete fetchOpts.busyElement;
+  delete fetchOpts.operation;
   try {
     let res;
     try {
@@ -412,7 +541,11 @@ async function api(path, opts) {
     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));
+    operationFinish(operationToken, "done");
     return data;
+  } catch (e) {
+    operationFinish(operationToken, "failed", e && e.message ? e.message : e);
+    throw e;
   } finally {
     if (timer) clearTimeout(timer);
     requestBusyEnd(busyToken);
@@ -2027,7 +2160,7 @@ async function createTask() {
     try {
       const cq = await api("/api/tasks/clarify", {
         // 澄清只是增强，不能让建任务被模型调用拖住；超时后直接按原目标开跑。
-        method: "POST", timeout: 8000,
+        method: "POST", timeout: 8000, operation: false,
         body: JSON.stringify({ goal: payload.goal, type: payload.type }) });
       const qs = (cq && cq.questions) || [];
       if (qs.length) {
@@ -2089,7 +2222,7 @@ async function createTask() {
     if (critics.length) payload.critics = critics;
   }
   try {
-    const r = await api("/api/tasks", { method: "POST", timeout: 30000,
+    const r = await api("/api/tasks", { method: "POST", timeout: 30000, operation: "创建任务",
       body: JSON.stringify(payload) });
     msg.textContent = t("已创建，跳转运行页…");
     // 先把新任务刷进 state 再跳：chatEngineIsDirect 靠 S.state.tasks 判引擎，
@@ -2383,7 +2516,8 @@ async function deleteTask(id) {
   let gone = false;
   try {
     toast(t("正在删除任务…"));
-    await api("/api/tasks/" + encodeURIComponent(id) + "/delete", { method: "POST" });
+    await api("/api/tasks/" + encodeURIComponent(id) + "/delete",
+      { method: "POST", operation: "删除任务" });
   } catch (e) {
     // 任务已不在（他端删过 / 重复点）：不报错晾着，照常把视图清掉
     if (!/任务不存在/.test(e.message)) { toast(t("删除失败：") + e.message, true); return; }
@@ -8344,7 +8478,7 @@ function renderZentaoProfiles() {
   const box = $("zt-profiles");
   if (!box) return;
   box.innerHTML = (S.ztProfiles || []).map((p, i) => ztProfCardHtml(p, i)).join("") ||
-    '<div class="empty">' + t("还没有产品档案——点「＋ 添加产品」，填产品 ID 与两端仓库。") + "</div>";
+    '<div class="empty">' + t("还没有产品档案——先测试连接，再从禅道选择产品，无需自己查 ID。") + "</div>";
 }
 
 /* DOM 卡片 → profiles 数组（结构变化前采集，保住已输入值） */
@@ -8385,6 +8519,10 @@ function ztProfAdd() {
     repos: { backend: {}, frontend: {} }, repo_hints: { backend: "", frontend: "" },
     owners: { backend: "", frontend: "", not_ours: "" }, module_routes: [] });
   renderZentaoProfiles();
+  // 首次添加时自动拉清单，避免用户只能盲填产品 ID；拉不到仍保留手填回退。
+  if (!(S.ztProducts || []).length && $("zt-base-url") && $("zt-base-url").value.trim()) {
+    ztFetchCatalog(false);
+  }
 }
 
 function ztProfDel(i) {
@@ -8515,7 +8653,7 @@ function zentaoOpenRun(runId) {
 }
 
 /* 表单 → 保存配置。password 只在用户输入了才提交（空 = 保持已存密码）。 */
-async function saveZentao() {
+function ztFormPayload() {
   const val = (id) => (($(id).value || "").trim());
   const payload = {
     base_url: val("zt-base-url"),
@@ -8529,6 +8667,11 @@ async function saveZentao() {
   };
   const pw = ($("zt-password").value || "").trim();
   if (pw) payload.password = pw;
+  return payload;
+}
+
+async function saveZentao() {
+  const payload = ztFormPayload();
   try {
     await api("/api/zentao/config", { method: "POST", body: JSON.stringify(payload) });
   } catch (e) { toast(t("保存失败：") + e.message, true); return; }
@@ -8554,6 +8697,16 @@ async function testZentao() {
       toast(t("地址已自动补全子路径，记得「保存配置」"));
     }
   }
+  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); }
+  }
 }
 
 async function scanZentao() {

package/app/ui/i18n.js

@@ -1276,6 +1276,29 @@
     "正在下载安装，插件包较大时需要约一分钟…": "Downloading and installing — large plugin packages can take about a minute…",
     "请求超时，请重试或检查网络": "Request timed out — try again or check your network",
     "操作处理中": "Working on it",
+    "操作状态": "Operations",
+    "清除已完成": "Clear completed",
+    "创建任务": "Create task",
+    "删除任务": "Delete task",
+    "归档任务": "Archive task",
+    "重试任务": "Retry task",
+    "创建续写任务": "Create continuation",
+    "重命名任务": "Rename task",
+    "取消运行": "Cancel run",
+    "删除运行": "Delete run",
+    "清理运行记录": "Clear run history",
+    "上传附件": "Upload attachment",
+    "升级 CodeBee": "Upgrade CodeBee",
+    "更新插件": "Update plugin",
+    "更新模型配置": "Update model settings",
+    "更新智能体绑定": "Update agent binding",
+    "提交操作": "Submit operation",
+    "{0} 项处理中": "{0} in progress",
+    "{0} 项失败": "{0} failed",
+    "操作完成": "Operation complete",
+    "处理中": "In progress",
+    "失败": "Failed",
+    "已完成": "Completed",
     "该插件含脚本/钩子/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)).",
@@ -1939,6 +1962,10 @@
     "AI 排查兜底": "AI triage fallback",
     "产品档案": "Product Profiles",
     "＋ 添加产品": "＋ Add product",
+    "＋ 从禅道添加产品": "＋ Add from ZenTao",
+    "刷新产品列表": "Refresh products",
+    "重新从禅道拉取产品与账号": "Reload products and accounts from ZenTao",
+    "先测试连接，再点「从禅道添加产品」直接选择产品；无需自己查 ID。每个产品只需配置我方仓库，负责人和模块路由均可稍后补充。": "Test the connection, then choose Add from ZenTao — no ID lookup needed. Configure only your repository first; owners and module routes can be added later.",
     "删除产品": "Remove product",
     "每个产品一份档案：我方端（自动修）、两端仓库与负责人、模块路由（模块 → 端/人，排查优先级最高）。": "One profile per product: our sides (auto-fix), frontend/backend repos and owners, module routes (module → side/owner, highest triage priority).",
     "定时扫描禅道多个产品的激活 Bug：先按模块路由/AI 排查定责（前端/后端/双端/非我方），我方端自动创建代码修复任务（实现→验证→评审→修复），修完自动合并并 resolve 或转派对应负责人；测试指错人也按排查结论改派。": "Periodically scans active bugs across products: triages each (frontend/backend/both/not-ours) via module routes or AI, auto-fixes on our sides (implement → verify → review → fix), then merges & resolves or transfers to the right owner — including re-routing bugs the tester assigned to the wrong person.",
@@ -1976,6 +2003,7 @@
     "需人工": "Needs human",
     "还没有认领过 Bug——配置好连接与产品档案后点「立即扫描」。": "No bugs claimed yet — set up connection and product profiles, then click \"Scan Now\".",
     "还没有产品档案——点「＋ 添加产品」，填产品 ID 与两端仓库。": "No product profiles yet — click \"＋ Add product\" and fill the product ID and repos.",
+    "还没有产品档案——先测试连接，再从禅道选择产品，无需自己查 ID。": "No product profiles yet — test the connection, then select a product from ZenTao; no ID lookup needed.",
     "先填产品 ID 再拉模块清单": "Fill the product ID before fetching modules",
     "先选产品再拉模块清单": "Pick a product before fetching modules",
     "拉取失败": "Fetch failed",

package/app/ui/index.html

@@ -214,6 +214,15 @@
       <div id="health-banner" class="health-banner hidden" onclick="healthBannerClick()" title="供应商健康告警" aria-label="供应商健康告警" data-i18n-title="供应商健康告警" data-i18n-aria="供应商健康告警"></div>
       <div class="top-actions">
         <button id="ctrl-pill" class="pill ctrl icon-only hidden" onclick="ctrlClick()" title="多端控制权" aria-label="多端控制权" data-i18n-aria="多端控制权" data-i18n-title="多端控制权"><svg class="ico" aria-hidden="true"><use href="#i-unlock"></use></svg></button>
+        <div id="op-wrap" class="op-wrap">
+          <button id="btn-ops" class="pill op-pill hidden" type="button" onclick="toggleOperationCenter()" title="操作状态" aria-label="操作状态" aria-haspopup="dialog" aria-expanded="false" aria-controls="op-center" data-i18n-title="操作状态" data-i18n-aria="操作状态">
+            <svg class="ico" aria-hidden="true"><use href="#i-history"></use></svg><span id="op-pill-text"></span>
+          </button>
+          <div id="op-center" class="op-center hidden" role="dialog" aria-label="操作状态" data-i18n-aria="操作状态">
+            <div class="op-center-head"><b data-i18n="操作状态">操作状态</b><button type="button" class="ghost small" onclick="clearFinishedOperations()" data-i18n="清除已完成">清除已完成</button></div>
+            <div id="op-list" class="op-list" aria-live="polite"></div>
+          </div>
+        </div>
         <!-- 语言快捷切换：语言名用母语写死（中文/English），刻意不做 i18n——任何母语的人都要能读懂并选中 -->
         <div class="lang-wrap">
           <button id="btn-lang" class="pill icon-only" type="button" onclick="toggleLangMenu()" title="语言 / Language" aria-label="切换语言" aria-haspopup="listbox" aria-controls="lang-menu" data-i18n-title="语言 / Language" data-i18n-aria="切换语言"><svg class="ico" aria-hidden="true"><use href="#i-globe"></use></svg></button>
@@ -535,7 +544,7 @@
           <h2 data-i18n="禅道 Bug 自动修复">禅道 Bug 自动修复</h2>
           <button class="hhelp" data-help-topic="auto" title="这是什么？点开看帮助" data-i18n-title="这是什么？点开看帮助" aria-label="帮助" data-i18n-aria="帮助"><svg class="ico" aria-hidden="true"><use href="#i-help"></use></svg></button>
           <div class="actions">
-            <button id="btn-zentao-test" class="ghost small" title="用当前表单里的连接信息试连禅道" data-i18n-title="用当前表单里的连接信息试连禅道"><span data-i18n="测试连接">测试连接</span></button>
+            <button id="btn-zentao-test" class="ghost small" title="测试成功后自动保存连接并拉取产品列表" data-i18n-title="测试成功后自动保存连接并拉取产品列表"><span data-i18n="测试并保存连接">测试并保存连接</span></button>
             <button id="btn-zentao-scan" class="primary small" title="立刻扫一遍激活 Bug 并对账回写" data-i18n-title="立刻扫一遍激活 Bug 并对账回写"><span data-i18n="立即扫描">立即扫描</span></button>
           </div>
         </div>
@@ -557,11 +566,11 @@
         </div>
         <div class="ops"><button id="btn-zentao-save" class="primary small"><span data-i18n="保存配置">保存配置</span></button></div>
         <h3 data-i18n="产品档案" class="sec-title">产品档案</h3>
-        <p data-i18n="每个产品一份档案：我方端（自动修）、两端仓库与负责人、模块路由（模块 → 端/人，排查优先级最高）。" class="hint">每个产品一份档案：我方端（自动修）、两端仓库与负责人、模块路由（模块 → 端/人，排查优先级最高）。</p>
+        <p data-i18n="先测试连接，再点「从禅道添加产品」直接选择产品；无需自己查 ID。每个产品只需配置我方仓库，负责人和模块路由均可稍后补充。" class="hint">先测试连接，再点「从禅道添加产品」直接选择产品；无需自己查 ID。每个产品只需配置我方仓库，负责人和模块路由均可稍后补充。</p>
         <div id="zt-profiles" class="cards"></div>
         <div class="ops">
-          <button id="btn-zentao-fetchcat" class="ghost small" title="从禅道拉产品与账号清单：产品 ID、负责人变下拉选择（需连接可用）" data-i18n-title="从禅道拉产品与账号清单：产品 ID、负责人变下拉选择（需连接可用）"><span data-i18n="拉取清单">拉取清单</span></button>
-          <button id="btn-zentao-addprofile" class="ghost small"><span data-i18n="＋ 添加产品">＋ 添加产品</span></button>
+          <button id="btn-zentao-fetchcat" class="ghost small" title="重新从禅道拉取产品与账号" data-i18n-title="重新从禅道拉取产品与账号"><span data-i18n="刷新产品列表">刷新产品列表</span></button>
+          <button id="btn-zentao-addprofile" class="primary small"><span data-i18n="＋ 从禅道添加产品">＋ 从禅道添加产品</span></button>
         </div>
         <datalist id="zt-users"></datalist>
         <h3 data-i18n="修复记录" class="sec-title">修复记录</h3>

package/app/ui/style.css

@@ -5456,3 +5456,55 @@ button.request-busy > * { opacity: .18; }
   .rd-route-row { grid-template-columns: 38px minmax(72px, 1fr); }
   .rd-route-reason { grid-column: 2; }
 }
+
+/* ---------------- 统一操作状态中心（所有用户触发的写请求） ---------------- */
+.op-wrap { position: relative; }
+.op-pill { min-width: 118px; justify-content: center; }
+.op-pill.running { color: var(--accent); border-color: color-mix(in srgb, var(--accent) 55%, var(--border)); }
+.op-pill.failed { color: var(--bad); border-color: color-mix(in srgb, var(--bad) 55%, var(--border)); }
+.op-pill.done { color: var(--ok); }
+.op-pill.running .ico { animation: op-center-spin 1.1s linear infinite; }
+@keyframes op-center-spin { to { transform: rotate(-360deg); } }
+.op-center {
+  position: absolute; z-index: 140; top: calc(100% + 9px); right: 0;
+  width: min(370px, calc(100vw - 24px)); max-height: min(480px, calc(100vh - 88px));
+  overflow: hidden; border: 1px solid var(--border-strong); border-radius: 8px;
+  background: var(--panel); box-shadow: var(--shadow-lg);
+}
+.op-center.hidden { display: none; }
+.op-center-head {
+  display: flex; align-items: center; justify-content: space-between; gap: 12px;
+  min-height: 48px; padding: 8px 10px 8px 14px; border-bottom: 1px solid var(--border);
+}
+.op-center-head b { font-size: 13px; }
+.op-list { max-height: min(430px, calc(100vh - 140px)); overflow: auto; }
+.op-row {
+  display: grid; grid-template-columns: 10px minmax(0, 1fr) 28px; gap: 9px;
+  align-items: start; min-height: 52px; padding: 10px 9px 10px 14px;
+  border-bottom: 1px solid var(--border);
+}
+.op-row:last-child { border-bottom: 0; }
+.op-state { width: 8px; height: 8px; margin-top: 6px; border-radius: 50%; background: var(--ok); }
+.op-row.running .op-state { background: var(--accent); animation: pulse 1.1s ease-in-out infinite; }
+.op-row.failed .op-state { background: var(--bad); }
+.op-copy { min-width: 0; }
+.op-copy > div { display: flex; align-items: baseline; justify-content: space-between; gap: 12px; }
+.op-copy b { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 12.5px; }
+.op-copy span { flex: none; color: var(--muted); font-size: 10.5px; }
+.op-copy p {
+  margin: 4px 0 0; color: var(--bad); font-size: 11px; line-height: 1.4;
+  display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden;
+}
+.op-dismiss {
+  width: 26px; height: 26px; padding: 5px; border: 0; border-radius: 6px;
+  color: var(--muted); background: transparent; cursor: pointer;
+}
+.op-dismiss:hover { color: var(--text); background: var(--panel2); }
+@media (max-width: 720px) {
+  .op-pill { min-width: 34px; width: 34px; height: 32px; padding: 5px; }
+  .op-pill #op-pill-text { display: none; }
+  .op-center { position: fixed; top: 58px; right: 8px; width: calc(100vw - 16px); }
+}
+@media (prefers-reduced-motion: reduce) {
+  .op-pill.running .ico, .op-row.running .op-state { animation: none; }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebee",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "CodeBee · 多智能体编排台 — 统一编排本机 AI 编码 CLI（Codex / Claude Code / QwenCode / OpenCode / Aider…）：目标→拆解→路由→执行→验证→跨厂商评审→修复→报告。纯 Python 标准库实现，本地 Web UI。",
   "license": "MIT",
   "bin": {