codebee 0.1.99 → 0.1.101

package/app/core/pipeline.py

@@ -596,6 +596,16 @@ def _external_sandbox_block_reason(agent, workdir, sandbox):
         if normalized.get("env_allowlist"):
             return "沙箱拒绝：该 CLI 后端未接入环境变量白名单，拒绝运行受限任务"
         return ""
+    if (agent or {}).get("kind") == "acp":
+        if normalized.get("network") is False:
+            return "沙箱拒绝：ACP 后端进程未接入网络隔离，拒绝运行网络受限任务"
+        if normalized.get("env_allowlist"):
+            return "沙箱拒绝：ACP 后端进程未接入环境变量白名单，拒绝运行受限任务"
+        roots = [os.path.realpath(x) for x in normalized.get("allowed_roots") or []]
+        if roots and not any(root == allowed or root.startswith(allowed + os.sep)
+                             for allowed in roots):
+            return "沙箱拒绝：任务目录不在 ACP 允许目录内"
+        return ""
     # 非 codex 外部 CLI：默认策略放行，收窄策略拒绝
     if normalized.get("network") is False:
         return "沙箱拒绝：该任务要求禁网，外部 CLI 无法执行网络受限任务"
@@ -818,7 +828,13 @@ def _spawn_step(session_run_id, role, agent, prompt, workdir, readonly, ev,
         llm_caller = _make_llm_caller(agent, workdir, deadline=deadline)
         call_kwargs = dict(workdir=workdir, readonly=readonly,
                            timeout=timeout, cancel_event=ev, log_path=str(log_abs),
-                           images=images, require_tools=require_tools, deadline=deadline)
+                           images=images, require_tools=require_tools, deadline=deadline,
+                           command_context={"run_id": session_run_id,
+                                            "sandbox": (store.get_task(
+                                                (store.get_run(session_run_id) or {}).get("task_id")
+                                            ) or {}).get("sandbox") or {},
+                                            "allow_terminal": not readonly},
+                           checkpoint_run_id=session_run_id)
 
         def _call(p, **kw):
             nonlocal usage_recorded
@@ -846,7 +862,13 @@ def _spawn_step(session_run_id, role, agent, prompt, workdir, readonly, ev,
         res = runner.run_agent(agent, prompt, workdir=workdir, readonly=readonly,
                                timeout=timeout, cancel_event=ev, log_path=str(log_abs),
                                resume=resume, images=images, require_tools=require_tools,
-                               deadline=deadline)
+                               deadline=deadline,
+                               command_context={"run_id": session_run_id,
+                                                "sandbox": (store.get_task(
+                                                    (store.get_run(session_run_id) or {}).get("task_id")
+                                                ) or {}).get("sandbox") or {},
+                                                "allow_terminal": not readonly},
+                               checkpoint_run_id=session_run_id)
     # 默认关闭压缩和 resume 都走直通分支，也必须把真实 usage 送进预算表；否则
     # 下一步永远看到 used=0，max_tokens_per_run 只是一个无效设置。
     if not usage_recorded:
@@ -1561,7 +1583,8 @@ def _run_code(run, task, agents, ev, stats, mode):
 
     # 项目记忆既给规划器，也给快速路径的实现者；不能因省掉独立规划而漏掉。
     user_context_len = len(task.get("context") or "")
-    project_memory = _read_project_memory(workdir)
+    project_memory = _read_project_memory(
+        workdir, query=task.get("goal") or task.get("title") or "")
     if project_memory:
         task = dict(task, context=(task.get("context") or "") + "\n\n" + project_memory)
 
@@ -2568,6 +2591,36 @@ __CRITIQUE__
 - 针对性改进所有 major 问题；保持既定风格与设定。
 - 完成后用 3 句话说明本轮改了什么。"""
 
+# 评审口径单一真源：评审面提示词（单章/全局）与作者面注入块从这里同源提取，
+# 两边永不脱节。此前评审清单/签约专项/全局口径只活在评审面，作者第一遍写完
+# 被打回才知道按什么标准被审（2026-10-10 实案：全章过线仍卡全局 major）。
+# 作者面刻意不下发评分机制本体（1-10 分/阈值/宁严勿宽）——对写作者零价值，
+# 透下去只喂响应试素材；清单条目本身全是质量正向要求，事前下发只有好处。
+REVIEW_CHECKLIST_ITEMS = (
+    "叙述语域与视角统一",
+    "复杂情感落到动作、五感或生理细节",
+    "开篇在前 600 字进入具体冲突",
+    "每章发生真实的局面变化",
+    "无可删的重复铺垫与长段解释",
+)
+GLOBAL_REVIEW_FOCUS = ("主线一致性、人物弧光、开篇吸引力、文风表现、情感表达、"
+                       "情节推进与节奏控制")
+
+
+def author_review_rubric_block(dims, signing_dims):
+    """作者面评审口径块：起草/修订提示词里事前下发「会按什么标准被审」，
+    与评审面同源（REVIEW_CHECKLIST_ITEMS / GLOBAL_REVIEW_FOCUS）。静态文本，
+    同批各章字节一致，不碎前缀缓存。"""
+    lines = [
+        "## 评审口径（本书会按以下标准审稿，写作时对照自查）",
+        "- 评分维度：" + " / ".join(dims) + "。",
+        "- 逐项硬清单：" + "；".join(REVIEW_CHECKLIST_ITEMS) + "。",
+        "- 全书级关注：" + GLOBAL_REVIEW_FOCUS + "。",
+        "- 签约专项维度：" + "、".join(signing_dims) + "。",
+    ]
+    return "\n".join(lines) + "\n"
+
+
 NOVEL_CRITIQUE_PROMPT = """你是严格的评审（不要使用任何工具、不要修改文件，只依据下方稿件内容评审）。
 请输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
 {
@@ -2576,7 +2629,7 @@ NOVEL_CRITIQUE_PROMPT = """你是严格的评审（不要使用任何工具、
   "summary": "一句话总评"
 }
 每个维度打 1-10 分（可为小数），宁严勿宽。major 问题必须给 quote（系统会逐条校验引文是否真在稿件中——编造的引文会被降档标记）。
-评审必须逐项回答：叙述语域与视角是否统一；复杂情感是否有动作、五感或生理细节；开篇是否在前 600 字进入具体冲突；本章是否发生局面变化；是否存在可删的重复铺垫或长段解释。
+评审逐项核查以下各项是否成立：%s。""" % ("；".join(REVIEW_CHECKLIST_ITEMS)) + """
 
 ## 待评审稿件
 ---
@@ -2862,6 +2915,7 @@ __VOLUME__
 - 本章主要情绪/戏剧变化：__HIGHLIGHT__（按其重要性决定篇幅和表现方式；不强制放大，不为满足标签伪造高潮）
 __LOCKED_CH__
 __STALE_NOTE__
+__REDO_ISSUES__
 - 正文约 __WORDS__ 字，中文，直接开写正文（可含本章标题行）。
 
 ## 前情提要（此前各章结尾摘录，衔接用）
@@ -2876,6 +2930,7 @@ __STYLE__
 ## 签约质量门禁
 __QUALITY_GATE__
 
+__REVIEW_RUBRIC__
 - 写完文件后，最终回复只输出一行：`第 __I__ 章完成（约 __WORDS__ 字）`——不要在回复里复述或解释正文。"""
 
 SERIAL_REVISE_PROMPT = """你是一名网文作者。第 __I__ 章没有通过评审，请修订文件 `__FILE__`（直接改写该文件）。文件必须以 UTF-8 编码保存（PowerShell 显式加 -Encoding UTF8，禁止依赖默认编码）。
@@ -2890,6 +2945,7 @@ __BEATS__
 （本章爽点/情绪爆点：__HIGHLIGHT__）
 __LOCKED_CH__
 
+__REVIEW_RUBRIC__
 ## 本章评审意见
 __CRITIQUE__
 
@@ -2913,7 +2969,7 @@ SERIAL_GLOBAL_PROMPT = """你是独立小说质量评审（不要修改任何文
   "issues": [{"dim": "维度名", "severity": "major|minor", "note": "具体问题（指明哪一章）", "quote": "支撑该问题的稿件原文连续片段（≥8字，逐字摘录不许改写）"}],
   "summary": "一句话总评：所读范围内的文本优势、主要风险与未验证项；不得预测签约结果"
 }
-每个维度打 1-10 分，按统一文本 rubric 与所读证据评估，不以“宁严勿宽”压分。重点关注：主线一致性、人物弧光、开篇吸引力、文风表现、情感表达、情节推进与节奏控制。
+每个维度打 1-10 分，按统一文本 rubric 与所读证据评估，不以“宁严勿宽”压分。重点关注：%s。""" % GLOBAL_REVIEW_FOCUS + """
 若是全书最初的前 3 章，可观察视角人物、故事承诺、开篇兑现和读者理解成本；固定字数点、钩子/爽点密度仅作参考，不是扣分门槛。发现问题须给可定位原文引文，并区分文本事实、解释和建议。
 major 问题必须给 quote（系统会逐条校验引文是否真在稿件中——编造的引文会被降档标记）。
 
@@ -3319,6 +3375,8 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
     # 签约专项维度作为额外硬性检查注入提示词与报告证据。
     dims = task.get("rubric") or DEFAULT_RUBRIC
     signing_dims = novel_quality.rubric_for({"type": "serial_novel"})
+    # 作者面评审口径块（与评审面同源提取）：起草/修订/打磨提示词都带
+    rubric_block = author_review_rubric_block(dims, signing_dims)
     threshold = task.get("threshold", 7.0)
     threshold_ch = threshold - 0.5 if threshold >= 7.5 else threshold   # 单章阈值略放宽 0.5 分
     dimkey = ", ".join('"%s": 0' % d for d in dims)
@@ -3389,6 +3447,9 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
     inherit = run.get("inherit") or {}
     done_set = set(inherit.get("done_chapters") or [])
     inh_scores = {c.get("chapter"): c for c in (inherit.get("chapter_scores") or [])}
+    # 未达标重写的原因账（store.retry_task 从 verdict.major_issues 下发）：
+    # 章节级+全局级 major，渲染进对应重写章的起草提示词；达标续跑为空表
+    redo_issues = [x for x in (inherit.get("redo_issues") or []) if isinstance(x, dict)]
     if inherit.get("outline"):
         outline = inherit["outline"]
         # 历史遗留：降级/模板大纲被继承时，真实任务宁可中止重生成，也不按空模板写全书
@@ -3817,6 +3878,26 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
             if os.path.exists(os.path.join(workdir, ch_file)):
                 stale_note = ("- 注意：目录里已有一版**未通过评审**的旧稿 `%s`——不要校验沿用、"
                               "不要增量修补，按本章任务直接覆盖重写。" % ch_file)
+            # 上一轮未达标原因（「重写未达标章」链路）：本章被点名的 major 与
+            # 全书级 major 随起草提示词下发——原因只躺在报告里、作者盲写等
+            # 修订拉回，白白多烧一轮评审（2026-10-10 实案）。
+            def _issue_ch(x):
+                try:
+                    return int(x.get("chapter"))
+                except (TypeError, ValueError):
+                    return None
+
+            redo_lines = []
+            mine = [x for x in redo_issues if _issue_ch(x) == i]
+            book_lvl = [x for x in redo_issues if _issue_ch(x) is None]
+            if mine:
+                redo_lines.append("- 本章被上一轮评审点名的问题（重写必须逐条消解）：")
+                redo_lines += _major_lines(mine)
+            if book_lvl:
+                redo_lines.append("- 上一轮全书级 major 问题（本章重写须配合消解，不得相抵）：")
+                redo_lines += _major_lines(book_lvl)
+            redo_note = ("## 上一轮评审未达标原因（必读）\n" + "\n".join(redo_lines) + "\n"
+                         ) if redo_lines else ""
             # stable_order：同一任务 8 个章节的技能块必须字节级一致（§07 T1.2' 前缀缓存）
             # 三块分开留底：起草重试的分层降级（_serial_shrunk_block）要按
             # 「经验库/圣经」各自的身份收缩，折成一整块就只剩 4K 硬截一层了
@@ -3855,6 +3936,8 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                         .replace("__HOOK__", branch_hook or ch.get("hook") or "留下悬念")
                         .replace("__LOCKED_CH__", serial_locked_chapter_block(workdir, i))
                         .replace("__STALE_NOTE__", stale_note)
+                        .replace("__REDO_ISSUES__", redo_note)
+                        .replace("__REVIEW_RUBRIC__", rubric_block)
                         .replace("__HIGHLIGHT__", ch.get("highlight") or "按剧情要点自然铺设一处小冲突/小反转")
                         .replace("__STYLE__", style_tpl)
                         .replace("__QUALITY_GATE__", novel_quality.opening_requirements(i, wpc))
@@ -4008,7 +4091,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                 if not res["ok"]:
                     # 成品是文件不是退出码：CLI 超时但章稿已完整落盘（终章长文实测
                     # 反复出现——文件写完、收尾声明没等到）就送评审门把关，别整章作废
-                    live = (store.get_run(run_id).get("steps") or [])
+                    live = ((store.get_run(run_id) or {}).get("steps") or [])
                     if live:
                         store.finish_step(run_id, live[-1]["n"], "done",
                                           summary="起草调用超时，但章稿已完整落盘（约 %d 字）——交评审门判质量"
@@ -4267,6 +4350,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                           .replace("__VOLUME__", vol_block_for(i))
                           .replace("__BEATS__", ch.get("beats") or "按大纲推进")
                           .replace("__LOCKED_CH__", serial_locked_chapter_block(workdir, i))
+                          .replace("__REVIEW_RUBRIC__", rubric_block)
                           .replace("__HIGHLIGHT__", ch.get("highlight")
                                    or "按剧情要点自然铺设一处小冲突/小反转")
                           .replace("__STYLE__", style_tpl)
@@ -4422,6 +4506,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                              .replace("__VOLUME__", vol_block_for(j))
                              .replace("__BEATS__", _wch.get("beats") or "按大纲推进")
                              .replace("__LOCKED_CH__", serial_locked_chapter_block(workdir, j))
+                             .replace("__REVIEW_RUBRIC__", rubric_block)
                              .replace("__HIGHLIGHT__", _wch.get("highlight")
                                       or "按剧情要点自然铺设一处小冲突/小反转")
                              .replace("__STYLE__", style_tpl)
@@ -4633,6 +4718,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                           .replace("__VOLUME__", vol_block_for(i))
                           .replace("__BEATS__", ch.get("beats") or "按大纲推进")
                           .replace("__LOCKED_CH__", serial_locked_chapter_block(workdir, i))
+                          .replace("__REVIEW_RUBRIC__", rubric_block)
                           .replace("__HIGHLIGHT__", ch.get("highlight")
                                    or "按剧情要点自然铺设一处小冲突/小反转")
                           .replace("__CRITIQUE__", crit)
@@ -5382,11 +5468,11 @@ def _write_project_memory(task, workdir, lines, source_run=""):
         return ""
 
 
-def _read_project_memory(workdir, cap=4000):
+def _read_project_memory(workdir, cap=4000, query=""):
     """Only inject approved, unexpired and fingerprint-verified memory."""
     try:
         from . import project_memory
-        return project_memory.active_text(workdir, cap=cap)
+        return project_memory.active_text(workdir, cap=cap, query=query)
     except (OSError, ValueError, TypeError):
         return ""
 
@@ -5917,8 +6003,23 @@ def execute_run(run_id):
                          status="cancelled", ended_at=_now())
     except Exception as e:
         import traceback
+        # 崩溃现场随错误行下发（2026-10-10 Mac 实案：连载连烧两轮自动续跑都
+        # 死于 AttributeError("'NoneType' object has no attribute 'get'")，
+        # 错误行只有一行 repr 无从定位；traceback 全文虽落 run 目录 error.log，
+        # 但 UI 上看不见）。尾帧 = 文件:行号:函数名，一行说清死在哪；同因止损
+        # 的错误签名因此按崩溃位置区分——同位置才算同因，代码升级后行号漂移
+        # 自动能多试一轮（新代码可能已修复），次数上限仍兜底。
+        _tb_tail = ""
+        try:
+            _frames = traceback.extract_tb(e.__traceback__)
+            if _frames:
+                _f = _frames[-1]
+                _tb_tail = "（崩溃于 %s:%s %s）" % (
+                    os.path.basename(_f.filename), _f.lineno, _f.name)
+        except Exception:
+            pass
         store.update_run(run_id, expected_status="running", status="failed",
-                         error=repr(e)[:500], ended_at=_now())
+                         error=(repr(e)[:380] + _tb_tail)[:500], ended_at=_now())
         try:
             err_path = store.run_dir(run_id) / "error.log"
             if _inside(str(store.run_dir(run_id).parent), str(err_path)):

package/app/core/plugins.py

@@ -371,14 +371,21 @@ def install(plugin_id, roots=None):
                     "skill_count": len(old.get("skill_pack_ids") or [])}, None
         source = Path(desc["dir"]).resolve()
         target = (_install_root() / plugin_id).resolve()
+        market_id = "plugin-" + plugin_id
+        # 回滚标记必须在 try 之前就绑定：_copy_plugin/load_manifest 在记账前
+        # 抛错时 except 要靠它决定是否清 market 包，未初始化会把人话错误
+        # 炸成 UnboundLocalError→500，还会跳过残留目录清理让重装永远撞车。
+        market_written = False
         try:
             target.relative_to(_install_root().resolve())
+            if target.exists() and target != source:
+                # 有登记记录的已装插件在上面 already 分支就返回了；走到这里
+                # 还存在目标目录只可能是上次安装中途失败的残缺副本，清掉重装。
+                shutil.rmtree(target, ignore_errors=True)
             _copy_plugin(source, target)
             installed_desc = load_manifest(target)
             files = _skill_files(installed_desc)
-            market_id = "plugin-" + plugin_id
             skill_result = None
-            market_written = False
             if files:
                 skill_result, err = market.install_files(
                     market_id, installed_desc["display_name"], files,

package/app/core/project_memory.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import hashlib
 import json
 import os
+import re
 import stat
 import time
 from pathlib import Path
@@ -95,6 +96,8 @@ def list_entries(workdir, *, now=None):
         raw = row.get("content") or ""
         row["verified"] = hashlib.sha256(raw.encode("utf-8")).hexdigest() == row.get("content_sha256")
         row["expired"] = float(row.get("expires_at") or 0) <= stamp
+        row["feedback_score"] = int(row.get("feedback_score") or 0)
+        row["feedback_count"] = int(row.get("feedback_count") or 0)
     return sorted(rows, key=lambda x: (x.get("created_at", 0), x.get("id", "")), reverse=True)
 
 
@@ -126,14 +129,78 @@ def decide(workdir, entry_id, action, *, expected_version=None, now=None):
     return row
 
 
-def active_text(workdir, *, cap=4000, now=None):
+def feedback(workdir, entry_id, *, useful, expected_version=None, now=None):
+    """Record explicit retrieval feedback as a versioned append-only update."""
+    if not isinstance(useful, bool):
+        raise ValueError("useful 必须是布尔值")
+    path = _file(workdir)
+    row = _read(path).get(str(entry_id or ""))
+    if not row:
+        raise KeyError("记忆条目不存在")
+    if expected_version is not None and int(expected_version) != int(row.get("version") or 1):
+        raise ValueError("记忆条目版本已变化，请刷新后重试")
+    raw = row.get("content") or ""
+    if hashlib.sha256(raw.encode("utf-8")).hexdigest() != row.get("content_sha256"):
+        raise ValueError("记忆内容指纹校验失败")
+    if row.get("status") != "approved":
+        raise ValueError("只有已批准的记忆条目可以反馈")
     stamp = float(now if now is not None else time.time())
+    row = dict(row, feedback_score=int(row.get("feedback_score") or 0) +
+               (1 if useful else -1),
+               feedback_count=int(row.get("feedback_count") or 0) + 1,
+               feedback_at=stamp, version=int(row.get("version") or 1) + 1,
+               updated_at=stamp)
+    _append(path, row)
+    return row
+
+
+def _query_terms(query):
+    query = str(query or "").strip().lower()
+    words = re.findall(r"[a-z0-9_]+|[\u3400-\u9fff]+", query)
+    terms = set()
+    for word in words:
+        if len(word) > 2 and re.fullmatch(r"[\u3400-\u9fff]+", word):
+            terms.update(word[i:i + 2] for i in range(len(word) - 1))
+        else:
+            terms.add(word)
+    return terms
+
+
+def _relevance(row, terms):
+    if not terms:
+        return 0
+    title = str(row.get("title") or "").lower()
+    content = str(row.get("content") or "").lower()
+    title_terms = _query_terms(title)
+    content_terms = _query_terms(content)
+    return 4 * len(terms & title_terms) + len(terms & content_terms)
+
+
+def active_text(workdir, *, cap=4000, query="", now=None):
+    stamp = float(now if now is not None else time.time())
+    try:
+        cap = max(0, int(cap))
+    except (TypeError, ValueError):
+        cap = 4000
+    heading = "## 已批准项目记忆（内容已校验，过期条目不注入）\n\n"
+    cap = max(0, cap - len(heading) - 2)
+    terms = _query_terms(query)
     items = []
     for row in list_entries(workdir, now=stamp):
         if row.get("status") != "approved" or row.get("expired") or not row.get("verified"):
             continue
-        items.append("### %s\n%s" % (row.get("title") or "项目记忆", row.get("content") or ""))
-    text = "\n\n".join(items)
-    if len(text) > cap:
-        text = text[-cap:]
-    return ("## 已批准项目记忆（内容已校验，过期条目不注入）\n\n" + text + "\n\n") if text else ""
+        block = "### %s\n%s" % (row.get("title") or "项目记忆", row.get("content") or "")
+        items.append((row, block))
+    items.sort(key=lambda item: (_relevance(item[0], terms),
+                                 item[0].get("feedback_score", 0),
+                                 item[0].get("created_at", 0)), reverse=True)
+    selected = []
+    used = 0
+    for _row, block in items:
+        cost = len(block) + (2 if selected else 0)
+        if used + cost > cap:
+            continue
+        selected.append(block)
+        used += cost
+    text = "\n\n".join(selected)
+    return (heading + text + "\n\n") if text else ""

package/app/core/registry.py

@@ -88,6 +88,12 @@ def effective_agents(catalog_entries, detected):
         if not pref.get("enabled", entry.get("default_enabled", False)):
             continue
         out.append(_build_agent(entry))
+    try:
+        from . import backend_profiles
+        out.extend(backend_profiles.runtime_agents())
+    except Exception:
+        # Broken local profile storage must not disable unrelated installed agents.
+        pass
     out.extend([dict(m) for m in MOCK_AGENTS])
     return out
 
@@ -98,6 +104,13 @@ def installed_agent(entry_id, catalog_entries, detected):
     续会话是用户对该 CLI 的显式指定，不依赖其是否参与自动路由；
     未安装 / 无编排配置 / id 不存在时返回 None。
     """
+    if str(entry_id or "").startswith("acp-"):
+        try:
+            from . import backend_profiles
+            return next((agent for agent in backend_profiles.runtime_agents()
+                         if agent.get("id") == entry_id), None)
+        except Exception:
+            return None
     for entry in catalog_entries:
         if entry.get("id") != entry_id:
             continue

package/app/core/runner.py

@@ -1678,7 +1678,8 @@ def _opencode_fast_banner_death(res):
 
 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):
+              images=None, require_tools=False, deadline=None, command_context=None,
+              checkpoint_run_id=""):
     """执行一次智能体调用，返回统一结构
     {ok, text, json, cost_usd, tokens, error, error_code, raw}。
     agent 来自 registry.effective_agents()；resume 为已有会话 id，仅真实智能体生效
@@ -1722,6 +1723,17 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                 "kind": agent.get("kind", "generic"), "model": None,
                 "attempts": []}
     kind = agent.get("kind", "generic")
+    if kind == "acp":
+        from . import acp_client
+        context = dict(command_context or {})
+        context.setdefault("run_id", checkpoint_run_id)
+        context.setdefault("sandbox", {})
+        context.setdefault("allow_terminal", not readonly)
+        return acp_client.run_agent(
+            agent, prompt, workdir=workdir, readonly=readonly, timeout=timeout,
+            cancel_event=cancel_event, deadline=deadline,
+            command_context=context, checkpoint_run_id=checkpoint_run_id,
+            resume=resume)
     if agent.get("runtime_config_sync_failed"):
         return {"ok": False, "text": "", "json": None, "cost_usd": 0.0,
                 "tokens": 0, "usage": None,

package/app/core/store.py

@@ -1723,12 +1723,27 @@ def retry_task(task_id):
                 # 结构——这正是「重写未达标章」按钮（前端 done+未达标态放行
                 # retry）区别于断点续跑的语义。
                 redo = set()
+                redo_issues = []
                 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}
+                    # 未达标原因账（verdict.major_issues，章节级+全局级）随继承
+                    # 下发：流水线把本章点名项与全书级项渲染进重写章起草提示词，
+                    # 作者第一遍就知道往哪改，不再盲写等修订拉回。被 major 点名
+                    # 的过线章一并回炉——总判定卡在 major 上时只重写未过线章
+                    # 消不掉账，「重写未达标章」会空转（2026-10-10 实案）。
+                    for x in (prev.get("verdict") or {}).get("major_issues") or []:
+                        if not isinstance(x, dict):
+                            continue
+                        redo_issues.append(x)
+                        try:
+                            redo.add(int(x.get("chapter")))
+                        except (TypeError, ValueError):
+                            pass
                 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")]
+                    v_scores = [c for c in v_scores if c.get("passed")
+                                and c.get("chapter") not in redo]
                 if done or redo:
                     if redo:
                         scores = v_scores          # 未达标重写：只带已过线章的分数
@@ -1743,6 +1758,8 @@ def retry_task(task_id):
                         # 落账的 chapter_scores——否则多轮失败恢复会把全部
                         # 已过线章节重新评审（实测一晚白烧数百万 token）
                         "chapter_scores": scores,
+                        # 未达标重写的原因账（达标续跑时为空表）
+                        "redo_issues": redo_issues,
                     }
                     break
         else:

package/app/main.py

@@ -358,6 +358,15 @@ class Handler(BaseHTTPRequestHandler):
                     return self._json(200, {"entries": project_memory.list_entries(task.get("workdir"))})
                 except (OSError, ValueError) as exc:
                     return self._json(409, {"error": str(exc)})
+            if path == "/api/backend-profiles":
+                from core import backend_profiles
+                try:
+                    return self._json(200, {"profiles": backend_profiles.list_profiles()})
+                except (OSError, ValueError) as exc:
+                    return self._json(409, {"error": str(exc)})
+            if path == "/api/command-auth":
+                from core import command_auth
+                return self._json(200, command_auth.view())
             if path == "/api/agents/presence":
                 from core import presence
                 return self._json(200, {"agents": presence.list_agents()})
@@ -887,6 +896,58 @@ class Handler(BaseHTTPRequestHandler):
                 return deny
         if path == "/api/tasks":
             return self._api_create_task()
+        if path == "/api/backend-profiles":
+            from core import backend_profiles
+            try:
+                return self._json(200, {"profile": backend_profiles.save(self._body() or {})})
+            except KeyError as exc:
+                return self._json(404, {"error": str(exc)})
+            except (OSError, TypeError, ValueError) as exc:
+                return self._json(400, {"error": str(exc)})
+        m = re.match(r"^/api/backend-profiles/([^/]+)/delete$", path)
+        if m:
+            from core import backend_profiles
+            try:
+                backend_profiles.remove(unquote(m.group(1)))
+                store.bump_state()
+                return self._json(200, {"ok": True})
+            except KeyError as exc:
+                return self._json(404, {"error": str(exc)})
+            except (OSError, TypeError, ValueError) as exc:
+                return self._json(400, {"error": str(exc)})
+        if path == "/api/command-auth":
+            from core import command_auth
+            body = self._body() or {}
+            try:
+                if "mode" in body:
+                    command_auth.set_mode(body.get("mode"))
+                return self._json(200, command_auth.view())
+            except (TypeError, ValueError) as exc:
+                return self._json(400, {"error": str(exc)})
+        m = re.match(r"^/api/command-auth/requests/([^/]+)$", path)
+        if m:
+            from core import command_auth
+            body = self._body() or {}
+            try:
+                result = command_auth.decide(
+                    unquote(m.group(1)), approve=body.get("approve"),
+                    scope=body.get("scope", "once"), match=body.get("match", "exact"),
+                    prefix=body.get("prefix"))
+                return self._json(200, result)
+            except KeyError as exc:
+                return self._json(404, {"error": str(exc)})
+            except (TypeError, ValueError) as exc:
+                return self._json(400, {"error": str(exc)})
+        m = re.match(r"^/api/command-auth/rules/([^/]+)/revoke$", path)
+        if m:
+            from core import command_auth
+            try:
+                command_auth.revoke(unquote(m.group(1)))
+                return self._json(200, {"ok": True})
+            except KeyError as exc:
+                return self._json(404, {"error": str(exc)})
+            except (TypeError, ValueError) as exc:
+                return self._json(400, {"error": str(exc)})
         if path == "/api/a2a/tasks":
             status, resp = self._create_and_start(self._body() or {})
             return self._json(status, {"protocol": "a2a-lite", **resp})
@@ -915,6 +976,11 @@ class Handler(BaseHTTPRequestHandler):
             body = self._body() or {}
             from core import project_memory
             try:
+                if str(body.get("action") or "").lower() == "feedback":
+                    row = project_memory.feedback(
+                        task.get("workdir"), body.get("id"), useful=body.get("useful"),
+                        expected_version=body.get("expected_version"))
+                    return self._json(200, {"entry": row})
                 row = project_memory.decide(task.get("workdir"), body.get("id"),
                                             body.get("action"),
                                             expected_version=body.get("expected_version"))
@@ -3480,6 +3546,10 @@ def main():
     print("[CodeBee] v%s" % (_ver or "?"), flush=True)
     _step("正在准备数据目录…")
     paths.ensure_dirs()
+    from core import backend_profiles as _backend_profiles
+    from core import command_auth as _command_auth
+    _backend_profiles.init()
+    _command_auth.init()
     from core import attachments
     n_pc = attachments.cleanup_stale()  # 待提交附件残留清理（崩溃/弃单不堆积）
     if n_pc: