codebee 0.1.4 → 0.1.6

package/app/core/registry.py

@@ -66,6 +66,10 @@ def _build_agent(entry):
         # 小时级 token 配额（可选，0/缺省=不限）：路由时对本小时用量超标的
         # 智能体降权（munder-difflin 式配额感知），订阅型 CLI 不至于被单任务打爆
         "quota_tokens_per_hour": int(orch.get("quota_tokens_per_hour") or 0),
+        # 整包透传 orch：per-agent 运行时开关（timeout_ms 5E、stall_timeout_s
+        # 看门狗等）都在 runner 侧读取——此前只挑字段，catalog 上配的
+        # timeout_ms/stall 根本流不到 runner（2026-09-17 连载 c35 实测）
+        "orch": orch,
     }
 
 

package/app/core/router.py

@@ -14,9 +14,10 @@ MAX_REPAIR_ROUNDS = 2  # 自动修复循环上限
 
 
 def _binding_bonus(agent_id):
-    """绑定链可用性加分/减分：链上有可用条目 +8，解析为空（回落 CLI 本机默认）
-    -25。2026-09-16 实测：静态能力基线让配额烧干的 codex 永远压过健康备用 CLI，
-    绑定空的 CLI 更是连用户配置的模型都没用上——先按「能不能按配置跑起来」校准。"""
+    """绑定链可用性加分/减分：链上有可用条目 +8，解析为空 -25。2026-09-16 实测：
+    静态能力基线让配额烧干的 codex 永远压过健康备用 CLI，绑定空的 CLI 更是连
+    用户配置的模型都没用上——先按「能不能按配置跑起来」校准。2026-09-17 起
+    空链步骤在 pipeline 直接判失败（不再静默回落本机默认），此处只管排序。"""
     try:
         from . import modelhub
         b = modelhub.resolve_binding(agent_id)
@@ -29,8 +30,13 @@ def _history_bonus(stats, agent_id, ttype):
     s = (stats.get(agent_id) or {}).get(ttype) or {}
     if not s.get("runs"):
         return 0.0
-    win_rate = s["wins"] / s["runs"]
-    return round(18.0 * win_rate + min(6.0, s["runs"]), 1)  # 胜率为主，经验为辅
+    runs = s["runs"]
+    win_rate = s["wins"] / runs
+    # 胜率为主，经验为辅；败率要扣分且随样本量爬满（前 3 次线性加权，防一次
+    # 偶发失败把智能体埋了）。0/3 全败 = -18：常挂的 CLI 必须排到无历史的新
+    # 面孔之后（2026-09-17 前败率不扣分，0/3 还拿 +6 经验分，比没跑过还高）。
+    loss_penalty = 24.0 * (1.0 - win_rate) * min(1.0, runs / 3.0)
+    return round(18.0 * win_rate + min(6.0, runs) - loss_penalty, 1)
 
 
 def score(agent, role, ttype, stats=None):
@@ -44,11 +50,11 @@ def score(agent, role, ttype, stats=None):
     if bb > 0:
         btxt = "，绑定链可用（+%s）" % bb
     elif bb < 0:
-        btxt = "，绑定链为空将回落 CLI 本机默认配置（%s）" % bb
+        btxt = "，绑定链为空：相关步骤将判失败（%s）" % bb
     hb = _history_bonus(stats, agent.get("id"), ttype)
     total = base + bb + hb
     hs = (stats.get(agent.get("id")) or {}).get(ttype)
-    htxt = ("，历史 %d/%d 胜（+%s）" % (hs["wins"], hs["runs"], hb)) if hs else "，无历史记录"
+    htxt = ("，历史 %d/%d 胜（%s）" % (hs["wins"], hs["runs"], "%+.1f" % hb)) if hs else "，无历史记录"
     quota_txt = ""
     quota = int(agent.get("quota_tokens_per_hour") or 0)
     if quota > 0:

package/app/core/runner.py

@@ -58,6 +58,28 @@ def resolve_command(command):
     return [path]
 
 
+def _npm_shim_bypass(argv):
+    """generic 类 CLI 把提示词嵌进 argv；经 cmd /c 重解析时引号/特殊字符会把
+    提示词截烂（kimi 实测：模型只看到 UTF-8 须知、任务本体整段丢失）。识别
+    标准 npm .cmd 垫片（%_prog% + %dp0% 目标脚本），改 node 直启绕开 cmd。
+    识别不出标准形态原样返回。"""
+    if len(argv) >= 3 and argv[0] == "cmd" and argv[1] == "/c" \
+            and str(argv[2]).lower().endswith((".cmd", ".bat")):
+        shim = argv[2]
+        try:
+            text = open(shim, encoding="utf-8", errors="replace").read()
+        except Exception:
+            return argv
+        m = re.search(r'%_prog%"\s+"?%dp0%(\\[^"\n]+?\.(?:mjs|js))"?', text)
+        if not m:
+            return argv
+        script = os.path.normpath(
+            os.path.join(os.path.dirname(shim), m.group(1).lstrip("\\")))
+        node = os.path.join(os.path.dirname(shim), "node.exe")
+        return [node if os.path.isfile(node) else "node", script] + list(argv[3:])
+    return argv
+
+
 def _kill_tree(pid):
     try:
         subprocess.run(
@@ -81,18 +103,21 @@ def _drain_streams(proc, t_out, t_err, *, timeout=10):
             t.join(timeout=remaining)
 
 
-def _pipe_reader(stream, chunks, log_fh):
+def _pipe_reader(stream, chunks, log_fh, stamp=None):
     """持续读子进程管道并实时落盘。
 
     必须用 read1()：BufferedReader.read(n) 会阻塞到凑满 n 字节或 EOF，
     在长命令（npm 安装等）上等于"进程结束才一次性返回"，日志面板全程空白。
     read1() 只要有数据就返回，日志才能真正边跑边看。
+    stamp：共享 [最后输出时刻]，停滞看门狗据此判定进程是否卡死。
     """
     while True:
         b = stream.read1(65536)
         if not b:
             break
         chunks.append(b)
+        if stamp is not None:
+            stamp[0] = time.time()
         if log_fh:
             try:
                 log_fh.write(b)
@@ -258,16 +283,22 @@ def pretty_cli_log(text, max_event_chars=4000):
 
 
 def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
-                timeout=DEFAULT_TIMEOUT, cancel_event=None, log_path=None):
+                timeout=DEFAULT_TIMEOUT, cancel_event=None, log_path=None,
+                stall_timeout=0):
     """通用子进程执行：并发读管道防死锁；超时/取消杀整棵进程树。
 
-    返回 {ok, exit_code, stdout, stderr, duration, cancelled, timed_out}。
+    stall_timeout：停滞看门狗（秒，0=关闭）——超过该时长 stdout/stderr 无任何
+    新输出即判卡死，提前杀树返回（timed_out=True + stalled=True）。只对输出
+    持续流动的 CLI 开（codex JSONL 事件流）；claude json 到结束才一次性输出，
+    开了会把正常长任务误杀。
+
+    返回 {ok, exit_code, stdout, stderr, duration, cancelled, timed_out, stalled}。
     """
     if shell_cmd:
         argv = ["cmd", "/c", shell_cmd]
     if argv is None:
         return {"ok": False, "exit_code": None, "stdout": "", "stderr": "argv 为空",
-                "duration": 0.0, "cancelled": False, "timed_out": False}
+                "duration": 0.0, "cancelled": False, "timed_out": False, "stalled": False}
     full_env = scrub_env(os.environ.copy(), mode="drop")
     if env:
         # 5A：env 关键字环境变量注入用户传入的 env（属于有意注入，例如模型 API key）
@@ -302,8 +333,9 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                     "stderr": "启动失败: %r" % e, "duration": 0.0,
                     "cancelled": False, "timed_out": False}
         out_chunks, err_chunks = [], []
-        t_out = threading.Thread(target=_pipe_reader, args=(proc.stdout, out_chunks, log_fh), daemon=True)
-        t_err = threading.Thread(target=_pipe_reader, args=(proc.stderr, err_chunks, log_fh), daemon=True)
+        stamp = [time.time()]   # 最后输出时刻（两条管道共同刷新）
+        t_out = threading.Thread(target=_pipe_reader, args=(proc.stdout, out_chunks, log_fh, stamp), daemon=True)
+        t_err = threading.Thread(target=_pipe_reader, args=(proc.stderr, err_chunks, log_fh, stamp), daemon=True)
         t_out.start()
         t_err.start()
         if stdin_text is not None:
@@ -319,7 +351,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 = False
+        cancelled = timed_out = stalled = False
         while True:
             try:
                 proc.wait(timeout=0.4)
@@ -336,6 +368,14 @@ 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:
+                # 停滞看门狗：长静默多为卡死（网关挂起/CLI 假死），与其耗满总
+                # 超时不如提前杀——错误按超时归类，走既有的换模型/换将链路
+                stalled = True
+                timed_out = True
+                _kill_tree(proc.pid)
+                _drain_streams(proc, t_out, t_err, timeout=5)
+                break
         duration = round(time.time() - start, 1)
         t_out.join(timeout=5)
         t_err.join(timeout=5)
@@ -350,12 +390,15 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                 pass
         if cancelled:
             stderr += "\n[已被用户取消]"
+        elif stalled:
+            stderr += "\n[输出停滞 %ss，已终止进程树]" % stall_timeout
         elif timed_out:
             stderr += "\n[超时 %ss，已终止进程树]" % timeout
         return {
             "ok": exit_code == 0 and not cancelled and not timed_out,
             "exit_code": exit_code, "stdout": stdout, "stderr": stderr,
             "duration": duration, "cancelled": cancelled, "timed_out": timed_out,
+            "stalled": stalled,
         }
     finally:
         if log_fh:
@@ -405,6 +448,28 @@ def _parse_codex_jsonl(stdout):
     return text, usage, sid
 
 
+def _codex_work_events(stdout):
+    """统计本轮事件流里真实「动了手」的事件数（命令执行/文件改动/MCP 工具）。
+
+    实现步空转闸的客观判据：2026-09-17 mo-so 实现步模型一条命令都没发，纯口头
+    谎报「进程执行被策略拦截」却 exit 0 + 一段像模像样的总结——text 看不出敷衍，
+    command_execution 计数为 0 才是硬证据。"""
+    n = 0
+    for line in stdout.splitlines():
+        line = line.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            ev = json.loads(line)
+        except Exception:
+            continue
+        if ev.get("type") == "item.completed" and (
+                ev.get("item") or {}).get("type") in (
+                "command_execution", "file_change", "mcp_tool_call"):
+            n += 1
+    return n
+
+
 def _codex_fail_msg(stdout):
     """从 JSONL 事件流提取终态失败消息；无失败返回 ""。
 
@@ -435,10 +500,21 @@ def _codex_fail_msg(stdout):
 
 
 def _parse_claude_json(stdout):
+    data = None
     try:
         data = json.loads(stdout)
     except Exception:
-        return None
+        # stream-json：逐行事件取最后一条 type=="result"（与旧单 JSON 同构）
+        for line in stdout.splitlines():
+            line = line.strip()
+            if not line.startswith("{"):
+                continue
+            try:
+                ev = json.loads(line)
+            except Exception:
+                continue
+            if isinstance(ev, dict) and ev.get("type") == "result":
+                data = ev
     if not isinstance(data, dict):
         return None
     u = data.get("usage") or {}
@@ -478,6 +554,7 @@ def _model_flag(kind, model):
 
 _TRANSIENT = ("503", "502", "529", "429", "no available channel", "temporarily",
               "unavailable", "overloaded", "rate limit", "timeout", "timed out",
+              "输出停滞",
               # 2026-09-15 连载验收实测：网关故障形态远不止 HTTP 5xx——
               # Z.ai 报 "400 [1211] Unknown Model"（模型临时下架）、qwen 连本地
               # 端点 ECONNREFUSED、codex initialize 空响应，这些都被旧表判成
@@ -585,7 +662,21 @@ def _resolve_attempts(agent):
             for m in (models_to_try or [None])[:3]]
 
 
-def _build_call(agent, kind, sid, readonly, model, prompt, images=None):
+def _codex_sandbox(readonly):
+    """codex 沙箱档位。写步默认 danger-full-access（2026-09-17 用户拍板「默认给全部
+    权限」）：workspace-write 禁网+禁盘外写，模型偶发还会误判沙箱受限、谎报
+    「进程执行被策略拦截」直接躺平（mo-so BUG#27596 实测，沙箱探针证明命令本可跑）。
+    只读步（评审/规划）仍 read-only——评审者可写会污染 git diff 裁决。
+    env TUTTI_CODEX_SANDBOX 可钉死某档（workspace-write / read-only / danger-full-access）。"""
+    if readonly:
+        return "read-only"
+    env = os.environ.get("TUTTI_CODEX_SANDBOX", "").strip().lower()
+    if env in ("workspace-write", "read-only", "danger-full-access"):
+        return env
+    return "danger-full-access"
+
+
+def _build_call(agent, kind, sid, readonly, model, prompt, images=None, workdir=None):
     """构建一次 CLI 调用的 (argv, stdin_text, prompt)。model 可为 None=CLI 默认。
     images 为图片附件绝对路径：codex 用 -i 原生附图；其余 kind 忽略（调用方已过滤）。"""
     env = {}
@@ -602,14 +693,13 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None):
                 "--skip-git-repo-check", "--json"]
             if model:
                 argv += ["-m", model]
-            argv += ["-c", 'sandbox_mode="%s"' %
-                     ("read-only" if readonly else "workspace-write")]
+            argv += ["-c", 'sandbox_mode="%s"' % _codex_sandbox(readonly)]
             if cp:
                 argv += _codex_provider_args(cp)
         else:
             argv = resolve_command(agent["command"]) + [
                 "exec", "--skip-git-repo-check", "--json",
-                "-s", "read-only" if readonly else "workspace-write"]
+                "-s", _codex_sandbox(readonly)]
             if model:
                 argv += ["-m", model]
             if cp:
@@ -620,7 +710,10 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None):
             argv += ["-i", p]
         stdin_text = prompt
     elif kind == "claude":
-        argv = resolve_command(agent["command"]) + ["-p", "--output-format", "json"]
+        # stream-json（2026-09-17 起）：逐行事件边跑边吐——停滞看门狗有得看，
+        # 步骤日志实时可读；result 末行与旧单 JSON 同构，解析器双形态兼容
+        argv = resolve_command(agent["command"]) + [
+            "-p", "--output-format", "stream-json", "--verbose"]
         if sid:
             argv += ["--resume", sid]
         if model:
@@ -629,15 +722,27 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None):
             # 实测本机自定义网关在 -p 模式下工具续接会丢最终结果（用工具必空）。
             # 评审/规划所需的上下文已内嵌在提示词中，显式禁用工具最稳。
             prompt = "（请勿使用任何工具，直接依据下方内容回答。）\n\n" + prompt
-        else:
+        elif os.environ.get("TUTTI_CLAUDE_PERMS", "").strip() == "acceptEdits":
             argv += ["--permission-mode", "acceptEdits"]
+        else:
+            # 无人值守 -p 下 acceptEdits 只自动放行改文件，Bash 一律权限拒绝 →
+            # 模型以为环境受限谎报「被策略拦截」躺平（同 codex 沙箱误判案）。
+            # 默认跳过全部权限检查（2026-09-17 用户拍板），env 可收回旧行为。
+            argv += ["--dangerously-skip-permissions"]
         stdin_text = prompt
     elif kind == "opencode":
         argv = resolve_command(agent["command"]) + ["run"]
+        if workdir:
+            # opencode 的 shell 不总跟进程 cwd 走（服务端复用时会落在旧项目根，
+            # 2026-09-17 mo-so 实测 agent 在 Temp 里全盘找代码）——显式钉死
+            argv += ["--dir", str(workdir)]
         if sid:
             argv += ["-s", sid]  # 无头续会话：-s 指定会话 id（-c 只能接最近一次）
         if model:
-            argv += ["--model", model]
+            # opencode 只认 provider/model 全名（裸名直接 UnknownError，实测）；
+            # CodeBee 同步进其配置的 provider id 固定为 orch，故裸名补前缀。
+            # 绑定里已写全名（含 /）的尊重原值。
+            argv += ["--model", model if "/" in model else "orch/" + model]
         stdin_text = prompt  # 无位置参数且 stdin 有内容时读 stdin
     elif kind == "qwen":  # gemini-cli 系：无参数且 stdin 有内容时读 stdin
         argv = resolve_command(agent["command"])
@@ -657,6 +762,8 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None):
             tmpl = agent["resume_argv_template"]
         argv = resolve_command(agent["command"]) + [
             str(a).replace("{prompt}", prompt).replace("{session}", sid) for a in tmpl]
+        # 提示词在 argv 里 → 必须绕开 cmd 重解析（见 _npm_shim_bypass）
+        argv = _npm_shim_bypass(argv)
         if "{prompt}" not in tmpl:
             stdin_text = prompt  # 恢复模板不带 {prompt}：提示词走 stdin（mimo 实测支持）
     return argv, stdin_text, prompt
@@ -682,9 +789,20 @@ def _check_approval(agent):
     return False, "sensitive step requires policy=ask UI flow (Phase 5) — currently blocking"
 
 
+def _stall_timeout(env_name, default):
+    """停滞看门狗秒数：stdout/stderr 持续无新输出超过该时长 → 判卡死提前杀，
+    错误按超时归类走既有换模型/换将链路。只对事件流持续流动的 CLI 启用
+    （codex JSONL / claude stream-json）；qwen/opencode/generic 结束才一次性
+    输出，开了会误杀正常长任务，仍靠总超时兜底。env 可调，0=关闭。"""
+    try:
+        return max(0, int(os.environ.get(env_name, str(default))))
+    except Exception:
+        return default
+
+
 def run_agent(agent, prompt, workdir=None, readonly=True,
               timeout=DEFAULT_TIMEOUT, cancel_event=None, log_path=None, resume=None,
-              images=None):
+              images=None, require_tools=False):
     """执行一次智能体调用，返回统一结构
     {ok, text, json, cost_usd, tokens, error, error_code, raw}。
     agent 来自 registry.effective_agents()；resume 为已有会话 id，仅真实智能体生效
@@ -692,6 +810,9 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
     generic: catalog orch.resume_argv_template）。
     images：任务图片附件的绝对路径，仅 codex 原生支持（-i）；其余智能体靠
     提示词里的 _attachments/ 路径 + 自身读文件能力获取，无读图工具时静默忽略。
+    require_tools：实现步空转闸（仅 codex 事件流可判）——True 时本轮零
+    command_execution/file_change/mcp_tool_call 事件即判 VENDOR_REFUSAL，
+    防模型纯口头谎报「环境受限」蒙混过关（2026-09-17 mo-so 实测）。
 
     模型尝试顺序来自 _resolve_attempts：跨厂商链（每条独立 env）或
     主模型 + 降级备选；瞬态错误才换下一条，取消/超时/解析失败不降级。
@@ -703,6 +824,18 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
     if orch_timeout_ms:
         timeout = float(orch_timeout_ms) / 1000.0
     kind = agent.get("kind", "generic")
+    if kind == "codex":
+        stall_t = _stall_timeout("TUTTI_CODEX_STALL_TIMEOUT", 600)
+    elif kind == "claude":
+        stall_t = _stall_timeout("TUTTI_CLAUDE_STALL_TIMEOUT", 600)
+    else:
+        # 数据驱动：catalog orch.stall_timeout_s——给 kimi 这类边写边吐进度行的
+        # CLI 配置后，静默挂死 10 分钟即杀（不必耗满总超时）；qwen/mimo 这类
+        # 结束才一次性输出的留 0（开了必误杀），靠总超时兜底
+        try:
+            stall_t = max(0, int((agent.get("orch") or {}).get("stall_timeout_s") or 0))
+        except Exception:
+            stall_t = 0
     # 5G：approval NEVER 一线（无人值守不静默降级）
     ok, reason = _check_approval(agent)
     if not ok:
@@ -745,9 +878,11 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
         for attempt in range(2):  # claude 偶发空响应（0 token）自动重试一次
             argv, stdin_text, prompt_eff = _build_call(eff_agent, kind, sid, readonly,
                                                        att["model"], prompt,
-                                                       images=images if kind == "codex" else None)
+                                                       images=images if kind == "codex" else None,
+                                                       workdir=workdir)
             res = run_process(argv=argv, stdin_text=stdin_text, cwd=workdir, env=env,
-                              timeout=timeout, cancel_event=cancel_event, log_path=log_path)
+                              timeout=timeout, cancel_event=cancel_event, log_path=log_path,
+                              stall_timeout=stall_t)
             out = {"ok": res["ok"], "text": "", "json": None, "cost_usd": 0.0,
                    "tokens": 0, "usage": None, "error": "", "error_code": "",
                    "sid": "", "raw": res, "kind": kind, "model": att["model"]}
@@ -756,9 +891,12 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                 # stdin..." 打在 stderr，真正的配额/限流错误全在 stdout 的 JSONL
                 # 里——只取其一会让 _quota_error/_transient_error 判空。
                 tail = ((res["stderr"] or "") + "\n" + (res["stdout"] or "")).strip()[-600:]
-                out["error"] = (("超时" if res["timed_out"] else "取消" if res["cancelled"]
-                                 else "退出码 %s" % res["exit_code"])
-                                + ("；stderr/stdout: " + tail if tail else ""))
+                head = ("输出停滞 %ss（stall timed out，疑似卡死已提前终止）" % stall_t
+                        if res.get("stalled")
+                        else "超时" if res["timed_out"]
+                        else "取消" if res["cancelled"]
+                        else "退出码 %s" % res["exit_code"])
+                out["error"] = head + ("；stderr/stdout: " + tail if tail else "")
                 if kind == "codex":
                     fm = _codex_fail_msg(res["stdout"])
                     if fm:
@@ -769,6 +907,32 @@ 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):
+                        # codex 撞 chat-only 供应商（0.154 只讲 responses）：
+                        # 自动冷却该供应商 30 分钟，链展开/路由绑定分随之
+                        # 自动绕开——不用人工改绑定（2026-09-17 mo-so 实测）
+                        try:
+                            from . import modelhub as _mh
+                            _mh.note_codex_wire_dead(att["provider_id"])
+                        except Exception:
+                            pass
+                elif "no model configured" in out["error"].lower():
+                    # CLI 本体没配置（kimi 实测）→ 运行期自愈：把绑定注入其
+                    # 自家配置，本次换将之后的下一轮即可用
+                    try:
+                        from . import manager as _mg
+                        note = _mg.sync_cli_config_now(agent.get("id", ""))
+                        if note and log_path:
+                            try:
+                                with open(log_path, "a", encoding="utf-8") as fh:
+                                    fh.write("\n[自愈] %s\n" % note)
+                            except Exception:
+                                pass
+                    except Exception:
+                        pass
                 out["error_code"] = _classify_failure(res, kind=kind)
                 break
             if kind == "codex":
@@ -784,6 +948,15 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                     out["error_code"] = ErrorCode.VENDOR_ERROR
                 elif not out["text"]:  # 事件流解析失败时退化为取 stdout 尾部
                     out["text"] = res["stdout"][-2000:]
+                if require_tools and out["ok"] and _codex_work_events(res["stdout"]) == 0:
+                    # 实现步空转闸：exit 0 + 有话但零动手 → 判拒绝（fatal 语义正确，
+                    # 不把谎报的「已改完」静默传给下游；auto 模式换将逻辑按 ok 触发，
+                    # 仍可换别的 CLI 再试）。原文尾段留进错误供人核对。
+                    out["ok"] = False
+                    out["error"] = ("实现步零工具调用：模型未执行任何命令/文件改动，"
+                                    "仅口头汇报（典型如谎报环境受限）。回答尾段: %s"
+                                    % (out["text"] or "")[-300:])
+                    out["error_code"] = ErrorCode.VENDOR_REFUSAL
                 if not out["text"] and out["ok"]:
                     out["error_code"] = _classify_failure(res, kind="codex", empty_output=True)
             elif kind == "claude":

package/app/core/selfupdate.py

@@ -62,23 +62,71 @@ def _ver_tuple(s):
     return [int(x) for x in re.findall(r"\d+", str(s or ""))[:4]]
 
 
-def _npm_latest():
-    """npm view codebee version；返回 (latest, err)。
-    用 _PKG_NAME 变量而非行内字面量：发布名改过一次（tutti-orchestrator→codebee），
-    硬编码两处容易漏改；Mimosa 安全基线要求 argv 可执行文件为字面量，参数用变量不违反。"""
+_RELNOTES_RE = re.compile(
+    r"<!--\s*relnotes:start\s*-->(.*?)<!--\s*relnotes:end\s*-->", re.S)
+
+
+def _relnotes(readme):
+    """README 里 relnotes 标记段的内容（发布前手工更新，见 CHANGELOG.md 头部说明）。"""
+    m = _RELNOTES_RE.search(str(readme or ""))
+    return m.group(1).strip() if m else ""
+
+
+def _npm_meta():
+    """npm view <pkg> --json；返回 (latest, relnotes, err)。
+
+    relnotes 来自 registry 元数据里的 README（与查新同一条 npm 通道，不依赖
+    GitHub 连通性），展示「新版本更新内容」用。部分 npm 版本 --json 不带
+    readme 字段，此时回退到 `npm view <pkg> readme` 纯文本再提取。"""
     r = runner.run_process(
-        argv=["cmd", "/c", "npm", "view", _PKG_NAME, "version"], timeout=60)
+        argv=["cmd", "/c", "npm", "view", _PKG_NAME, "--json"], timeout=60)
     if not r["ok"]:
-        return "", (r["stderr"] or r["stdout"] or "")[-200:] or "npm 命令失败"
-    m = re.search(r"\d+\.\d+\.\d+[\w.\-]*", r["stdout"] or "")
-    return (m.group(0) if m else ""), ("" if m else "npm 输出无法解析")
+        return "", "", (r["stderr"] or r["stdout"] or "")[-200:] or "npm 命令失败"
+    ver, notes = "", ""
+    try:
+        meta = json.loads(r["stdout"] or "{}")
+        if isinstance(meta, dict):
+            ver = str(meta.get("version") or "")
+            notes = _relnotes(meta.get("readme") or "")
+    except Exception:
+        pass
+    if not ver:  # 旧 npm --json 失败时退回纯文本解析
+        m = re.search(r"\d+\.\d+\.\d+[\w.\-]*", r["stdout"] or "")
+        ver = m.group(0) if m else ""
+    if ver and not notes:
+        r2 = runner.run_process(
+            argv=["cmd", "/c", "npm", "view", _PKG_NAME, "readme"], timeout=60)
+        if r2["ok"]:
+            notes = _relnotes(r2["stdout"] or "")
+    return ver, notes, ("" if ver else "npm 输出无法解析")
+
+
+def changelog_section(version):
+    """本地 CHANGELOG.md 中 version 对应小节（升级重启后「本次更新内容」用）。"""
+    v = re.escape(str(version or "").lstrip("v"))
+    m = re.search(r"(?ms)^## v?%s\b[^\n]*$(.*?)(?=^## |\Z)" % v,
+                  _read_changelog())
+    if not m:
+        return ""
+    body = m.group(0).strip()
+    return body
+
+
+def _read_changelog():
+    try:
+        return (paths.ROOT / "CHANGELOG.md").read_text(encoding="utf-8")
+    except Exception:
+        return ""
 
 
 def check(force=False):
-    """GET /api/selfupdate 载荷：{mode, current, latest, has_update, note}。"""
+    """GET /api/selfupdate 载荷：{mode, current, latest, has_update, note,
+    notes, whatsnew}。notes=远端新版本的更新内容（npm readme relnotes 段）；
+    whatsnew=当前版本在本地 CHANGELOG.md 的小节（升级重启后弹「本次更新内容」）。"""
     mode = install_mode()
     cur = package_version()
-    out = {"mode": mode, "current": cur, "latest": "", "has_update": False, "note": ""}
+    out = {"mode": mode, "current": cur, "latest": "", "has_update": False,
+           "note": "", "notes": "", "whatsnew": changelog_section(cur)}
     if mode != "npm":
         out["note"] = ("开发仓库模式：请用 git pull 更新（自动升级会覆盖未提交的代码）"
                        if mode == "repo" else "非 npm 安装，无法自动更新")
@@ -87,8 +135,9 @@ def check(force=False):
         if not force and _CHECK_CACHE["result"] and \
                 time.time() - _CHECK_CACHE["ts"] < _UPDATE_TTL:
             return dict(_CHECK_CACHE["result"])
-    latest, err = _npm_latest()
+    latest, notes, err = _npm_meta()
     out["latest"] = latest
+    out["notes"] = notes
     if err:
         out["note"] = "查询新版本失败：" + err
     elif latest and cur:

package/app/core/store.py

@@ -244,8 +244,9 @@ def _valid_id(task_id):
 def set_book_meta(task_id, platform, entry):
     """写任务的作品信息状态（book_meta[platform] = {status, data?, error?, at}）。
 
-    一键生成是后台线程跑的，前端靠任务 JSON 里的这个字段看进度（SSE 推送）。
-    任务不存在返回 False。"""
+    一键生成是后台线程跑的，前端靠任务 JSON 里的这个字段看进度。这里必须
+    bump_state：SSE 存活时前端不主动拉状态，不推送则卡片停在旧状态（点生成
+    不翻「生成中」、跑完不翻「已生成」）。任务不存在返回 False。"""
     if not _valid_id(task_id):
         return False
     with LOCK:
@@ -254,6 +255,7 @@ def set_book_meta(task_id, platform, entry):
             return False
         task.setdefault("book_meta", {})[platform] = entry
         _save_json(paths.TASKS_DIR / (task_id + ".json"), task)
+    bump_state()
     return True