codebee 0.1.18 → 0.1.19

package/app/core/pipeline.py

@@ -310,7 +310,8 @@ def _wait_gate(run_id, ev):
             return
         if ev is not None and ev.is_set():
             return
-        time.sleep(1.0)
+        # ev.wait 睡等：取消置位即刻醒来，不必耗满 1s 轮询间隔
+        (ev.wait(1.0) if ev is not None else time.sleep(1.0))
 
 
 def _binding_dead_msg(agent):
@@ -632,6 +633,7 @@ __GOAL__
 
 ## 本步指令
 __SUBTASK__
+__FILES__
 
 ## 背景与上下文
 __CONTEXT__
@@ -693,6 +695,16 @@ def _verify_hint(task):
     return ""
 
 
+def _files_hint(sub):
+    """计划锚定文件清单（OpenSpec explore 借鉴）：计划里带了 files 就明示改动面，
+    让实现者知道该动哪些文件、不必全盘摸索。无 files 时返回空串（旧计划兼容）。"""
+    files = (sub or {}).get("files")
+    if not isinstance(files, list) or not files:
+        return ""
+    return "\n- 本步涉及文件（计划已锚定，先读再改）：" + "、".join(
+        "`%s`" % str(f) for f in files[:10])
+
+
 def _run_verify(run_id, task, workdir, ev):
     """确定性验证。返回 (verify_pass, ran)。"""
     if not task.get("verify_command"):
@@ -803,6 +815,7 @@ def _code_bestof(run, task, impl, difficulty, ev):
                 prompt = (_RUN_CONSTITUTION + CODE_IMPL_PROMPT
                           .replace("__GOAL__", task["goal"])
                           .replace("__SUBTASK__", sub["detail"] if sub["detail"] else sub["title"])
+                          .replace("__FILES__", _files_hint(sub))
                           .replace("__CONTEXT__", task.get("context") or "（无）")
                           .replace("__VERIFY_HINT__", _verify_hint(task)))
                 res = _run_step(run_id, "race%d-impl" % k, agt_b, prompt, wt_path,
@@ -953,6 +966,7 @@ def _run_code(run, task, agents, ev, stats, mode):
                           .replace("__GOAL__", task["goal"])
                           .replace("__SUBTASK__",
                                    sub["detail"] if sub["detail"] else sub["title"])
+                          .replace("__FILES__", _files_hint(sub))
                           .replace("__CONTEXT__", task.get("context") or "（无）")
                           .replace("__VERIFY_HINT__", _verify_hint(task))) + prog
                 role = "implement" if len(subtasks) == 1 else "implement-%d/%d" % (i + 1, len(subtasks))
@@ -1421,7 +1435,8 @@ RESEARCH_APPENDIX = """
   单源信息要标注「仅单一来源」。
 - 引用来源在文中用行内链接或脚注标明（域名即可，不编造 URL）。
 - 区分「事实」与「观点」：数据/时间/版本号给来源，预测/评价标明是分析。
-- 结构建议：结论先行 → 分层论证 → 风险与局限（说明哪些结论证据不足）。"""
+- 结构硬性要求：报告第一段必须是「**核心结论**」三行以内的要点摘要（结论先行），
+  之后才展开分层论证 → 风险与局限（说明哪些结论证据不足）。"""
 
 NOVEL_REVISE_PROMPT = """你是一名专业作者。请根据下方汇总评审意见修订稿件文件：`__FILE__`（直接写入该文件）。文件必须以 UTF-8 编码保存（PowerShell 写文件显式加 -Encoding UTF8，禁止依赖默认编码）。
 
@@ -1647,6 +1662,10 @@ def _critique_json(res, dims):
     if isinstance(gj, dict) and isinstance(gj.get("scores"), dict) and gj.get("scores"):
         return gj
     prose = runner.scores_from_prose(text, dims)
+    if not prose:
+        # 第四道网（BAML 借鉴）：维度名没命中时按「X：N 分」模式泛化抓取——
+        # 自定义 rubric 改了维度措辞而模型用了自己的说法时仍能救回
+        prose = runner.extract_scores_from_text(text)
     if prose:
         return {"scores": prose, "issues": [], "summary": text[:400]}
     return {"scores": {}, "issues": [],
@@ -2016,9 +2035,12 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                 use_prompt = prompt
                 for draft_attempt in range(3):
                     if draft_attempt:
-                        if ev is not None and ev.is_set():
-                            break
-                        time.sleep(30 * draft_attempt)   # 30s / 60s 退避
+                        # 30s / 60s 退避；ev.wait 睡等可被取消即刻唤醒
+                        if ev is not None:
+                            if ev.wait(30 * draft_attempt):
+                                break
+                        else:
+                            time.sleep(30 * draft_attempt)
                     if draft_attempt and len(prompt) > 12000 and sk_block and sk_block in prompt:
                         # 长提示词在容量受限通道（讯飞托管 35B 等）上会挂起/秒拒
                         # ——分层降级：经验库→4K、模块库按模块边界、圣经按二级标题
@@ -2103,9 +2125,12 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                 for race_round in range(2):
                     # 全变体失败（网关突发限流）→ 60s 退避重赛一轮，别一章判死
                     if race_round:
-                        if ev is not None and ev.is_set():
-                            break
-                        time.sleep(60)
+                        # ev.wait 睡等可被取消即刻唤醒
+                        if ev is not None:
+                            if ev.wait(60):
+                                break
+                        else:
+                            time.sleep(60)
                         for kk in range(n_variants):
                             # 清上一轮残稿：防陈旧半成品被本轮评分误认成新成品
                             try:
@@ -3008,11 +3033,28 @@ def _write_task_evidence(run_id, task, workdir, summary_lines):
             for ln in summary_lines:
                 f.write("- %s\n" % str(ln)[:300])
             f.write("\n")
+        _archive_stamp(run_id, task, workdir, summary_lines)
         return path
     except Exception:
         return ""
 
 
+def _archive_stamp(run_id, task, workdir, summary_lines):
+    """归档戳（借鉴 OpenSpec archive）：evidence 落盘后向 spec.md 尾部追加
+    「已完成」快照行——spec 从「意图」升格为「意图+交付记录」的活档案。
+    失败静默。"""
+    try:
+        spec = os.path.join(workdir, ".codebee", "spec.md")
+        if not os.path.isfile(spec):
+            return
+        with open(spec, "a", encoding="utf-8") as f:
+            f.write("\n---\n**✅ 已交付** · %s · run %s\n%s\n" % (
+                _now(), run_id,
+                "\n".join("- %s" % str(ln)[:160] for ln in summary_lines[:5])))
+    except Exception:
+        return
+
+
 def _evidence_lines_from_run(run_id, task):
     """从 run 步骤与 verdict 提取证据行（确定性事实，不抄模型输出）。"""
     run = store.get_run(run_id) or {}

package/app/core/planner.py

@@ -12,7 +12,7 @@ import os
 import re
 import time
 
-from . import modelhub, runner, skills, usage
+from . import knowledge, modelhub, runner, skills, usage
 
 MAX_SUBTASKS = 4
 DEFAULT_OUTLINE_TIMEOUT = 900   # 8 章大纲 + 经验包注入是重生成任务，300s 实测不够
@@ -116,10 +116,16 @@ def _log_usage(source, role, task, res, agent=None, tool="", model="", provider=
 
 CODE_PLAN_PROMPT = """你是技术负责人。请把下面的开发目标拆解为 __N__ 个以内、按顺序执行的子任务，
 并判定任务难度。只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
-{"difficulty": "easy 或 hard", "subtasks": [{"title": "简短标题", "detail": "具体要做什么，给执行工程师的直接指令"}]}
+{"difficulty": "easy 或 hard", "subtasks": [{"title": "简短标题", "detail": "具体要做什么，给执行工程师的直接指令", "files": ["涉及的文件路径"]}]}
 难度判定：常规增删改查/小函数/格式调整 = easy；跨模块改动/架构调整/复杂算法/安全相关 = hard。
 子任务粒度要可独立验证；最后一个子任务必须包含整体联调/收尾。
 
+## 先探索再计划（重要，借鉴 OpenSpec explore）
+拆解之前先用你的读文件/搜索工具**实际查看工作目录**，找到目标相关的真实文件与函数，再据此拆解。
+detail 必须点名真实存在的文件路径；files 列出该子任务会改动的文件（新建的写目标路径）。
+**没探索过就不要凭想象编路径**——计划的可执行性取决于它对真实代码库的贴合度。
+若工作目录为空（全新项目），files 写计划新建的文件路径。
+
 ## 开发目标
 __GOAL__
 
@@ -274,6 +280,9 @@ def make_serial_outline(task, author_agent=None, workdir=None, ev=None, log_path
     wpc = int(serial.get("words_per_chapter") or 2500)
     start = int(serial.get("start_chapter") or 1)
     sk_block, _ = skills.block_for(task)
+    kb_block = knowledge.block_for(task)
+    if kb_block:
+        sk_block = (sk_block + "\n\n" + kb_block) if sk_block else kb_block
     prev_title = ""
     if start > 1:
         prev_lines, done, prev_title, prev_tail = _prev_serial_story(task)
@@ -367,7 +376,10 @@ def make_serial_outline(task, author_agent=None, workdir=None, ev=None, log_path
 
 
 def _norm_subtasks(data):
-    """规范化 LLM 计划输出；不合规返回 None。"""
+    """规范化 LLM 计划输出；不合规返回 None。
+
+    files 字段（OpenSpec explore 借鉴）：计划锚定的真实文件清单，透传给执行步
+    让实现者知道改动面（缺失/非法时留空，向后兼容旧计划）。"""
     if not isinstance(data, dict):
         return None
     subs = data.get("subtasks")
@@ -381,7 +393,13 @@ def _norm_subtasks(data):
         detail = str(s.get("detail") or "").strip()
         if not title:
             continue
-        steps.append({"title": title[:60], "detail": detail[:1500]})
+        step = {"title": title[:60], "detail": detail[:1500]}
+        files = s.get("files")
+        if isinstance(files, list):
+            clean = [str(f).strip()[:200] for f in files if str(f).strip()][:10]
+            if clean:
+                step["files"] = clean
+        steps.append(step)
     return steps or None
 
 

package/app/core/publish/manager.py

@@ -86,16 +86,56 @@ def view():
 
 
 def recover_orphans():
-    """启动收尸：waiting_login / busy 的线程随进程重启死掉，统一改判 error。"""
+    """启动收尸：waiting_login / busy 的线程随进程重启死掉，统一改判 error。
+
+    升级自愈：旧版「等扫码窗口一关就冤判超时」留下的 error（error 文案带
+    「等待登录超时」）排队后台复核——profile 登录态还在的直接翻 connected，
+    别让升级完还挂着旧冤案；attach 不到活实例就维持原样（用户点重连时
+    新终审逻辑自会兜住）。"""
     _load()
     n = 0
+    stale = []
     for plat in PLATFORMS:
-        if _st(plat).get("status") in ("waiting_login", "busy"):
+        s = _st(plat)
+        if s.get("status") in ("waiting_login", "busy"):
             _set(plat, status="error", error="上次操作随服务重启中断，请重试")
             n += 1
+        elif s.get("status") == "error" and "等待登录超时" in (s.get("error") or ""):
+            stale.append(plat)
+    if stale:
+        threading.Thread(target=_recheck_stale_errors, args=(stale,),
+                         daemon=True, name="pub-stale-recheck").start()
     return n
 
 
+def _recheck_stale_errors(plats):
+    """旧版假超时的后台复核：只 attach 还活着的浏览器实例（绝不 launch——
+    升级重启时静默弹窗口吓人），登录态复核过了翻 connected；否则不动。"""
+    for plat in plats:
+        if _st(plat).get("status") != "error":
+            continue                  # 用户已先行操作（重连/断开），别覆盖
+        port = _st(plat).get("port") or 0
+        if not port:
+            continue
+        try:
+            b = Browser.attach(int(port))
+        except Exception:
+            continue                  # 实例已死：不 launch，维持原错误
+        with LOCK:
+            _browsers[plat] = b
+        page = b.first_page(create=False)
+        if page is None:
+            continue
+        try:
+            ok, _u = _check_login(plat, page)
+        except Exception:
+            continue
+        if ok and _st(plat).get("status") == "error":
+            _set(plat, status="connected", error="",
+                 last_login=time.strftime("%m-%d %H:%M"))
+            ledger.record(plat, "connect", ok=True)
+
+
 # ---------------------------------------------------------------- 浏览器会话
 def _profiles_base():
     """profile 存放根：用户主目录 ~/.codebee/publish_profiles（仓库外）。
@@ -245,13 +285,31 @@ def connect(plat):
             except (BrowserError, Exception):
                 pass                        # 页面被用户关掉等：继续等到超时
             time.sleep(5)
-        _set(plat, status="error", error="等待登录超时（15 分钟），请重新点连接")
+        _finalize_login_wait(plat)
 
     threading.Thread(target=wait_login, daemon=True,
                      name="pub-login-%s" % plat).start()
     return True, ""
 
 
+def _finalize_login_wait(plat):
+    """等扫码超时后的终审：用户可能已在本窗口登录后把窗口关了（profile
+    里登录态还在），attach-or-launch 重拉页面再复核一次，别急着冤判
+    超时——「明明登录着却报超时」是发布卡死感的最大来源。复核也过不了
+    才落超时错误。返回 True 表示复核通过（已判 connected）。"""
+    try:
+        _b, page = _open_page(plat)
+        ok, _u = _check_login(plat, page)
+    except Exception:
+        ok = False
+    if ok:
+        _set(plat, status="connected", last_login=time.strftime("%m-%d %H:%M"))
+        ledger.record(plat, "connect", ok=True)
+    else:
+        _set(plat, status="error", error="等待登录超时（15 分钟），请重新点连接")
+    return ok
+
+
 def disconnect(plat):
     b = _browsers.pop(plat, None)
     if b:
@@ -357,6 +415,25 @@ def create_book_async(task_id, plat, auto_submit=False):
     return True, ""
 
 
+# ---------------------------------------------------------------- 动作：登记已有作品
+def register_book(task_id, plat, title, book_id=""):
+    """人工登记平台已有作品：建书流程没走通、或用户纯手工在平台上建的
+    书，补进台账让卡片翻到「已建书·发一章」，避免再点「创建作品」造出
+    重复书。只动本地台账不碰浏览器；发章按书名找书，title 必填，
+    book_id 选填（有直达 URL 时填）。已登记会覆盖更新（兼纠错口）。"""
+    from .. import store
+    if plat not in PLATFORMS:
+        return False, "未知平台"
+    if not store.get_task(task_id):
+        return False, "任务不存在"
+    title = (title or "").strip()
+    if not title:
+        return False, "作品名必填（发章按作品名在平台找书）"
+    ledger.save_book(task_id, plat, {"book_id": str(book_id or "").strip(),
+                                     "title": title[:120]})
+    return True, ""
+
+
 def _with_tag_steps(steps, groups, values, mod=None):
     """标签走数据驱动：清单进 values["_tags"]（[组名, 标签] 对），由 flow 的
     "tags" 步骤按组切换点选。组显示名映射来自**对应平台模块**的

package/app/core/runner.py

@@ -163,8 +163,26 @@ def _pipe_reader(stream, chunks, log_fh, stamp=None):
                 pass
 
 
+def _decode_line(blob):
+    """单行解码：UTF-8 → GBK → replace（与 decode_output 同一编码纪律）。"""
+    try:
+        return blob.decode("utf-8")
+    except UnicodeDecodeError:
+        pass
+    try:
+        return blob.decode("gbk")
+    except UnicodeDecodeError:
+        return blob.decode("utf-8", "replace")
+
+
 def decode_output(data):
-    """子进程输出解码：UTF-8 严格解码失败时回退 GBK（中文 Windows 控制台）。"""
+    """子进程输出解码：UTF-8 严格解码失败时回退 GBK（中文 Windows 控制台）。
+
+    整块 UTF-8 与整块 GBK 都失败时逐行兜底——日志文件是混合编码（我方 UTF-8
+    审计头 + CLI 自家 GBK 输出），整块回退会把能读的部分一起牺牲：要么头部中文
+    变乱码，要么整篇落进 replace 分支铺成 U+FFFD 墙（2026-09-20 aider 日志实证，
+    详情页卡片显示成一片 ◆）。逐行解码两边都保住（GBK/UTF-8 的多字节序列都不
+    含 0x0A，按行切不会切坏字符）。"""
     if not data:
         return ""
     try:
@@ -174,7 +192,8 @@ def decode_output(data):
     try:
         return data.decode("gbk")
     except UnicodeDecodeError:
-        return data.decode("utf-8", "replace")
+        pass
+    return "\n".join(_decode_line(ln) for ln in data.split(b"\n"))
 
 
 def read_text_any_enc(path):
@@ -201,6 +220,64 @@ def tail_decoded(data, tail):
     return decode_output(chunk[i:])
 
 
+# 终端控制序列：CSI（颜色/光标/清行，`\x1b[91m`）、OSC（窗口标题）、其余两字符转义
+_ANSI_RE = re.compile(
+    r"\x1b\[[0-9;?]*[ -/]*[@-~]"
+    r"|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?"
+    r"|\x1b[@-Z\\-_]"
+)
+# 被切片/前端截断掉 ESC 的「裸序列」残尾（`[91m`、`[0m`）：只在行首止血，
+# 正文里合法的 [数字+字母]（如 [1m] 引用）不动——后面紧跟 `]` 的不算残尾
+_ANSI_HEAD_RE = re.compile(r"^\[[0-9;?]{1,6}[A-Za-z](?!\])")
+# CLI 拿来做进度条/画框/旋转动画的图元，成串出现时人读不出任何信息
+_NOISE_RUN_RE = re.compile(r"([\u2500-\u259f\u25a0-\u25ff\u2800-\u28ff])\1{7,}")
+# 解不出来的字节（replace 兜底）成串即「乱码墙」——多数等宽字体把 U+FFFD 画成
+# 带问号的菱形，一屏看起来就是 ◆◆◆◆
+_FFFD_RUN_RE = re.compile(r"\ufffd{3,}")
+_CTRL_RE = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]")
+
+
+def strip_ansi(text):
+    """剥掉 ANSI 转义序列（颜色/光标/进度），并清掉行首被截断的裸序列残尾。"""
+    if not text:
+        return ""
+    out = _ANSI_RE.sub("", text)
+    # 残尾可能连着几个（`[91m[0mError:`），一次替换只够消掉最前面那个
+    while True:
+        nxt = "\n".join(_ANSI_HEAD_RE.sub("", ln) for ln in out.split("\n"))
+        if nxt == out:
+            return out
+        out = nxt
+
+
+def clean_cli_text(text):
+    """CLI 原始输出 → 人类可读文本（只用于错误摘要/日志展示，不碰模型正文）。
+
+    终端噪声四种，都是实测踩过的：
+    1. ANSI 转义：`\\x1b[91m\\x1b[1mError:` 在浏览器里渲染成 `[91m[1mError:`；
+    2. 裸 `\\r` 覆写：进度条/旋转动画反复回退改写同一行，原样展示会叠成一片；
+       `\\r\\n` 是行结束符不是覆写，先归一化再按覆写取「该行最终形态」；
+    3. 画线/进度图元成串（`────…`、`████…`）与 U+FFFD 乱码墙（编码不可解）；
+    4. 剩余控制字符。
+    """
+    if not text:
+        return ""
+    out = strip_ansi(text).replace("\r\n", "\n")
+    if "\r" in out:
+        lines = []
+        for ln in out.split("\n"):
+            if "\r" in ln:
+                parts = ln.split("\r")
+                ln = next((p for p in reversed(parts) if p.strip()), parts[-1])
+            lines.append(ln)
+        out = "\n".join(lines)
+    out = _CTRL_RE.sub("", out)
+    out = _FFFD_RUN_RE.sub(
+        lambda m: "…（%d 个字符无法解码：CLI 输出不是 UTF-8/GBK）" % len(m.group(0)), out)
+    out = _NOISE_RUN_RE.sub(lambda m: m.group(1) * 3 + "…", out)
+    return re.sub(r"\n{4,}", "\n\n\n", out)
+
+
 _TS_PREFIX = re.compile(r"^\d{4}-\d{2}-\d{2}T[\d:.,]+Z?\s*")
 
 
@@ -600,7 +677,11 @@ _TRANSIENT = ("503", "502", "529", "429", "no available channel", "temporarily",
               # 「非瞬态不降级」，导致跨厂商链上健康的后继模型从未被尝试。
               "unknown model", "1211", "connection error", "econnrefused",
               "connection aborted", "initialize", "reset by peer",
-              "channel is closed", "no route to host")
+              "channel is closed", "no route to host",
+              # 2026-09-20 连载评审实测：codex 网关断流（stream disconnected）
+              # 与 opencode 服务端 500（Unexpected server error）都是「重试/换将
+              # 就可能活」的瞬态病，旧表判成终态导致整链早死
+              "stream disconnected", "unexpected server error")
 
 
 def _transient_error(err):
@@ -809,8 +890,21 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None, workdir=
         stdin_text = prompt
     elif kind == "aider":
         argv = resolve_command(agent["command"]) + [
-            "--yes-always", "--no-auto-commits", "--no-check-update", "--message", prompt]
+            "--yes-always", "--no-auto-commits", "--no-check-update",
+            # 网关自定义模型名（glm-5.1 等）litellm 全都不认识，警告页+建议列表
+            # 纯属刷屏（2026-09-20 实测占满步骤日志头部）
+            "--no-show-model-warnings", "--message", prompt]
         if model:
+            # litellm 靠 provider 前缀路由，裸模型名直接报
+            # "LLM Provider NOT provided"。前缀按本条尝试实际注入的端点协议定：
+            # ANTHROPIC_BASE_URL=anthropic 面（Bigmodel 等）、OPENAI_API_BASE=
+            # openai 兼容面；都没有=CLI 本机默认场景，模型名保持用户原样
+            envd = agent.get("env") or {}
+            if "/" not in model:
+                if envd.get("ANTHROPIC_BASE_URL"):
+                    model = "anthropic/" + model
+                elif envd.get("OPENAI_API_BASE"):
+                    model = "openai/" + model
             argv += ["--model", model]
     else:  # generic：模板把 {prompt}/{session} 嵌进参数（注意 cmd 行长度限制）
         tmpl = agent.get("argv_template") or ["-p", "{prompt}"]
@@ -968,7 +1062,9 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                 # stderr 与 stdout 都要进错误串：codex 把 "Reading prompt from
                 # stdin..." 打在 stderr，真正的配额/限流错误全在 stdout 的 JSONL
                 # 里——只取其一会让 _quota_error/_transient_error 判空。
-                tail = ((res["stderr"] or "") + "\n" + (res["stdout"] or "")).strip()[-600:]
+                # 先洗后切：切片会割断 ANSI 序列，留下 `[91m` 这种裸残尾直接进 UI
+                tail = clean_cli_text(
+                    ((res["stderr"] or "") + "\n" + (res["stdout"] or ""))[-4000:]).strip()[-600:]
                 head = ("输出停滞 %ss（stall timed out，疑似卡死已提前终止）" % stall_t
                         if res.get("stalled")
                         else "超时" if res["timed_out"]
@@ -1025,7 +1121,7 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                     out["error"] = "codex: %s" % fm
                     out["error_code"] = ErrorCode.VENDOR_ERROR
                 elif not out["text"]:  # 事件流解析失败时退化为取 stdout 尾部
-                    out["text"] = res["stdout"][-2000:]
+                    out["text"] = clean_cli_text(res["stdout"][-2000:])
                 if require_tools and out["ok"] and _codex_work_events(res["stdout"]) == 0:
                     # 实现步空转闸：exit 0 + 有话但零动手 → 判拒绝（fatal 语义正确，
                     # 不把谎报的「已改完」静默传给下游；auto 模式换将逻辑按 ok 触发，
@@ -1060,7 +1156,10 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                     out["error_code"] = _classify_failure(
                         res, kind="claude", parsed=parsed, attempt_done=True)
             else:
-                out["text"] = res["stdout"].strip()
+                # generic（aider/opencode/kimi…）的 stdout 就是终端转录：ANSI 颜色、
+                # \r 进度条、画线框全在里面。不清洗的话它同时污染两处——步骤摘要
+                # （详情页卡片显示成 ◆/─ 墙）与评审 JSON 解析（转义混进正文）
+                out["text"] = clean_cli_text(res["stdout"]).strip()
                 if not out["text"]:
                     out["error_code"] = _classify_failure(res, kind=kind, empty_output=True)
             break
@@ -1162,6 +1261,27 @@ def as_scores(gj):
     return gj if isinstance(gj, dict) else None
 
 
+def extract_scores_from_text(text):
+    """评审解析第四道网（借鉴 BAML 的宽容提取）：模型把分数写成散文键值对
+    完全不出 JSON 时（2026-09-18 真实案例：kimi 正文提分），从文本直接抓
+    「维度：N 分」模式。返回 scores dict 或 {}。"""
+    if not text:
+        return {}
+    scores = {}
+    for m in re.finditer(
+            r"[\u4e00-\u9fa5A-Za-z][\u4e00-\u9fa5A-Za-z0-9 ]{0,11}"
+            r"[:：]\s*(\d{1,2}(?:\.\d)?)\s*分?", text):
+        dim = m.group(0).rsplit(":", 1)[0].rsplit("：", 1)[0].strip()
+        try:
+            val = float(m.group(1))
+        except ValueError:
+            continue
+        if not dim or dim in scores or not (1.0 <= val <= 10.0):
+            continue
+        scores[dim] = round(val, 1)
+    return scores if len(scores) >= 3 else {}
+
+
 def scores_from_prose(text, dims):
     """评审解析第三道网：agentic CLI 有时把 JSON 写进文件、stdout 只留中文
     总结（「情节 8 / 人物 8 / …」）。JSON 全灭后按维度名从正文提分；

package/app/core/selfupdate.py

@@ -18,9 +18,9 @@ SSE 可看进度）。npm 替换的是包目录文件，当前进程已加载进
 """
 from __future__ import annotations
 
-import json
-import logging
-import os
+import json
+import logging
+import os
 import re
 import socket
 import subprocess
@@ -29,11 +29,11 @@ import threading
 import time
 from pathlib import Path
 
-from . import paths, runner
-
-log = logging.getLogger(__name__)
-
-_PKG_NAME = "codebee"   # npm 发布名；必须与 package.json 的 name 一致（单测断言）
+from . import paths, runner
+
+log = logging.getLogger(__name__)
+
+_PKG_NAME = "codebee"   # npm 发布名；必须与 package.json 的 name 一致（单测断言）
 _UPDATE_TTL = 600   # 查新结果缓存（秒）
 _LOCK = threading.Lock()
 _CHECK_CACHE = {"ts": 0.0, "result": None}
@@ -161,46 +161,88 @@ def check(force=False):
     return out
 
 
-def apply_upgrade():
+def apply_upgrade():
     """发起升级：建 mgmt run 异步跑 npm install -g @latest。返回 {run_id} 或 {error}。"""
     if install_mode() != "npm":
         return {"error": "当前安装方式不支持自动升级（见版本页说明）"}
     from . import store, jobs
-    try:
-        run = store.create_run(
-            "mgmt", "升级 CodeBee 本体（npm install -g %s@latest）" % _PKG_NAME,
-            entry_id="__self__", op="selfupgrade")
-    except Exception:
-        log.exception("selfupdate: 创建升级运行记录失败")
-        return {"error": "升级任务创建失败，请稍后重试"}
-    try:
-        jobs.enqueue({"kind": "selfupgrade", "run_id": run["id"]})
-    except Exception:
-        # The run is already durable when enqueue fails. Close it explicitly so
-        # the upgrade panel cannot remain in a misleading queued state.
-        log.exception("selfupdate: 升级任务入队失败 run=%s", run["id"])
-        try:
-            store.update_run(run["id"], status="failed",
-                             error="升级任务入队失败，请稍后重试",
-                             ended_at=time.strftime("%Y-%m-%d %H:%M:%S"))
-        except Exception:
-            log.exception("selfupdate: 升级运行失败收口失败 run=%s", run["id"])
-        return {"error": "升级任务入队失败，请稍后重试", "run_id": run["id"]}
-    return {"run_id": run["id"]}
+    try:
+        run = store.create_run(
+            "mgmt", "升级 CodeBee 本体（npm install -g %s@latest）" % _PKG_NAME,
+            entry_id="__self__", op="selfupgrade")
+    except Exception:
+        log.exception("selfupdate: 创建升级运行记录失败")
+        return {"error": "升级任务创建失败，请稍后重试"}
+    try:
+        jobs.enqueue({"kind": "selfupgrade", "run_id": run["id"]})
+    except Exception:
+        # The run is already durable when enqueue fails. Close it explicitly so
+        # the upgrade panel cannot remain in a misleading queued state.
+        log.exception("selfupdate: 升级任务入队失败 run=%s", run["id"])
+        try:
+            store.update_run(run["id"], status="failed",
+                             error="升级任务入队失败，请稍后重试",
+                             ended_at=time.strftime("%Y-%m-%d %H:%M:%S"))
+        except Exception:
+            log.exception("selfupdate: 升级运行失败收口失败 run=%s", run["id"])
+        return {"error": "升级任务入队失败，请稍后重试", "run_id": run["id"]}
+    return {"run_id": run["id"]}
+
+
+_LOCKED_RE = re.compile(r"\b(EBUSY|EPERM)\b")
+_RETRY_DELAYS = (5, 15)   # 目录被占用时自动重试前的等待秒数（暂时性占用多在此窗口内释放）
+
+
+def _locked_error(res):
+    """npm 失败输出是否为「包目录被占用」类（EBUSY/EPERM）——值得等一等重试。"""
+    blob = ((res or {}).get("stderr") or "") + ((res or {}).get("stdout") or "")
+    return bool(_LOCKED_RE.search(blob[-4000:]))
+
+
+def _log_note(log_path, text):
+    """向步骤日志追加一行进度说明（run_process 以 append 模式写同一文件）。"""
+    if not log_path:
+        return
+    try:
+        with open(log_path, "ab") as fh:
+            fh.write(("\n===== %s =====\n" % text).encode("utf-8", "replace"))
+    except Exception:
+        pass
 
 
 def run_upgrade(run_id, log_path):
-    """worker 线程里执行升级命令（run/step 生命周期由 jobs 层管）。"""
-    res = runner.run_process(
-        argv=_npm_argv("install", "-g", _PKG_NAME + "@latest"),
-        # Windows 上 npm 换版本靠把包目录整体改名（codebee → .codebee-xxx）；
-        # cwd 若落在本包内，目录被自身进程占用，rename 必报 EBUSY——钉在包外
-        cwd=str(Path.home()), timeout=900, log_path=log_path)
+    """worker 线程里执行升级命令（run/step 生命周期由 jobs 层管）。
+
+    包目录被其他进程占用（EBUSY/EPERM：打开包目录的资源管理器/终端窗口、
+    杀毒或索引扫描）是升级失败的最常见原因，且多为暂时性——自动重试
+    _RETRY_DELAYS 轮，仍败则给人话结论（原始 npm 输出在步骤日志里可查）。"""
+    res = {}
+    for attempt, delay in enumerate((0,) + _RETRY_DELAYS):
+        if delay:
+            _log_note(log_path, "目录被占用（EBUSY/EPERM），%d 秒后自动重试（第 %d/%d 次）"
+                      % (delay, attempt, len(_RETRY_DELAYS)))
+            time.sleep(delay)
+        res = runner.run_process(
+            argv=_npm_argv("install", "-g", _PKG_NAME + "@latest"),
+            # Windows 上 npm 换版本靠把包目录整体改名（codebee → .codebee-xxx）；
+            # cwd 若落在本包内，目录被自身进程占用，rename 必报 EBUSY——钉在包外
+            cwd=str(Path.home()), timeout=900, log_path=log_path)
+        if res["ok"] or not _locked_error(res):
+            break
     if res["ok"]:
         with _LOCK:  # 装完即过期查新缓存，重启后自然拿到新版本
             _CHECK_CACHE["result"] = None
-    return {"ok": res["ok"], "exit_code": res["exit_code"],
-            "error": "" if res["ok"] else (res["stderr"][-800:] or "退出码 %s" % res["exit_code"])}
+        return {"ok": True, "exit_code": res["exit_code"], "error": ""}
+    stderr = res["stderr"] or ""
+    if _locked_error(res):
+        err = ("升级失败：codebee 安装目录被其他程序占用（已自动重试 %d 次未恢复）。"
+               "常见占用：打开包目录的资源管理器窗口/终端、杀毒或索引扫描。"
+               "请关闭相关窗口后回版本页重试；仍不行可退出 CodeBee 后手动执行 "
+               "npm install -g %s@latest。" % (len(_RETRY_DELAYS), _PKG_NAME))
+    else:
+        # npm 的进度条/颜色转义与中文 Windows 的 GBK 输出都进过这里，先洗再用
+        err = runner.clean_cli_text(stderr)[-800:] or "退出码 %s" % res["exit_code"]
+    return {"ok": False, "exit_code": res["exit_code"], "error": err}
 
 
 def _port_free(port):