codebee 0.1.73 → 0.1.76

package/app/core/runner.py

@@ -12,6 +12,7 @@
 """
 from __future__ import annotations
 
+import glob
 import json
 import os
 import re
@@ -68,10 +69,50 @@ def find_git_bash():
     return None
 
 
+_CLI_EXTS = (".exe", ".cmd", ".bat")
+
+
+def _fallback_probe_cli(name):
+    """which() 落空时按常见安装位兜底找 CLI（Windows only），返回全路径或 None。
+
+    服务进程的 PATH 是启动那一刻的快照：CLI 在服务起跑之后才安装/迁移（如
+    2026-09-30 claude 转 winget 原生安装）时，快照里没有新目录，which 解析
+    不到、裸名直传 Popen 直接 FileNotFoundError，直到重启服务才自愈。这里
+    只探测磁盘已知落点，不改 PATH、不缓存（装没装是低频事件，探几次不亏）。
+    """
+    if os.name != "nt":
+        return None
+    name = str(name)
+    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]*", name):
+        return None   # 带斜杠/参数形态的不是裸命令名，交给原路径逻辑
+    local = os.environ.get("LOCALAPPDATA") or ""
+    home = os.path.expanduser("~")
+    appdata = os.environ.get("APPDATA") or os.path.join(home, "AppData", "Roaming")
+    flat_dirs = (
+        os.path.join(local, "Microsoft", "WinGet", "Links"),
+        os.path.join(home, ".local", "bin"),
+        os.path.join(appdata, "npm"),
+    )
+    for d in flat_dirs:
+        for ext in _CLI_EXTS:
+            p = os.path.join(d, name + ext)
+            if os.path.isfile(p):
+                return p
+    # winget 便携包：Packages\<厂商.Id_*>\name.EXE（目录名带来源哈希，glob 一层）
+    pkgs = os.path.join(local, "Microsoft", "WinGet", "Packages")
+    try:
+        for p in glob.glob(os.path.join(pkgs, "*", name + ".*")):
+            if p.lower().endswith(_CLI_EXTS) and os.path.isfile(p):
+                return p
+    except OSError:
+        pass
+    return None
+
+
 def resolve_command(command):
     """命令名 → 可直接 spawn 的 argv 前缀（.cmd/.bat 垫片必须经 cmd /c）。"""
-    path = shutil.which(command) or command
-    low = path.lower()
+    path = shutil.which(command) or _fallback_probe_cli(command) or command
+    low = str(path).lower()
     if low.endswith(".cmd") or low.endswith(".bat"):
         return ["cmd", "/c", path]
     return [path]
@@ -719,6 +760,18 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                 stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                 creationflags=CREATE_NO_WINDOW,
                 start_new_session=(os.name != "nt"))  # POSIX 需独立进程组供 killpg 杀树；Windows 忽略该参数
+        except FileNotFoundError as e:
+            # filename=None 时 %r 只有一句「系统找不到指定的文件」，无从排查
+            # （2026-09-30 claude winget 迁移实案：服务 PATH 快照过旧）。
+            # e.filename 在场（如 POSIX cwd 缺失）时点名真实缺失路径，不猜 argv[0]。
+            tgt = str(e.filename) if getattr(e, "filename", None) \
+                else (str(argv[0]) if argv else "")
+            return {"ok": False, "exit_code": None, "stdout": "",
+                    "stderr": ("启动失败：找不到可执行文件「%s」。CLI 未安装或已卸载；"
+                               "若刚安装，重启 CodeBee 服务让 PATH 生效即可。"
+                               % tgt),
+                    "duration": 0.0, "cancelled": False, "timed_out": False,
+                    "stalled": False, "deadline_exceeded": False, "abort_marker": None}
         except Exception as e:
             return {"ok": False, "exit_code": None, "stdout": "",
                     "stderr": "启动失败: %r" % e, "duration": 0.0,
@@ -1503,9 +1556,20 @@ def _build_call(agent, kind, sid, readonly, model, prompt, images=None, workdir=
             and argv.count(prompt) == 1:
         pf = _prompt_to_file(prompt, workdir)
         if pf:
-            argv[argv.index(prompt)] = (
-                "[系统] 本次完整指令因命令行长度限制已写入文件：%s\n"
-                "请先用读文件工具完整读取该文件，然后把文件内容当作你的任务指令执行。" % pf)
+            if kind == "aider":
+                # aider 非交互态没有「读文件工具」语义：--message 指挥它读文件
+                # 会被模型判定为提示注入直接拒绝（2026-10-03 不周山守村人全局
+                # 评审实案：glm-5.3 十秒交白卷 → 全局有效评审恒 1 名，门禁
+                # 「≥2 名」结构性不可能通过）。aider 的 --read 把文件作为只读
+                # 会话文件由 CLI 自己读入，语义与交互式 aider file.md 一致。
+                argv[argv.index(prompt)] = (
+                    "本次完整任务指令已作为只读文件加入会话，"
+                    "请直接依据该文件内容执行任务。")
+                argv += ["--read", pf]
+            else:
+                argv[argv.index(prompt)] = (
+                    "[系统] 本次完整指令因命令行长度限制已写入文件：%s\n"
+                    "请先用读文件工具完整读取该文件，然后把文件内容当作你的任务指令执行。" % pf)
             # Keep the original payload on stdin as a compatibility path for
             # simple generic adapters and test shims that read stdin. CLI tools
             # that intentionally use argv still receive the bounded file hint.
@@ -1578,6 +1642,30 @@ def _invalid_model(model):
     return str(model or "").strip().lower() in _INVALID_MODEL_NAMES
 
 
+# opencode 启动横幅形如「> build · glm-5.3」（ANSI 清洗后一行、圆点分隔）；
+# 真错误（配额/配置/网络）CLI 都会另打印文本，不会是纯横幅形态
+_OC_BANNER_LINE_RE = re.compile(r"^\s*>?\s*[^\s·•]+\s*[·•]\s*\S+\s*$")
+
+
+def _opencode_fast_banner_death(res):
+    """opencode 启动期秒退签名：退出码 1、总时长很短、输出清洗 ANSI 后只剩
+    启动横幅、没有任何错误文本。真实失败不走这个形态；该形态只值得原地
+    立即重试一次（配置写读竞态/端口抢占类瞬时抖动，2026-09-30 实案：
+    并行评审爆发期连续三发「退出码 1；stderr/stdout: > build · glm-5.3」，
+    数分钟后同进程自愈）。"""
+    if res.get("ok") or res.get("exit_code") != 1:
+        return False
+    try:
+        if float(res.get("duration") or 0) > 15.0:
+            return False
+    except (TypeError, ValueError):
+        return False
+    blob = clean_cli_text((res.get("stderr") or "") + "\n"
+                          + (res.get("stdout") or ""))
+    lines = [ln.strip() for ln in blob.splitlines() if ln.strip()]
+    return bool(lines) and all(_OC_BANNER_LINE_RE.match(ln) for ln in lines)
+
+
 def run_agent(agent, prompt, workdir=None, readonly=True,
               timeout=DEFAULT_TIMEOUT, cancel_event=None, log_path=None, resume=None,
               images=None, require_tools=False, deadline=None):
@@ -1801,6 +1889,14 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                    "provider_id": att.get("provider_id") or "",
                    "provider": att.get("provider") or {}}
             if not res["ok"]:
+                if (kind == "opencode" and attempt == 0
+                        and _opencode_fast_banner_death(res)
+                        and not (cancel_event is not None
+                                 and cancel_event.is_set())):
+                    _log_note(log_path,
+                              "opencode 启动即退（仅横幅无错误文本）——按瞬时抖动 2s 后原地重试一次")
+                    time.sleep(2.0)
+                    continue
                 # stderr 与 stdout 都要进错误串：codex 把 "Reading prompt from
                 # stdin..." 打在 stderr，真正的配额/限流错误全在 stdout 的 JSONL
                 # 里——只取其一会让 _quota_error/_transient_error 判空。

package/app/core/store.py

@@ -195,6 +195,18 @@ def create_task(payload):
     # 参数修订号（借鉴 WorkDSH 契约纪律 expectedRevision）：写接口据此做过期
     # 写入检测。老任务无此键按 1 处理；不带 expected_rev 的调用不受影响。
     task["rev"] = 1
+    # Durable task contract: acceptance criteria and approval requirement are
+    # persisted outside the task JSON so evidence/audit history survives task
+    # parameter edits and can be consumed by API/MCP clients independently.
+    raw_criteria = payload.get("acceptance_criteria")
+    if raw_criteria not in (None, "") and not isinstance(raw_criteria, list):
+        raise ValueError("acceptance_criteria 必须是列表")
+    task["acceptance_criteria"] = [str(x).strip()[:500] for x in
+                                    (raw_criteria or []) if str(x).strip()][:40]
+    approval_required = payload.get("approval_required", False)
+    if not isinstance(approval_required, bool):
+        raise ValueError("approval_required 必须是布尔值")
+    task["approval_required"] = approval_required
     if flow["engine"] == "direct":
         task["direct_provider_id"] = _text(payload.get("direct_provider_id"),
                                             "direct_provider_id")[:80]
@@ -388,6 +400,24 @@ def create_task(payload):
     with LOCK:
         _TASKS[task["id"]] = task
         _save_json(paths.TASKS_DIR / (task["id"] + ".json"), task)
+    try:
+        from . import contracts
+        contracts.create(task["id"], {
+            "acceptance_criteria": task.get("acceptance_criteria"),
+            "approval_required": task.get("approval_required"),
+            "actor": "system",
+        })
+    except Exception:
+        # Contracts are an evidence enrichment layer; legacy task creation
+        # must remain available if a damaged optional contract file is found.
+        pass
+    if task.get("serial"):
+        try:
+            from . import story_tracking
+            story_tracking.init(task["workdir"], task["id"], task["title"],
+                                premise=task.get("context") or task.get("goal") or "")
+        except Exception:
+            pass
     return task
 
 
@@ -535,6 +565,30 @@ def serial_chain_ids(task_id):
     return order
 
 
+def chain_book_meta(task, platform):
+    """任务在某平台的作品信息「面板视图」：根优先返回首个有状态的条目。
+
+    与 inherited_book_meta 同为根优先，但不筛 done——生成可从链上任意任务
+    触发、落点在根任务，running/failed 也要沿链可见，否则续写批次触发生成
+    后面板永远空转。running/done 优先于 failed（旧失败不遮新结果）。"""
+    task = task or {}
+    platform = str(platform)
+    own = ((task.get("book_meta") or {}).get(platform)) or {}
+    first_failed = None
+    for tid in serial_chain_ids(task.get("id") or ""):
+        t = task if tid == str(task.get("id")) else get_task(tid)
+        if not t:
+            continue
+        e = ((t.get("book_meta") or {}).get(platform)) or {}
+        if not (isinstance(e, dict) and e.get("status")):
+            continue
+        if e.get("status") in ("running", "done"):
+            return e
+        if first_failed is None:
+            first_failed = e
+    return first_failed or own
+
+
 def inherited_book_meta(task, platform):
     """任务在某平台的作品信息：连载链上「生成完成」的条目整链共用（都是用第一个）。
 
@@ -1050,6 +1104,22 @@ def update_run(run_id, expected_status=None, **fields):
                 # Acceptance reporting is evidence enrichment; it must not
                 # prevent the primary run from reaching a terminal state.
                 pass
+            try:
+                from . import contracts
+                for case in (run.get("acceptance") or {}).get("cases") or []:
+                    contracts.add_evidence(
+                        run.get("task_id") or "",
+                        {"criterion": "acceptance:%s" % case.get("case"),
+                         "status": "passed" if case.get("status") == "passed" else case.get("status"),
+                         "summary": case.get("reason") or "acceptance matrix",
+                         "source": "acceptance"}, actor="system")
+                contracts.record_acceptance_cases(
+                    run.get("task_id") or "",
+                    (run.get("acceptance") or {}).get("cases") or [],
+                    actor="system")
+                contracts.complete(run.get("task_id") or "", run)
+            except Exception:
+                pass
         _save_json(paths.RUNS_DIR / run_id / "run.json", run)
         if st in TERMINAL_STATUSES and prev_status not in TERMINAL_STATUSES:
             # 事后对账：只有「非终态 → 终态」这一次翻转才记账，重复写终态
@@ -1720,6 +1790,8 @@ def continue_task(task_id, chapters=None):
         "difficulty": task.get("difficulty") or "auto",
         "implementer": task.get("implementer") or "",
         "critics": task.get("critics") or [],
+        "acceptance_criteria": task.get("acceptance_criteria") or [],
+        "approval_required": bool(task.get("approval_required")),
         "manuscript": task.get("manuscript") or "manuscript.md",
         "threshold": task.get("threshold") or 7.0,
         "serial": {"chapters": batch,

package/app/core/story_tracking.py

@@ -0,0 +1,275 @@
+"""Structured, deterministic long-form fiction tracking.
+
+The JSON state is the source of truth. Markdown files under ``derived`` are
+regenerated from that state and are checked for drift before a run consumes
+them. This keeps long serial projects resumable without requiring a vector DB.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import time
+from pathlib import Path
+
+_MAX_CHAPTERS = 5000
+_STATE_REL = Path(".codebee") / "story_tracking.json"
+_DERIVED = Path(".codebee") / "derived"
+_CHAPTERS = Path(".codebee") / "chapters"
+
+
+def _now():
+    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+
+
+def _root(workdir):
+    root = Path(workdir).expanduser().resolve()
+    if not root.is_dir():
+        raise ValueError("工作目录不存在")
+    return root
+
+
+def _state_path(root):
+    return root / _STATE_REL
+
+
+def _digest(text):
+    return hashlib.sha256(str(text).encode("utf-8")).hexdigest()
+
+
+def _norm_lf(text):
+    """换行归一到 LF。章稿经 _read_chapter 保真读回时带 CRLF（Windows 上
+    _write_chapter 文本模式落盘所致），不归一会让同一份稿在不同路径下
+    摘要不一致。"""
+    return str(text).replace("\r\n", "\n").replace("\r", "\n")
+
+
+def _empty(task_id, title, premise=""):
+    return {"version": 1, "task_id": str(task_id), "title": str(title or "")[:120],
+            "premise": str(premise or "")[:2000], "state_revision": 0,
+            "current_chapter": 0, "facts": [], "characters": [], "timeline": [],
+            "foreshadowing": [], "next_promises": [], "author_truth": [],
+            "reader_known": [], "chapters": [], "derived_digests": {},
+            "created_at": _now(), "updated_at": _now()}
+
+
+def _save(root, state):
+    path = _state_path(root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(state, ensure_ascii=False, indent=2), encoding="utf-8")
+    tmp.replace(path)
+
+
+def _load(root):
+    path = _state_path(root)
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        return None
+    except (OSError, ValueError) as exc:
+        raise ValueError("故事追踪状态不可读: %s" % exc)
+    if not isinstance(data, dict) or data.get("version") != 1:
+        raise ValueError("不支持的故事追踪状态版本")
+    for name in ("facts", "characters", "timeline", "foreshadowing",
+                 "next_promises", "author_truth", "reader_known", "chapters"):
+        if not isinstance(data.get(name), list):
+            raise ValueError("故事追踪状态字段 %s 必须是列表" % name)
+    if not isinstance(data.get("derived_digests"), dict):
+        raise ValueError("故事追踪状态字段 derived_digests 必须是对象")
+    if any(not isinstance(row, dict) for row in data.get("chapters") or []):
+        raise ValueError("故事追踪状态 chapters 含无效记录")
+    return data
+
+
+def init(workdir, task_id, title, premise=""):
+    root = _root(workdir)
+    state = _load(root)
+    if state is None:
+        state = _empty(task_id, title, premise)
+        _save(root, state)
+    _render(root, state)
+    return state
+
+
+def load(workdir):
+    return _load(_root(workdir))
+
+
+def _clean_lines(values, limit=100):
+    result = []
+    for value in values if isinstance(values, list) else []:
+        text = str(value or "").strip()[:1000]
+        if text and text not in result:
+            result.append(text)
+        if len(result) >= limit:
+            break
+    return result
+
+
+def _clean_foreshadowing(values):
+    result = []
+    for raw in values if isinstance(values, list) else []:
+        if not isinstance(raw, dict):
+            continue
+        item = {"id": str(raw.get("id") or "").strip()[:40],
+                "text": str(raw.get("text") or "").strip()[:1000],
+                "status": str(raw.get("status") or "active").strip()[:30],
+                "planted_chapter": raw.get("planted_chapter"),
+                "payoff_chapter": raw.get("payoff_chapter")}
+        if item["id"] and item["text"]:
+            result.append(item)
+    return result[-500:]
+
+
+def commit_chapter(workdir, chapter_no, outline, prose, *, facts=None, characters=None,
+                   timeline=None, foreshadowing=None, next_promises=None,
+                   author_truth=None, reader_known=None):
+    root = _root(workdir)
+    try:
+        number = int(chapter_no)
+    except (TypeError, ValueError):
+        raise ValueError("章节号无效")
+    if not 1 <= number <= _MAX_CHAPTERS:
+        raise ValueError("章节号必须在 1-%d 之间" % _MAX_CHAPTERS)
+    outline = str(outline or "").strip()
+    prose = _norm_lf(str(prose or "").strip())
+    if not outline:
+        raise ValueError("提交章节前必须有细纲")
+    if not prose:
+        raise ValueError("正文不能为空")
+    state = _load(root)
+    if state is None:
+        state = _empty("", root.name)
+    # A shared workdir can be used by continuation tasks.  The structured
+    # tracking file is book-level state, so accepting a newer task id here
+    # would make the next run look like a foreign-state drift.  Keep the
+    # original owner and append chapters to the existing book timeline.
+    record = {"chapter": number, "outline": outline[:12000], "prose_digest": _digest(prose),
+              "word_count": len(prose), "committed_at": _now(),
+              "facts": _clean_lines(facts), "characters": _clean_lines(characters),
+              "timeline": _clean_lines(timeline), "foreshadowing": _clean_foreshadowing(foreshadowing),
+              "next_promises": _clean_lines(next_promises, 20),
+              "author_truth": _clean_lines(author_truth, 100), "reader_known": _clean_lines(reader_known, 100)}
+    existing = next((x for x in state["chapters"] if x.get("chapter") == number), None)
+    if existing and existing.get("prose_digest") == record["prose_digest"] and existing.get("outline") == outline:
+        return state
+    if existing:
+        state["chapters"] = [x for x in state["chapters"] if x.get("chapter") != number]
+    state["chapters"].append(record)
+    state["chapters"].sort(key=lambda x: int(x.get("chapter") or 0))
+    state["current_chapter"] = max(int(state.get("current_chapter") or 0), number)
+    state["facts"] = _clean_lines([x for c in state["chapters"] for x in c.get("facts", [])], 500)
+    state["characters"] = _clean_lines([x for c in state["chapters"] for x in c.get("characters", [])], 300)
+    state["timeline"] = _clean_lines([x for c in state["chapters"] for x in c.get("timeline", [])], 500)
+    state["foreshadowing"] = _clean_foreshadowing([x for c in state["chapters"] for x in c.get("foreshadowing", [])])
+    state["next_promises"] = record["next_promises"]
+    state["author_truth"] = record["author_truth"]
+    state["reader_known"] = record["reader_known"]
+    state["state_revision"] = int(state.get("state_revision") or 0) + 1
+    state["updated_at"] = _now()
+    chapter_dir = _CHAPTERS / ("%04d" % number)
+    (root / chapter_dir).mkdir(parents=True, exist_ok=True)
+    # 字节落盘钉死 LF：文本模式写会把已含 CRLF 的章稿二次翻译成 \r\r\n，
+    # 磁盘稿与状态摘要永久错位，续写批开场漂移闸必拦（2026-10-03 实案）
+    (root / chapter_dir / "outline.md").write_bytes((outline + "\n").encode("utf-8"))
+    (root / chapter_dir / "prose.md").write_bytes((prose + "\n").encode("utf-8"))
+    _save(root, state)
+    _render(root, state)
+    return state
+
+
+def _render(root, state):
+    derived = root / _DERIVED
+    derived.mkdir(parents=True, exist_ok=True)
+    lines = ["# 故事上下文", "", "- 书名：%s" % state.get("title", ""),
+             "- 当前章：第%s章" % state.get("current_chapter", 0),
+             "- 状态修订：%s" % state.get("state_revision", 0), ""]
+    if state.get("premise"):
+        lines += ["## 核心 premise", "", state["premise"], ""]
+    lines += ["## 长期事实", ""] + ["- " + x for x in state.get("facts", [])] + [""]
+    lines += ["## 活跃伏笔", ""]
+    for item in state.get("foreshadowing", []):
+        lines.append("- %s｜%s｜%s" % (item.get("id"), item.get("text"), item.get("status")))
+    lines += ["", "## 下一章承诺", ""] + ["- " + x for x in state.get("next_promises", [])] + [""]
+    lines += ["## 作者真相", ""] + ["- " + x for x in state.get("author_truth", [])] + [""]
+    lines += ["## 读者已知", ""] + ["- " + x for x in state.get("reader_known", [])] + [""]
+    context = "\n".join(lines).rstrip() + "\n"
+    (derived / "context.md").write_text(context, encoding="utf-8")
+    (derived / "foreshadowing.md").write_text("# 伏笔\n\n" + "\n".join(
+        "- %s｜%s｜%s" % (x.get("id"), x.get("text"), x.get("status"))
+        for x in state.get("foreshadowing", [])) + "\n", encoding="utf-8")
+    (derived / "timeline.md").write_text("# 时间线\n\n" + "\n".join(
+        "- " + x for x in state.get("timeline", [])) + "\n", encoding="utf-8")
+    state["derived_digests"] = {}
+    for name in ("context.md", "foreshadowing.md", "timeline.md"):
+        state["derived_digests"][name] = _digest((derived / name).read_text(encoding="utf-8"))
+    _save(root, state)
+    try:
+        from . import retrieval
+        for name in ("context.md", "foreshadowing.md", "timeline.md"):
+            path = derived / name
+            retrieval.upsert(str(path), path.read_text(encoding="utf-8"),
+                             {"task_id": state.get("task_id"), "kind": "story_tracking"})
+    except Exception:
+        pass
+
+
+def _prose_matches(path, digest):
+    """章稿摘要比对，兼容三种历史形态。
+
+    - 新写：文件纯 LF，状态摘要按 LF 文本计算；
+    - 旧写（文本模式二次翻译）：磁盘 \\r\\r\\n，状态摘要按 CRLF 原文计算——
+      CRCRLF 是写出路径独有的字节形态，先按字节愈合回 CRLF 再比对即可认定
+      同源，不必要求用户手工修复历史状态（2026-10-03 续写批漂移闸误杀实案）；
+    - 旧写（未二次翻译）：磁盘普通 CRLF，摘要按 CRLF 原文计算。
+    注意愈合必须在字节层做：read_text 的通用换行翻译会把 \\r\\r\\n 折成 \\n\\n，
+      事后无从区分「真空行」与「二次翻译」，就再也对不上了。
+    """
+    if not digest:
+        return False
+    try:
+        data = path.read_bytes()
+    except OSError:
+        return False
+    candidates = set()
+    for raw in (data, data.replace(b"\r\r\n", b"\r\n")):
+        text = raw.decode("utf-8", "replace")
+        candidates.add(_digest(text.strip()))
+        candidates.add(_digest(_norm_lf(text).strip()))
+    return digest in candidates
+
+
+def check(workdir):
+    root = _root(workdir)
+    state = _load(root)
+    if not state:
+        return {"ok": False, "errors": ["缺少故事追踪状态"]}
+    errors = []
+    for name, digest in (state.get("derived_digests") or {}).items():
+        path = root / _DERIVED / name
+        if not path.is_file():
+            errors.append("缺少派生文件 %s" % name)
+            continue
+        actual = _digest(path.read_text(encoding="utf-8"))
+        if actual != digest:
+            errors.append("派生文件已被手工修改: %s" % name)
+    for chapter in state.get("chapters") or []:
+        number = int(chapter.get("chapter") or 0)
+        outline = root / _CHAPTERS / ("%04d" % number) / "outline.md"
+        prose = root / _CHAPTERS / ("%04d" % number) / "prose.md"
+        if not outline.is_file() or not prose.is_file():
+            errors.append("章节文件缺失: %04d" % number)
+        elif outline.read_text(encoding="utf-8").strip() != str(chapter.get("outline") or "").strip():
+            # A continuation run may legitimately replace the shared outline
+            # with a book-level outline containing additional future chapters.
+            # Only reject a mismatch when the persisted chapter's own outline
+            # is no longer represented in the current file.
+            persisted = str(chapter.get("outline") or "").strip()
+            current = outline.read_text(encoding="utf-8").strip()
+            if persisted and persisted not in current:
+                errors.append("章节细纲不一致: %04d" % number)
+        elif not _prose_matches(prose, chapter.get("prose_digest")):
+            errors.append("章节正文不一致: %04d" % number)
+    return {"ok": not errors, "errors": errors, "state_revision": state.get("state_revision", 0),
+            "current_chapter": state.get("current_chapter", 0)}