codebee 0.1.95 → 0.1.97

package/app/core/pipeline.py

@@ -19,7 +19,7 @@ import re
 import threading
 import time
 
-from . import aiflavor, attachments, branching, catalog, chaptersafe, defectretro, dispatch_log, flows, history, hooks, jobs, knowledge, manager, modelhub, mocks, novel_quality, paihang, planner, quality_gate, registry, router, runner, skills, store, task_compile, usage, volumes
+from . import aiflavor, agent_context, attachments, branching, catalog, chaptersafe, checkpoints, defectretro, dispatch_log, flows, history, hooks, jobs, knowledge, manager, modelhub, mocks, novel_quality, paihang, planner, quality_gate, registry, router, runner, skills, store, task_compile, usage, volumes
 from . import builtin_agent
 from . import diagnostics
 from . import paths as paths_mod
@@ -229,10 +229,12 @@ def _resume_workdir(resume_ctx, fallback):
 
 
 def _compaction_enabled():
-    """Phase 2 灰度开关：环境变量 TUTTI_COMPACTION=1 或设置页
-    settings_v2 orchestrator.compaction.enabled 任一开启即生效（默认关）。"""
-    if os.environ.get("TUTTI_COMPACTION") == "1":
+    """环境变量可显式覆盖设置页开关；未设置时读取 settings_v2。"""
+    env_value = os.environ.get("TUTTI_COMPACTION", "").strip().lower()
+    if env_value in ("1", "true", "yes", "on"):
         return True
+    if env_value in ("0", "false", "no", "off"):
+        return False
     try:
         from .settings_schema import get as ss_get, register_default_namespaces
         register_default_namespaces()
@@ -442,7 +444,39 @@ def _run_step(run_id, role, agent, prompt, workdir, readonly, ev, timeout=runner
                                    agent.get("label", agent["id"]), note=note,
                                    model=agent.get("model") or "",
                                    provider=_binding_brief(agent))
+    try:
+        checkpoints.start(
+            run_id, step["n"], role, prompt,
+            input_data={"workdir": workdir, "readonly": readonly,
+                        "agent": agent.get("id")},
+            attempt=len((store.get_run(run_id) or {}).get("steps") or []))
+    except Exception:
+        pass
     start = time.time()
+    # Third-party CLI backends have their own sandbox semantics, but do not
+    # consume CodeBee's per-task policy. Fail closed for narrowed policies
+    # instead of treating a prompt or workdir as an OS-level boundary.
+    sandbox_error = ""
+    try:
+        run_row = store.get_run(run_id) or {}
+        task_row = store.get_task(run_row.get("task_id")) if run_row.get("task_id") else {}
+        if agent.get("mode") != "mock":
+            if not task_row:
+                sandbox_error = "无法读取任务沙箱策略，外部智能体执行已拒绝"
+            else:
+                from . import policy
+                sandbox_error = _external_sandbox_block_reason(
+                    agent, workdir, task_row.get("sandbox") or {})
+    except Exception:
+        # A missing task record is not permission to synthesize a wider policy.
+        sandbox_error = "无法读取任务沙箱策略，外部智能体执行已拒绝"
+    if sandbox_error:
+        res = {"ok": False, "text": "", "json": None, "cost_usd": 0.0,
+               "tokens": 0, "usage": None, "error": sandbox_error,
+               "raw": {"exit_code": None, "sandbox_blocked": True},
+               "kind": agent.get("kind", "generic"), "model": agent.get("model")}
+        _finish_step_result(run_id, step, res, role, agent, start)
+        return res
     if dead_binding:
         from .error_codes import ErrorCode
         res = {"ok": False, "text": "", "json": None, "cost_usd": 0.0,
@@ -484,11 +518,47 @@ def _run_step(run_id, role, agent, prompt, workdir, readonly, ev, timeout=runner
         if directive_block:
             prompt = directive_block + "\n\n---\n\n" + prompt
         effective_prompt = (guard["reminder"] + "\n\n---\n\n" + prompt) if guard["reminder"] else prompt
+        git_checkpoint = None
+        try:
+            git_checkpoint = checkpoints.begin_git_step(run_id, workdir)
+        except Exception:
+            git_checkpoint = {"ok": False, "error": "文件检查点准备失败，外部智能体未启动"}
+        if not git_checkpoint.get("ok"):
+            res = {"ok": False, "text": "", "json": None, "cost_usd": 0.0,
+                   "tokens": 0, "usage": None,
+                   "error": git_checkpoint.get("error") or "文件检查点准备失败",
+                   "raw": {"exit_code": None, "checkpoint_blocked": True},
+                   "kind": agent.get("kind", "generic"), "model": agent.get("model")}
+            _finish_step_result(run_id, step, res, role, agent, start)
+            return res
         res = _spawn_step(session_run_id=run_id, role=role, agent=agent,
                           prompt=effective_prompt, workdir=workdir, readonly=readonly,
                           ev=ev, timeout=timeout, resume=resume, step=step,
                           log_abs=log_abs, images=images, require_tools=require_tools,
                           deadline=deadline)
+        checkpoint_warning = git_checkpoint.get("warning", "")
+        if git_checkpoint.get("supported"):
+            try:
+                finished_checkpoint = checkpoints.finish_git_step(
+                    run_id, workdir, git_checkpoint.get("head"),
+                    git_checkpoint.get("before_paths") or [])
+                checkpoint_warning = finished_checkpoint.get("warning") or ""
+                if not finished_checkpoint.get("ok"):
+                    checkpoint_warning = finished_checkpoint.get("warning") or "外部智能体文件快照未能完整记录"
+            except Exception:
+                checkpoint_warning = "外部智能体文件快照记录失败；本步骤改动可能无法恢复"
+        if checkpoint_warning:
+            res["checkpoint_warning"] = checkpoint_warning
+            if res.get("ok"):
+                res["text"] = (res.get("text") or "") + "\n\n（检查点范围提示：%s）" % checkpoint_warning
+            elif res.get("error"):
+                res["error"] = res["error"] + "；" + checkpoint_warning
+            if log_abs:
+                try:
+                    with log_abs.open("a", encoding="utf-8") as handle:
+                        handle.write("\n[检查点] %s\n" % checkpoint_warning)
+                except OSError:
+                    pass
     # 先收尾再查取消：取消时进程已被 run_process 杀停，若先抛 Cancelled，
     # 步骤记录会永远停在「运行中」变僵尸（与 _run_verify 的顺序对齐）
     _finish_step_result(run_id, step, res, role, agent, start)
@@ -500,6 +570,32 @@ def _run_step(run_id, role, agent, prompt, workdir, readonly, ev, timeout=runner
     return res
 
 
+def _external_sandbox_block_reason(agent, workdir, sandbox):
+    """Reject task policies that this CLI launcher cannot enforce.
+
+    Codex is currently the only supported external runner with an OS-backed
+    workspace write sandbox. Other CLI integrations have no equivalent boundary
+    in this launcher and must use the in-process agent/tool executor instead.
+    """
+    if (agent or {}).get("mode") == "mock":
+        return ""
+    from . import policy
+    if (agent or {}).get("kind") != "codex":
+        return "沙箱拒绝：该外部 CLI 没有经验证的 OS 文件隔离；请改用内置 Agent"
+    root = os.path.realpath(workdir or ".")
+    normalized = policy.normalize_sandbox(sandbox, root)
+    roots = [os.path.realpath(x) for x in normalized.get("allowed_roots") or []]
+    if normalized.get("network") is False:
+        return "沙箱拒绝：该 CLI 后端未接入网络隔离，拒绝运行网络受限任务"
+    if roots != [root]:
+        return "沙箱拒绝：该 CLI 后端未接入允许目录隔离，拒绝运行目录受限任务"
+    if normalized.get("disabled_tools"):
+        return "权限拒绝：该 CLI 后端无法执行 CodeBee 工具禁用策略，拒绝运行"
+    if normalized.get("env_allowlist"):
+        return "沙箱拒绝：该 CLI 后端未接入环境变量白名单，拒绝运行受限任务"
+    return ""
+
+
 def _create_task_from_builtin(payload):
     """Create and enqueue a task requested by the direct conversation tool."""
     task = store.create_task(payload)
@@ -579,7 +675,8 @@ def _run_builtin_step(run_id, role, bi, prompt, workdir, ev, note="", images=Non
                             deadline=deadline, cancel_event=ev, log=_log, images=images,
                             on_reason=_on_reason, on_stream=_on_stream,
                             on_activity=_on_activity,
-                            task_creator=_create_task_from_builtin)
+                            task_creator=_create_task_from_builtin,
+                            sandbox=task.get("sandbox"), checkpoint_run_id=run_id)
     if followups and res.get("ok"):
         clean, fups = _parse_followups(res.get("text") or "")
         if fups:
@@ -779,6 +876,17 @@ def _finish_step_result(run_id, step, res, role, agent, start):
                       # 思考过程（内置智能体流式抓取）：落进步骤记录，对话气泡折叠展示
                       thinking=res.get("reasoning") or None,
                       partial=bool(res.get("partial")))
+    try:
+        checkpoint_status = ("unknown" if raw.get("unknown") else
+                             "timeout" if status == "timeout" else
+                             "cancelled" if status == "cancelled" else
+                             "done" if status == "done" else "failed")
+        checkpoints.finish(
+            run_id, step["n"], checkpoint_status,
+            error=res.get("error") or "", output=res.get("text") or "",
+            metadata={"role": role, "agent": agent.get("id") or ""})
+    except Exception:
+        pass
     # 错误台账：失败/超时各记一条结构化记录（遥测与诊断包的数据源）。
     # 用户主动取消不入账——那不是产品问题；detail 只存脱敏后的失败摘录。
     if status in ("failed", "timeout"):
@@ -1442,6 +1550,28 @@ def _run_code(run, task, agents, ev, stats, mode):
     if project_memory:
         task = dict(task, context=(task.get("context") or "") + "\n\n" + project_memory)
 
+    # 断点简报（B）：重试继承上一遍失败/中断 run 的现场，注入规划器与实现者
+    # 共用的 __CONTEXT__——「走到哪、改了什么、还剩什么」不再从零重建上下文。
+    _handoff = run.get("handoff") or {}
+    _brief = _handoff_brief(_handoff)
+    if _brief:
+        task = dict(task, context=(task.get("context") or "") + "\n\n" + _brief)
+    # 断点会话（A）：上一遍实现者的 CLI 会话 id，implement_all 里按人复用。
+    _inh_session = run.get("inherit_session") or {}
+
+    def _keep_sid(agent_row, agent_b, r):
+        """记录最后一次实现的会话 id：run 内 fix 轮复用 + 落盘 run 供重试跨 run 续会话。"""
+        sid = _resume_sid(agent_b, r.get("sid"))
+        if sid:
+            impl_sid[0] = sid
+            try:
+                store.update_run(run_id, impl_session={
+                    "agent": agent_row.get("id"), "session": sid,
+                    "workdir": workdir})
+            except Exception:
+                pass
+        return sid
+
     # ---- 规划。低风险短任务直接把目标作为单步计划，省掉一次独立模型调用；
     # 附件或较长的用户背景仍先规划，避免快速路径漏读约束。
     fast_path = (mode == "fast" or
@@ -1507,11 +1637,20 @@ def _run_code(run, task, agents, ev, stats, mode):
 
     def implement_all(impl_agent, prefix_note):
         nonlocal reviewer
-        # 会话延续只对原实现者有效；换将后新智能体没有该会话，必须丢弃
+        # 会话延续只对原实现者有效；换将后新智能体没有该会话，必须丢弃。
+        # 优先级：任务级 resume（用户显式指定）> 断点继承会话（A：跨 run 续跑，
+        # 仅同一实现者 + 同一工作目录 + 该 CLI 支持续会话时复用）
+        inh_sid = ""
+        if (not resume_ctx and _inh_session.get("session")
+                and _inh_session.get("agent") == impl_agent["id"]
+                and _same_workdir(_inh_session.get("workdir") or "", workdir)
+                and _resume_sid(impl_agent, _inh_session.get("session"))):
+            inh_sid = _inh_session["session"]
         use_resume = (resume_ctx["session"]
-                      if (resume_ctx and impl_agent["id"] == resume_ctx["agent"]["id"]) else None)
+                      if (resume_ctx and impl_agent["id"] == resume_ctx["agent"]["id"])
+                      else (inh_sid or None))
         # 续会话时 CLI 要在会话所属项目目录下启动，否则定位不到会话
-        step_wd = _resume_workdir(resume_ctx, workdir) if use_resume else workdir
+        step_wd = _resume_workdir(resume_ctx, workdir) if (resume_ctx and use_resume) else workdir
 
         def _run_one(agt):
             """用指定智能体跑全部子任务；返回 (ok, 最后一次 res)。"""
@@ -1557,10 +1696,20 @@ def _run_code(run, task, agents, ev, stats, mode):
                                 note=prefix_note if i == 0 else "",
                                 resume=use_resume, images=att_imgs,
                                 require_tools=True, swap_guard=swap_guard)
-                # §07 T1.1：记录最后一次实现的会话 id，fix 轮复用（会话内前缀走缓存读计价）
-                new_sid = _resume_sid(agt_b, res.get("sid"))
-                if new_sid:
-                    impl_sid[0] = new_sid
+                _keep_sid(agt, agt_b, res)
+                # 断点继承会话失效兜底（A）：会话可能已被 CLI 清理或跨机不可续。
+                # 认证/配额类死因换会话也没用，不重试；其余丢弃继承会话原样重跑一次。
+                if (not res["ok"] and inh_sid and i == 0 and use_resume == inh_sid
+                        and not (res.get("raw") or {}).get("cancelled")
+                        and not runner._auth_error(res.get("error") or "")
+                        and not runner._quota_error(res.get("error") or "")):
+                    res = _run_step(run_id, role, agt_b, prompt, step_wd,
+                                    readonly=False, ev=ev,
+                                    note=((prefix_note + "；") if prefix_note else "")
+                                    + "继承会话续跑失败，已丢弃旧会话全新执行",
+                                    resume=None, images=att_imgs,
+                                    require_tools=True, swap_guard=swap_guard)
+                    _keep_sid(agt, agt_b, res)
                 if agt.get("mode") == "mock" and res["ok"]:
                     try:
                         mock_path = os.path.abspath(os.path.join(workdir, "mock-impl.txt"))
@@ -1587,10 +1736,11 @@ def _run_code(run, task, agents, ev, stats, mode):
                              error=auth_err, ended_at=_now())
             return False
         # 单路实现失败：Best-of-N 赛马兜底（借鉴 orca worktree 择优）——多路并行
-        # 各自 worktree 隔离实现+验证，胜者 diff 回主工作区；失败回落走换将
+        # 各自 worktree 隔离实现+验证，胜者 diff 回主工作区；失败回落走换将。
+        # 会话延续在场时跳过（N 路共用同一 CLI 会话会互相践踏，与连载同理）
         if (mode == "auto" and impl_agent.get("mode") == "real"
                 and max(1, min(3, int(task.get("best_of") or 1))) >= 2
-                and resume_ctx is None
+                and resume_ctx is None and not inh_sid
                 and _code_bestof(run, task, impl_agent, difficulty, ev)):
             return True
         # 实现步失败不立刻判死：2026-09-16 实测配额烧干时 5 连跑全在同一条 CLI 上
@@ -1737,6 +1887,7 @@ def _run_code(run, task, agents, ev, stats, mode):
                             note="自动修复第 %d 轮" % round_no,
                             resume=resume_ctx["session"] if resume_ctx else impl_sid[0],
                             require_tools=True)
+            _keep_sid(impl, modelhub.bind_agent(impl, difficulty), res)
             if (res.get("raw") or {}).get("timed_out"):
                 # 自动修复没有换将/重试兜底；超时后继续验收会把未完成的修复
                 # 当作正常轮次，让 run 继续显示 running，最终还可能误标 done。
@@ -1854,7 +2005,7 @@ def _run_code(run, task, agents, ev, stats, mode):
         _mem_lines = ["改动文件：%s" % (_touched_str or "（无 diff）"),
                       "验收：%s" % ("通过" if verify_pass else "未通过"),
                       "修复轮数：%d" % (len(repairs) - 1)]
-        _write_project_memory(task, workdir, _mem_lines)
+        _write_project_memory(task, workdir, _mem_lines, source_run=run_id)
     except Exception:
         pass
     # Stop gate（planning-with-files）：收工时活计划若有未勾选项，摘要与 verdict
@@ -2692,8 +2843,8 @@ __VOLUME__
 - 撰写本书第 __I__ 章，把本章正文写入文件 `__FILE__`（直接写入该文件，只写本章）。文件必须以 UTF-8 编码保存：PowerShell 一律显式加 `-Encoding UTF8`（如 `Set-Content -Path __FILE__ -Encoding UTF8`），禁止依赖系统默认编码，否则中文会乱码。
 - 章节标题：__TITLE__
 - 剧情要点：__BEATS__
-- 章末钩子：__HOOK__
-- 本章爽点/情绪爆点：__HIGHLIGHT__（必须按特写镜头写厚：铺垫在前、放大在中、余波在后，用动作/五感/生理反应/环境反馈呈现，禁止一句话带过）
+- 章末收束/继续阅读理由（可自然收束或留白）：__HOOK__
+- 本章主要情绪/戏剧变化：__HIGHLIGHT__（按其重要性决定篇幅和表现方式；不强制放大，不为满足标签伪造高潮）
 __LOCKED_CH__
 __STALE_NOTE__
 - 正文约 __WORDS__ 字，中文，直接开写正文（可含本章标题行）。
@@ -2732,23 +2883,23 @@ __STYLE__
 
 ## 签约返修原则
 - 统一叙述语域、句式和视角距离，不在白描、半文半白和网络梗之间跳变。
-- 复杂情感必须落到动作、五感、生理反应和对话潜台词，禁止只写“很伤心/很愤怒”。
-- 爽点/情绪爆点按特写镜头写厚：铺垫在前、放大在中、余波在后，禁止一句话带过。
+- 复杂情感需按其叙事分量呈现；动作、感官、对话、内心直述、环境或留白均可，避免与本稿风格不合的机械扩写。
+- 重要情绪/戏剧变化要有与其分量相称的呈现；避免概括带过，但不把每个变化都扩写成高潮。
 - 删除不改变局面的环境、解释和重复叙述；每段至少完成冲突、信息或人物选择之一。
 - 让主角主动做出选择并推动下一步，补足因果桥，不用旁白硬推剧情。
 
 ## 要求
 - 针对性解决所有 major 问题（含确定性文本信号指出的问题），保持与前后的剧情衔接；字数仍约 __WORDS__ 字。"""
 
-SERIAL_GLOBAL_PROMPT = """你是网文主编（不要修改任何文件）。全书各章已完稿，请从**全书整体**视角评审。
+SERIAL_GLOBAL_PROMPT = """你是独立小说质量评审（不要修改任何文件），不代表任何签约平台。全书各章已完稿，请从**全书整体**视角评审。
 请输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
 {
   "scores": {"__DIMKEYS__"},
   "issues": [{"dim": "维度名", "severity": "major|minor", "note": "具体问题（指明哪一章）", "quote": "支撑该问题的稿件原文连续片段（≥8字，逐字摘录不许改写）"}],
-  "summary": "一句话总评：是否达到可签约水平"
+  "summary": "一句话总评：所读范围内的文本优势、主要风险与未验证项；不得预测签约结果"
 }
-每个维度打 1-10 分，宁严勿宽。重点关注：主线一致性、人物弧光、开篇吸引力、文风统一、情感细腻度、情节推进与节奏控制。
-若是前 3 章，必须核对黄金一章/黄金三章的切入速度；若发现拖沓、硬推或情绪概括，给出可定位的 major 问题与原文引文。
+每个维度打 1-10 分，按统一文本 rubric 与所读证据评估，不以“宁严勿宽”压分。重点关注：主线一致性、人物弧光、开篇吸引力、文风表现、情感表达、情节推进与节奏控制。
+若是全书最初的前 3 章，可观察视角人物、故事承诺、开篇兑现和读者理解成本；固定字数点、钩子/爽点密度仅作参考，不是扣分门槛。发现问题须给可定位原文引文，并区分文本事实、解释和建议。
 major 问题必须给 quote（系统会逐条校验引文是否真在稿件中——编造的引文会被降档标记）。
 
 ## 全书目标
@@ -2759,19 +2910,19 @@ __GOAL__
 __MANUSCRIPT__
 ---"""
 
-# 独立签约评估（开篇闸门 + 2万字检查点共用）：评分维度保持作者任务口径，
-# 平台五维在这里按平台真实尺度单独核——驳回模板的高频话术逐条要判定。
-SERIAL_SIGNING_EVAL_PROMPT = """你是签约评估编辑（不要修改任何文件）。请按免费阅读平台（番茄/七猫）签约评估的口径评审下面的稿件__NOTE__。
+# 独立文本质量评估（开篇闸门 + 项目检查点共用）：沿用稳定 rubric，
+# 不代表平台决定；按原文证据检查常见拒稿问题，不将经验观察点变成硬门槛。
+SERIAL_SIGNING_EVAL_PROMPT = """你是独立小说质量评审（不要修改任何文件），不是番茄或七猫的签约编辑，不能代表平台结论。
+评审稿件__NOTE__，按下方统一文本质量 rubric 评估；如附当前平台规则或编辑原话，可单独核对适配，不得臆测平台内部标准。
 请输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
 {
   "scores": {"__DIMKEYS__"},
   "issues": [{"dim": "维度名", "severity": "major|minor", "note": "具体问题（指明哪一章）", "quote": "支撑该问题的稿件原文连续片段（≥8字，逐字摘录不许改写）"}],
-  "summary": "一句话总评：是否达到可申请签约评估的水平"
+  "summary": "一句话内部文本诊断：优势、主要风险和未验证项；不得表述为平台结论或过签预测"
 }
-每个维度打 1-10 分（可为小数），按平台真实尺度从严。五个维度固定为：开篇吸引力、情节推进、文风统一、情感细腻度、节奏控制。
-驳回模板的高频话术——文风在风格上不统一（语域/句式跳变）、
-复杂情感描绘不够细腻（情绪概括无动作细节）、开篇切入点缺乏足够的吸引力（黄金一章未兑现）、情节的推动生硬（因果桥缺失/旁白硬推）、
-行文拖沓节奏缓慢（重复铺垫、与主线无关的描写）——每一条都要给出明确判定与证据。
+统一评分 rubric：1-3 为明显影响理解或阅读的严重问题；4-6 为有具体可定位的弱项；7-8 为基本有效、仍有局部提升空间；9-10 为在本稿目标下表现突出。分数必须由所读文本支撑，不把分数映射成过签概率。
+五个维度固定为：开篇吸引力、情节推进、文风统一、情感细腻度、节奏控制。每项给证据与未读范围；不能因不用某种套路（如黄金三章、打脸、单一视角）扣分。
+可检查文风是否突变、情绪是否被概括、开篇承诺是否兑现、因果桥是否成立、重复是否损害节奏；这些是检查问题而不是预设缺陷。没有当前平台规则或明确编辑反馈时，不把质量评审包装成平台审核结论。
 
 ## 待评审稿件
 ---
@@ -4309,7 +4460,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                                          agent.get("label"))
                 time.sleep(0.15)
                 gj = {"scores": {d: 8.0 for d in dims},
-                      "issues": [], "summary": "（mock）全书结构完整，达到可签约水平"}
+                      "issues": [], "summary": "（mock）内部结构评估：整体结构完整；此结果不代表平台签约结论"}
                 store.finish_step(run_id, step["n"], "done", summary="均分 8.0：（mock）全书达标",
                                   duration_s=0.15)
                 results[idx] = gj
@@ -4326,7 +4477,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                     "- 本次送审批次为全书第 %d—%d 章（连载中段批次），文本中的前文节选仅供衔接核对；\n"
                     "- 「黄金一章/黄金三章」口径仅适用于全书第 1—3 章，不得据此扣减本批批首章的开篇分；\n"
                     "- 本批各章的既定事件以工作目录「章纲/」下的锁定章纲为准（可自行查阅）：承段、"
-                    "过渡章的节奏分应对照章纲既定事件是否落实与章末钩子是否成立，"
+                    "过渡章的节奏分应对照章纲既定事件与叙事功能是否落实；自然收束、留白均可，不以悬念钩子作为硬门槛。"
                     "不以高潮段的事件密度为统一标准；\n"
                     "- 「伏笔悬置」类 major 须先核对章纲的揭示位安排：揭示位写在后批章纲中的伏笔"
                     "不算悬置，无任何安排的悬置才成立；\n"
@@ -4894,6 +5045,14 @@ def _run_content_review(run, task, agents, ev, stats, mode):
             pass
     else:
         is_research = task.get("type") == "research"
+        # 经验库/知识库注入（review 引擎 13 类型补全，serial 起草同款）：
+        # learn_async 面向全部 run 收割，此前注入只在连载链——「全类型收割、
+        # 单链注入」闭环半开。在 _draft_prompt_for 外取一次（bestof 多稿件
+        # 共用一份，命中计数不重复累加）；stable_order 保前缀缓存，预算纪律
+        # 由块内自带（skills 包区限额+教训保底 / knowledge 装箱截断）。
+        sk_lessons, _ = skills.block_for(task, stable_order=True, run_id=run_id)
+        kb_block = knowledge.block_for(task)
+        ctx_block = "\n\n".join(p for p in (sk_lessons, kb_block) if p)
 
         def _draft_prompt_for(vfile):
             p = (_tpl(task, "draft_prompt", NOVEL_DRAFT_PROMPT).replace("__FILE__", vfile)
@@ -4927,6 +5086,9 @@ def _run_content_review(run, task, agents, ev, stats, mode):
                 gl = _gitlog_brief(workdir)
                 if gl:
                     p += ("\n\n## 本周提交素材（git log，如实取材，缺失勿虚构）\n" + gl)
+            if ctx_block:
+                # 空块不追加：零命中零噪音（空库时 prompt 与旧版字节一致）
+                p += "\n\n" + ctx_block
             p += _content_contract(task)
             return p
 
@@ -4987,6 +5149,16 @@ def _run_content_review(run, task, agents, ev, stats, mode):
             .replace("__MANUSCRIPT__", manuscript or "（稿件为空！）"))
         if task.get("context"):
             crit_prompt += "\n\n## 原始任务背景与附件参考\n" + task["context"]
+        # 经验库/知识库注入（serial 逐章评审同款；「## 待评审稿件」锚点由
+        # _ensure_critique_placeholders 保证存在），按证据强度随评审下发
+        sk, _ = skills.block_for(task, stable_order=True, run_id=run_id)
+        if sk:
+            crit_prompt = crit_prompt.replace(
+                "## 待评审稿件", "%s\n\n## 待评审稿件" % sk, 1)
+        kb = knowledge.block_for(task)
+        if kb:
+            crit_prompt = crit_prompt.replace(
+                "## 待评审稿件", "%s\n\n## 待评审稿件" % kb, 1)
         # AI 味确定性检测（借鉴 oh-story 去AI味）：客观参考线随评审下发，
         # 命中才追加——评审官结合上下文判断是否真问题，脚本不直接扣分
         crit_prompt = aiflavor.inject_into_prompt(crit_prompt, manuscript, task.get("type"))
@@ -5182,41 +5354,26 @@ def _read_constitution(workdir):
             "与其他要求冲突时以宪章为准）\n\n" + txt + "\n\n")
 
 
-def _write_project_memory(task, workdir, lines):
-    """项目记忆持久化（借鉴 agentmemory）：代码任务成功后把架构事实追加到
-    .codebee/project-memory.md——同目录后续 code 任务规划前自动注入，
-    让编排者「知道这个代码库的脾气」而非每次从零摸索。失败静默。"""
+def _write_project_memory(task, workdir, lines, source_run=""):
+    """Persist proposed project facts; they are not injected before approval."""
     if not lines:
         return ""
     try:
-        pm = os.path.join(workdir, ".codebee", "project-memory.md")
-        os.makedirs(os.path.dirname(pm), exist_ok=True)
-        header_needed = not os.path.isfile(pm)
-        with open(pm, "a", encoding="utf-8") as f:
-            if header_needed:
-                f.write("# 项目记忆（每次代码任务完成后自动追加，供后续任务参考）\n\n")
-            f.write("### %s · %s\n" % (task.get("title") or "", _now()))
-            for ln in lines:
-                f.write("- %s\n" % str(ln)[:300])
-            f.write("\n")
-        return pm
+        from . import project_memory
+        row = project_memory.propose(workdir, source_run=source_run,
+                                     title=task.get("title") or "", facts=lines)
+        return str(project_memory._file(workdir)) if row else ""
     except Exception:
         return ""
 
 
 def _read_project_memory(workdir, cap=4000):
-    """读取项目记忆供规划提示词注入。超出上限截断到最新条目。"""
-    p = os.path.join(workdir or "", ".codebee", "project-memory.md")
-    if not _inside(workdir, p) or not os.path.isfile(p):
-        return ""
+    """Only inject approved, unexpired and fingerprint-verified memory."""
     try:
-        txt = _read_text_any_enc(p)[:cap].strip()
-    except OSError:
-        return ""
-    if not txt:
+        from . import project_memory
+        return project_memory.active_text(workdir, cap=cap)
+    except (OSError, ValueError, TypeError):
         return ""
-    return ("## 项目记忆（此前代码任务在此工作目录留下的架构事实，"
-            "规划时优先参考）\n\n" + txt + "\n\n")
 
 
 def _write_task_spec(task, workdir):
@@ -5347,10 +5504,24 @@ def _write_task_plan(task, workdir, plan):
         if root not in target.parents:
             return ""
         target.parent.mkdir(parents=True, exist_ok=True)
+        # 断点续跑（B）：旧计划已勾选 [x] 的项按标题继承到新计划——重试重新
+        # 规划不再抹掉已完成进度（继承发生在写盘前，mark_task_plan 的行号
+        # 约定基于新文件，安全）；[!]/[>] 不继承，重跑自然重置。
+        prev_done = {}
+        try:
+            if target.is_file():
+                _pat = re.compile(r"^\d+\. \[([ x!>])\] (.+)$")
+                for _ln in target.read_text("utf-8").splitlines():
+                    _m = _pat.match(_ln)
+                    if _m and _m.group(1) == "x":
+                        prev_done.setdefault(_m.group(2).strip(), True)
+        except Exception:
+            prev_done = {}
         lines = ["# 任务计划", "", "来源：%s" % (plan or {}).get("source", "?"), ""]
         # checkbox 形态：mark_task_plan 按行号翻 [x]/[!]/[>]，断点一眼可见
         for i, s in enumerate((plan or {}).get("steps") or [], 1):
-            lines.append("%d. [ ] %s" % (i, str(s.get("detail") or s.get("title") or "")[:200]))
+            _t = str(s.get("detail") or s.get("title") or "")[:200]
+            lines.append("%d. [%s] %s" % (i, "x" if prev_done.get(_t.strip()) else " ", _t))
         target.write_text("\n".join(lines) + "\n", encoding="utf-8")
         return str(target)
     except Exception:
@@ -5414,6 +5585,79 @@ def mark_task_plan(workdir, index, status):
         return False
 
 
+def _same_workdir(a, b):
+    """路径同位判断（Windows 大小写/斜杠不敏感）；任一为空即不同。"""
+    try:
+        na = os.path.normcase(os.path.abspath(a or ""))
+        nb = os.path.normcase(os.path.abspath(b or ""))
+        return bool(na) and bool(nb) and na == nb
+    except Exception:
+        return False
+
+
+def _assemble_handoff(task, run):
+    """断点简报组装（B）：终态 run 的「走到哪/改了什么/还剩什么」快照。
+    存进 run 记录供 retry_task 继承；组装失败返回近空 dict，绝不挡收尾。"""
+    steps = run.get("steps") or []
+    done_steps = [{"role": s.get("role") or "", "summary": (s.get("summary") or "")[:120]}
+                  for s in steps if (s.get("status") or "") == "done"][-8:]
+    pending = ""
+    for s in steps:
+        if (s.get("status") or "") != "done":
+            pending = "%s%s" % (s.get("role") or "?",
+                                ("（%s）" % s["summary"][:100]) if s.get("summary") else "")
+            break
+    try:
+        _total, _left = plan_stopgate(task.get("workdir") or "")
+    except Exception:
+        _total, _left = 0, []
+    ch = run.get("changes")
+    if not ch:
+        try:
+            from . import gitmod
+            ch = gitmod.collect_changes(task.get("workdir") or "")
+        except Exception:
+            ch = {}
+    files = [f.get("path") for f in ((ch or {}).get("files") or []) if f.get("path")][:25]
+    return {
+        "status": run.get("status") or "",
+        "error": (run.get("error") or "")[:240],
+        "ended_at": run.get("ended_at") or "",
+        "done_steps": done_steps,
+        "pending": pending,
+        "plan_total": _total,
+        "plan_left": [[n, m, t] for n, m, t in (_left or [])][:6],
+        "changed_files": files,
+    }
+
+
+def _handoff_brief(h):
+    """断点简报 → 注入 __CONTEXT__ 的人话块；无实质内容返回空串（零噪音）。"""
+    if not isinstance(h, dict) or not (h.get("done_steps") or h.get("pending")
+                                       or h.get("plan_left") or h.get("changed_files")):
+        return ""
+    rows = ["## 断点简报（上次运行中断现场，系统注入）",
+            "上次运行以「%s」终止%s。工作目录/任务分支保留着上次已完成的部分改动。"
+            "先核对现场再继续：已完成的修复不要推翻重做，从中断处接着完成目标。"
+            % (h.get("status") or "?",
+               ("（原因：%s）" % h["error"]) if h.get("error") else "")]
+    done = h.get("done_steps") or []
+    if done:
+        rows.append("- 已完成步骤：" + "；".join(
+            ("%s：%s" % (s.get("role") or "?", s["summary"])) if s.get("summary")
+            else (s.get("role") or "?") for s in done))
+    if h.get("pending"):
+        rows.append("- 中断位置：%s" % h["pending"])
+    left = h.get("plan_left") or []
+    if left:
+        rows.append("- 活计划未完成项：" + "、".join(
+            "#%s[%s]%s" % (n, m, t) for n, m, t in left))
+    files = h.get("changed_files") or []
+    if files:
+        rows.append("- 上次已改动的文件：" + "、".join(str(f) for f in files))
+    return "\n".join(rows)
+
+
 def _workdir_blocker(task, run_id):
     """同工作目录互斥：返回占用该目录的任务（无则 None）。
     任务计划/项目记忆/任务分支检出都是工作目录级共享状态，并行会互相覆盖
@@ -5505,6 +5749,11 @@ def execute_run(run_id):
                      difficulty=task_spec["difficulty"])
     task = dict(task)
     task = attachments.refresh_task(task, task.get("workdir") or "")
+    try:
+        task, _agent_context = agent_context.inject(task, task.get("workdir") or "")
+        store.update_run(run_id, agent_context=_agent_context)
+    except Exception:
+        pass
     task["_compiled_spec"] = task_spec
     # 运行内统一使用编译后的难度；store 中历史任务常带 difficulty=auto，
     # 不能让这个兼容值覆盖 easy/default/hard 的模型调度决策。
@@ -5708,6 +5957,17 @@ def execute_run(run_id):
                                                   "restore_error": repr(e)[:200]})
                 except Exception:
                     pass
+        # 断点简报（B）：失败/取消/超时的代码 run 组装「走到哪/改了什么/还剩什么」，
+        # 供 retry_task 继承注入新 run——重试从断点继续，不从零烧 token。
+        # done 不组装：主动重跑语义就是重来。放在 git 收尾后，changes 是最新的。
+        try:
+            if (task.get("engine")
+                    or ("code" if task.get("type") == "code" else "review")) == "code":
+                _fin = store.get_run(run_id) or {}
+                if _fin.get("status") in ("failed", "cancelled", "timeout"):
+                    store.update_run(run_id, handoff=_assemble_handoff(task, _fin))
+        except Exception:
+            pass
         # 自学习闭环：运行结束自动把本次评审暴露的问题沉淀为可复用教训（异步，不阻塞）
         try:
             if store.get_run(run_id):