codebee 0.1.18 → 0.1.20

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):

package/app/core/settings.py

@@ -16,9 +16,19 @@ _FILE = paths.DATA_DIR / "settings.json"
 # 「导出诊断包」是用户手动操作不受此开关限制）
 # publish_daily_cap / publish_fail_streak：自动发布护栏——每任务每平台每日
 # 成功发章上限、平台连续失败几次后暂停自动发布（publish/auto.py 读取）
+# pet_enabled / pet_mode：桌面蜜蜂（app/pet.py）开关与显示模式。关闭后看护线程
+# 不再拉起、在岗蜜蜂轮询到 false 自行退出；mode=always 常驻，tasks_only 仅任务
+# 运行时出现（空闲 90s 隐身）。
+# cleanup_enabled / cleanup_retention_days：每日垃圾清理（core/cleanup.py）——
+# 运行过程日志/发布截图/bak 残留等超期自动清理；retention 为保留天数。
 DEFAULTS = {"max_concurrent_jobs": 6, "default_workdir": "", "hooks_token": "",
             "telemetry_errors": True, "publish_daily_cap": 10,
-            "publish_fail_streak": 3, "notify_webhook": "", "notify_base_url": ""}
+            "publish_fail_streak": 3, "notify_webhook": "", "notify_base_url": "",
+            "pet_enabled": True, "pet_mode": "always", "pet_skin": "plush",
+            "cleanup_enabled": True, "cleanup_retention_days": 14}
+# 桌宠形象白名单（与 app/pet.py 的 SKINS 对齐；这里不 import pet 模块，避免
+# core 反向依赖 app 根目录脚本）
+PET_SKINS = ("plush", "robot")
 # 并发上限 12：worker 只是拉起 CLI 子进程的调度位，跨任务无共享资源；
 # 同任务单飞守卫在 jobs 层。默认 6 对齐「多任务并行不排队」的使用预期。
 MIN_WORKERS, MAX_WORKERS = 1, 12
@@ -103,6 +113,27 @@ def save(patch):
             cur["notify_webhook"] = str(patch.get("notify_webhook") or "").strip()[:300]
         if "notify_base_url" in patch:
             cur["notify_base_url"] = str(patch.get("notify_base_url") or "").strip()[:200]
+        if "pet_enabled" in patch:
+            cur["pet_enabled"] = bool(patch.get("pet_enabled"))
+        if "pet_mode" in patch:
+            pm = str(patch.get("pet_mode") or "").strip()
+            if pm not in ("always", "tasks_only"):
+                return cur, "pet_mode 只能是 always 或 tasks_only"
+            cur["pet_mode"] = pm
+        if "pet_skin" in patch:
+            ps = str(patch.get("pet_skin") or "").strip()
+            if ps not in PET_SKINS:
+                return cur, "pet_skin 只能是 %s 之一" % "/".join(PET_SKINS)
+            cur["pet_skin"] = ps
+        if "cleanup_enabled" in patch:
+            cur["cleanup_enabled"] = bool(patch.get("cleanup_enabled"))
+        if "cleanup_retention_days" in patch:
+            try:
+                cur["cleanup_retention_days"] = int(patch.get("cleanup_retention_days"))
+            except (TypeError, ValueError):
+                return cur, "cleanup_retention_days 必须是整数"
+            if not 1 <= cur["cleanup_retention_days"] <= 365:
+                return cur, "cleanup_retention_days 取值 1-365"
         _FILE.parent.mkdir(parents=True, exist_ok=True)
         tmp = _FILE.with_suffix(".tmp")
         tmp.write_text(json.dumps(cur, ensure_ascii=False, indent=2), encoding="utf-8")

package/app/core/skill_scan.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+"""skill 装前危险模式扫描（借鉴 NVIDIA SkillSpector 的静态扫描思路）。
+
+研究数据（SkillSpector 对 31,132 个 skill 的分析）：26.1% 含漏洞、5.2% 疑似
+恶意。我们在「白名单闸门 + SSRF 防护 + 剥离式检查」之外补一道**内容静态扫描**：
+装前扫 skill 正文里的危险模式，给风险提示——提示不是拦阻（用户仍可装），
+但危险必须被看见。
+
+纯内存函数：输入是文本，输出是发现列表，无网络无落盘。
+"""
+from __future__ import annotations
+
+import re
+
+# 危险模式（静态正则；命中即在装前提示行展示）
+# —— 每条：(模式, 类别, 中文说明)
+_PATTERNS = [
+    # 代码执行
+    (r"\beval\s*\(", "代码执行", "动态 eval 执行任意代码"),
+    (r"\bexec\s*\(", "代码执行", "exec 执行任意代码"),
+    (r"subprocess|os\.system|Popen", "代码执行", "起子进程执行命令"),
+    # 数据外发
+    (r"https?://(?!api\.|docs\.|github\.com|raw\.githubusercontent)[a-z0-9.-]+/(upload|collect|track|ingest|webhook|callback)",
+     "数据外发", "向非常规端点上传/回调数据"),
+    (r"requests\.post|urllib\.request|fetch\s*\(", "网络请求", "发起网络请求（确认目标可信）"),
+    # 敏感信息读取
+    (r"os\.environ|process\.env|getenv", "环境读取", "读取环境变量（可能带走密钥）"),
+    (r"\.ssh/|\.aws/|\.npmrc|\.gitconfig|credentials|\.env\b", "敏感文件", "触碰凭据/密钥文件路径"),
+    (r"keychain|credential manager|dpapi", "敏感文件", "访问系统凭据库"),
+    # 提示注入特征
+    (r"(ignore|disregard|forget).{0,30}(previous|above|prior|all).{0,20}(instruction|prompt|rule)",
+     "提示注入", "指令覆盖话术（试图无视既有规则）"),
+    (r"system prompt|开发者指令|隐藏指令", "提示注入", "提及系统提示词/隐藏指令"),
+    (r"do not (tell|reveal|mention).{0,20}(user|human|player)", "提示注入", "要求对用户隐瞒行为"),
+    # 反拒答/越权
+    (r"(you (are|must) (now|act as)|从此你是|你现在必须)", "越权人格", "试图重设助手人格"),
+    (r"exfiltrat|渗透|后门|backdoor|keylog", "可疑意图", "包含可疑渗透/后门词汇"),
+]
+
+_COMPILED = [(re.compile(p, re.I), cat, desc) for p, cat, desc in _PATTERNS]
+
+
+def scan_text(text, max_findings=12):
+    """扫描一段 skill 文本。返回 [{category, detail, line}]；空列表=干净。
+
+    line 是 1 起的行号（供装前提示定位）。同一类别只报首个命中
+    （提示行是给人看的，重复刷屏没有信息量）。"""
+    findings, seen_cats = [], set()
+    if not text:
+        return []
+    lines = text.splitlines()
+    for rx, cat, desc in _COMPILED:
+        if cat in seen_cats:
+            continue
+        for i, ln in enumerate(lines, 1):
+            if rx.search(ln):
+                findings.append({"category": cat, "detail": desc, "line": i})
+                seen_cats.add(cat)
+                break
+        if len(findings) >= max_findings:
+            break
+    return findings
+
+
+def risk_label(findings):
+    """发现列表 → 风险标签（装前提示行用）。
+
+    高危（代码执行/敏感文件/可疑意图）任一命中 = 高风险；否则有发现 = 注意；
+    空 = 干净。"""
+    if not findings:
+        return ""
+    cats = {f["category"] for f in findings}
+    if cats & {"代码执行", "敏感文件", "可疑意图", "数据外发"}:
+        return "⚠ 高风险"
+    return "△ 注意"
+
+
+def scan_summary(text):
+    """一步到位：扫描+汇总成一行提示文案（空=干净返回空串）。"""
+    fs = scan_text(text)
+    if not fs:
+        return ""
+    label = risk_label(fs)
+    top = "、".join("%s(行%d)" % (f["category"], f["line"]) for f in fs[:4])
+    more = " 等 %d 项" % len(fs) if len(fs) > 4 else ""
+    return "%s：%s%s" % (label, top, more)

package/app/core/store.py

@@ -410,6 +410,28 @@ def migrate_task_workdirs(old_root, new_root):
     return moved, skipped
 
 
+def _sanitize_run_text(r):
+    """就地清洗 run 与各步骤里的 CLI 文本字段（错误串/摘要/输出）。
+
+    写入侧与读盘侧共用：runner 已经把 ANSI/覆写/乱码墙洗过一遍，这里兜住
+    「错误串是我们自己拼的」「历史数据是旧版本写的」两条漏网路径。只动字符串
+    值，不碰结构——清洗是幂等的，重复调用无副作用。"""
+    for k in ("error", "summary"):
+        v = r.get(k)
+        if isinstance(v, str) and v:
+            r[k] = runner.clean_cli_text(v)
+    for s in r.get("steps") or []:
+        if not isinstance(s, dict):
+            continue
+        for k in ("summary", "error"):
+            v = s.get(k)
+            if isinstance(v, str) and v:
+                s[k] = runner.clean_cli_text(v)
+        # output 是智能体正文：只剥 ANSI（同 finish_step 的口径）
+        if isinstance(s.get("output"), str) and s["output"]:
+            s["output"] = runner.strip_ansi(s["output"])
+
+
 def load_all():
     with LOCK:
         for p in paths.TASKS_DIR.glob("*.json"):
@@ -422,6 +444,10 @@ def load_all():
             try:
                 r = json.loads(p.read_text(encoding="utf-8"))
                 r.pop("cancel_event", None)
+                # 存量清洗：早期版本把 CLI 的 ANSI 转义/控制字符原样写进了摘要与
+                # 错误串（`[91m[1mError:`、U+FFFD 乱码墙），读盘时统一洗一遍——
+                # 老运行不必等重跑才干净（2026-09-20「咋还有乱码」实测）
+                _sanitize_run_text(r)
                 # 队列不跨进程持久化：磁盘上仍是 queued/running 的运行必是上次进程中断的残骸
                 if r.get("status") in ("queued", "running"):
                     r["status"] = "failed"
@@ -620,6 +646,11 @@ def update_run(run_id, expected_status=None, **fields):
             return None
         if expected_status is not None and run.get("status") != expected_status:
             return None
+        for k in ("error", "summary"):
+            if isinstance(fields.get(k), str):
+                # 错误串多是我们自己拼的 CLI 尾巴（含 ANSI/覆写/乱码墙）：
+                # 落内存前洗一遍，UI/台账读到的就是干净文本
+                fields[k] = runner.clean_cli_text(fields[k])
         run.update(fields)
         # 终态收尸：run 已结束却还挂 queued/running 的步骤统一落 cancelled，
         # 语义与 recover_orphaned_runs 的启动清扫对齐（那套清跨进程遗留，
@@ -1105,7 +1136,26 @@ def retry_task(task_id):
                                if s.get("status") == "done"
                                and (s.get("role") or "").startswith("draft-c")
                                and str(s.get("role")).split("c")[-1].isdigit()})
-                if done:
+                v_scores = (prev.get("verdict") or {}).get("chapter_scores") or []
+                # 重写未达标章：上一遍完整跑完但质量未过线（verdict.publishable
+                # =False）时，未过线章的成稿与分数都不进继承——流水线对缺继承
+                # 的章走正常起草+评审，等于只重写这几章；已过线章照常复用不烧
+                # token。大纲始终继承（全章未过线时 done 清空也继承），保住全书
+                # 结构——这正是「重写未达标章」按钮（前端 done+未达标态放行
+                # retry）区别于断点续跑的语义。
+                redo = set()
+                if (prev.get("verdict") or {}).get("publishable") is False:
+                    redo = {int(c["chapter"]) for c in v_scores
+                            if not c.get("passed") and c.get("chapter") is not None}
+                if redo:
+                    done = [n for n in done if n not in redo]
+                    v_scores = [c for c in v_scores if c.get("passed")]
+                if done or redo:
+                    if redo:
+                        scores = v_scores          # 未达标重写：只带已过线章的分数
+                    else:
+                        scores = ((prev.get("verdict") or {}).get("chapter_scores")
+                                  or prev.get("chapter_scores") or [])
                     run["inherit"] = {
                         "outline": outline,
                         "done_chapters": done,
@@ -1113,8 +1163,7 @@ def retry_task(task_id):
                         # failed/cancelled 的 run 没有 verdict，退回每章实时
                         # 落账的 chapter_scores——否则多轮失败恢复会把全部
                         # 已过线章节重新评审（实测一晚白烧数百万 token）
-                        "chapter_scores": ((prev.get("verdict") or {}).get("chapter_scores")
-                                           or prev.get("chapter_scores") or []),
+                        "chapter_scores": scores,
                     }
                     break
         task["status"] = "queued"
@@ -1333,7 +1382,9 @@ def finish_step(run_id, n, status, summary="", exit_code=None,
             if s["n"] == n:
                 s["status"] = status
                 s["ended_at"] = time.strftime("%H:%M:%S")
-                s["summary"] = summary
+                # 步骤摘要是 CLI 文本的汇聚点（失败时=错误尾巴，成功时=智能体结论）：
+                # 落盘前统一清洗，避免 ANSI/覆写/乱码墙进 UI 与报告
+                s["summary"] = runner.clean_cli_text(summary)
                 s["exit_code"] = exit_code
                 s["cost_usd"] = round(cost_usd, 4)
                 s["tokens"] = tokens
@@ -1342,7 +1393,9 @@ def finish_step(run_id, n, status, summary="", exit_code=None,
                 if duration_s is not None:
                     s["duration_s"] = round(duration_s, 1)
                 if output is not None:
-                    s["output"] = str(output)[:6000]
+                    # output 是智能体正文（对话气泡直读）：只剥 ANSI，不做噪声折叠
+                    # ——正文里的装饰性长串是作者写的，不能替它省略
+                    s["output"] = runner.strip_ansi(str(output))[:6000]
                 if followups:
                     s["followups"] = list(followups)[:3]
                 break
@@ -1497,9 +1550,10 @@ def read_step_log(run_id, rel_path, tail=paths.LOG_TAIL_CHARS, pretty=False):
             text = "...(已截断)...\n" + runner.tail_decoded(data, tail)
         else:
             text = runner.decode_output(data)
-        # 折叠遥测刷屏（时间戳不同的重复 WARN）；pretty 再把 codex JSONL
-        # 事件流翻译成【消息】【命令】等可读行，日志抽屉直读"蜂在干什么"
-        text = runner.collapse_dup_lines(text)
+        # 先洗终端噪声（ANSI/覆写/乱码墙），再折叠遥测刷屏（时间戳不同的重复
+        # WARN）；pretty 最后把 codex JSONL 事件流翻译成【消息】【命令】等可读行
+        # ——顺序不能反：乱码墙会挤掉折叠分组，翻译也会把 ANSI 当正文
+        text = runner.collapse_dup_lines(runner.clean_cli_text(text))
         if pretty:
             text = runner.pretty_cli_log(text)
         return text