codebee 0.1.104 → 0.1.106

package/app/core/openapi.py

@@ -68,6 +68,13 @@ def document():
         "CommandAuth": {"type": "object", "properties": {
             "mode": {"type": "string", "enum": ["legacy", "restricted"]},
             "pending": {"type": "array"}, "rules": {"type": "array"}, "audit": {"type": "array"}}},
+        "ReviewRequest": {"type": "object", "required": ["id", "run_id", "status"],
+                           "properties": {
+                               "id": {"type": "string"}, "run_id": {"type": "string"},
+                               "summary": {"type": "string"}, "paths": {"type": "array", "items": {"type": "string"}},
+                               "channel": {"type": "string"},
+                               "status": {"type": "string", "enum": ["requested", "assigned", "approved", "changes_requested", "dismissed", "expired"]},
+                               "reviewer": {"type": "string"}, "reason": {"type": "string"}}},
     }
 
     def body(schema):
@@ -146,6 +153,28 @@ def document():
         "/api/command-auth/rules/{rule_id}/revoke": {
             "post": {"summary": "撤销命令授权规则", "security": security,
                      "responses": {"200": ok, "400": errors["400"], "401": errors["401"], "404": errors["404"]}}},
+        "/api/reviews": {
+            "get": {"summary": "读取外部人工评审请求", "security": security,
+                    "responses": {"200": response("评审请求列表", {"type": "object", "properties": {
+                        "reviews": {"type": "array", "items": ref("ReviewRequest")}}}), "401": errors["401"]}},
+            "post": {"summary": "创建外部人工评审请求", "security": security,
+                     "requestBody": body({"type": "object", "required": ["run_id"], "properties": {
+                         "run_id": {"type": "string", "maxLength": 100}, "summary": {"type": "string", "maxLength": 1000},
+                         "paths": {"oneOf": [{"type": "string"}, {"type": "array", "items": {"type": "string", "maxLength": 500}}]},
+                         "channel": {"type": "string", "maxLength": 200}}}),
+                     "responses": {"200": response("评审请求", {"type": "object", "properties": {"review": ref("ReviewRequest")}}), **errors}}},
+        "/api/reviews/{review_id}/transition": {
+            "post": {"summary": "推进外部人工评审状态", "security": security,
+                     "requestBody": body({"type": "object", "required": ["action"], "properties": {
+                         "action": {"type": "string", "enum": ["assign", "approve", "changes_requested", "dismiss", "expire"]},
+                         "reviewer": {"type": "string", "maxLength": 200}, "reason": {"type": "string", "maxLength": 1000}}}),
+                     "responses": {"200": response("评审请求", {"type": "object", "properties": {"review": ref("ReviewRequest")}}), **errors}}},
+        "/api/capabilities": {"get": {"summary": "读取智能体能力清单", "security": security,
+            "responses": {"200": response("能力清单", {"type": "object"}), "401": errors["401"]}}},
+        "/api/tasks/{task_id}/memory/preview": {"get": {"summary": "预览项目记忆注入内容", "security": security,
+            "parameters": [{"name": "q", "in": "query", "schema": {"type": "string", "maxLength": 500}},
+                           {"name": "cap", "in": "query", "schema": {"type": "integer", "minimum": 0, "maximum": 20000}}],
+            "responses": {"200": response("记忆注入预览", {"type": "object"}), "401": errors["401"], "404": errors["404"], "409": errors["409"]}}},
         "/api/retrieval/search": {"get": {"summary": "本地检索", "security": security,
             "parameters": [{"name": "q", "in": "query", "required": True,
                             "schema": {"type": "string", "maxLength": 500}},

package/app/core/pipeline.py

@@ -445,11 +445,20 @@ def _run_step(run_id, role, agent, prompt, workdir, readonly, ev, timeout=runner
                                    model=agent.get("model") or "",
                                    provider=_binding_brief(agent))
     try:
+        checkpoint_effects = [] if readonly else ["workspace_files"]
+        if agent.get("mode") != "mock":
+            checkpoint_effects.append("external_agent")
+        if agent.get("kind") in ("acp", "mcp"):
+            checkpoint_effects.append("external_protocol")
         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 []))
+            attempt=len((store.get_run(run_id) or {}).get("steps") or []),
+            tool_call={"name": "agent_step", "agent": agent.get("id"),
+                       "role": role, "readonly": bool(readonly)},
+            conversation_ref=resume or "",
+            side_effects=checkpoint_effects)
     except Exception:
         pass
     start = time.time()
@@ -475,7 +484,8 @@ def _run_step(run_id, role, agent, prompt, workdir, readonly, ev, timeout=runner
                "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)
+        _finish_step_result(run_id, step, res, role, agent, start,
+                            readonly=readonly)
         return res
     if dead_binding:
         from .error_codes import ErrorCode
@@ -484,7 +494,8 @@ def _run_step(run_id, role, agent, prompt, workdir, readonly, ev, timeout=runner
                "error_code": ErrorCode.ENV_BLOCK,
                "raw": {"exit_code": None}, "kind": agent.get("kind", "generic"),
                "model": agent.get("model")}
-        _finish_step_result(run_id, step, res, role, agent, start)
+        _finish_step_result(run_id, step, res, role, agent, start,
+                            readonly=readonly)
         return res
     if agent.get("mode") == "mock":
         time.sleep(0.3)
@@ -507,7 +518,8 @@ def _run_step(run_id, role, agent, prompt, workdir, readonly, ev, timeout=runner
                    "raw": {"exit_code": None, "repeat_stop": True},
                    "kind": agent.get("kind", "generic"),
                    "model": agent.get("model")}
-            _finish_step_result(run_id, step, res, role, agent, start)
+            _finish_step_result(run_id, step, res, role, agent, start,
+                                readonly=readonly)
             return res
         # 运行中指挥：drain 用户追加的指令/附件，注入本步（守门拦截时不 drain，
         # 消息留给下一个真实步骤，不空耗）；role/step_n 作送达回执
@@ -529,7 +541,8 @@ def _run_step(run_id, role, agent, prompt, workdir, readonly, ev, timeout=runner
                    "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)
+            _finish_step_result(run_id, step, res, role, agent, start,
+                                readonly=readonly)
             return res
         res = _spawn_step(session_run_id=run_id, role=role, agent=agent,
                           prompt=effective_prompt, workdir=workdir, readonly=readonly,
@@ -561,7 +574,8 @@ def _run_step(run_id, role, agent, prompt, workdir, readonly, ev, timeout=runner
                     pass
     # 先收尾再查取消：取消时进程已被 run_process 杀停，若先抛 Cancelled，
     # 步骤记录会永远停在「运行中」变僵尸（与 _run_verify 的顺序对齐）
-    _finish_step_result(run_id, step, res, role, agent, start)
+    _finish_step_result(run_id, step, res, role, agent, start,
+                        readonly=readonly)
     if (res.get("raw") or {}).get("deadline_exceeded"):
         store.update_run(run_id, expected_status="running", status="timeout",
                          ended_at=_now(), error="任务总时限已到")
@@ -793,6 +807,18 @@ def _cost_gate_block():
     return None
 
 
+def _run_sandbox(run_id):
+    """Return a run's persisted sandbox policy, or the unrestricted default hint.
+
+    Low-level callers such as budget-gate tests may use a run id before creating
+    a task. The runner still enforces any task policy when one is present.
+    """
+    run = store.get_run(run_id) or {}
+    task_id = run.get("task_id")
+    task = store.get_task(task_id) if task_id else None
+    return (task or {}).get("sandbox") or {}
+
+
 def _spawn_step(session_run_id, role, agent, prompt, workdir, readonly, ev,
                 timeout, resume, step, log_abs, images=None, require_tools=False,
                 deadline=None):
@@ -832,9 +858,7 @@ def _spawn_step(session_run_id, role, agent, prompt, workdir, readonly, ev,
                            timeout=timeout, cancel_event=ev, log_path=str(log_abs),
                            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 {},
+                                            "sandbox": _run_sandbox(session_run_id),
                                             "allow_terminal": not readonly},
                            checkpoint_run_id=session_run_id)
 
@@ -866,9 +890,7 @@ def _spawn_step(session_run_id, role, agent, prompt, workdir, readonly, ev,
                                resume=resume, 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 {},
+                                                "sandbox": _run_sandbox(session_run_id),
                                                 "allow_terminal": not readonly},
                                checkpoint_run_id=session_run_id)
     # 默认关闭压缩和 resume 都走直通分支，也必须把真实 usage 送进预算表；否则
@@ -883,7 +905,7 @@ def _spawn_step(session_run_id, role, agent, prompt, workdir, readonly, ev,
     return res
 
 
-def _finish_step_result(run_id, step, res, role, agent, start):
+def _finish_step_result(run_id, step, res, role, agent, start, *, readonly=None):
     """step 收尾：记录 + 用量 + 运行时断言（5F）。"""
     # 被取消杀停的步骤如实记「已取消」；超时被杀记「超时」——都只是步骤
     # 显示层的细分，run 级仍是 failed，善后路径（重试/自动续跑）不变
@@ -924,7 +946,10 @@ def _finish_step_result(run_id, step, res, role, agent, start):
         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 ""})
+            metadata={"role": role, "agent": agent.get("id") or "",
+                      "repropose_required": True,
+                      "side_effects": ([] if readonly is True else ["workspace_files"]) +
+                      (["external_agent"] if agent.get("mode") != "mock" else [])})
     except Exception:
         pass
     # 错误台账：失败/超时各记一条结构化记录（遥测与诊断包的数据源）。
@@ -1040,6 +1065,7 @@ __FILES__
 __CONTEXT__
 
 ## 要求
+- 思考先行：动手前先读懂相关代码、明确验收标准再改；不读懂就动手是大改与返工的主因。
 - 修改要最小化、聚焦任务目标；不要无关重构。
 - 反过度防御（借鉴 HERO：只约束你「提出」的方案，不约束你「检查」的范围）——
   不要给没要求的数据加哈希/校验和；不要为内部脚本铺层层边界分支；

package/app/core/project_memory.py

@@ -179,7 +179,7 @@ def _relevance(row, 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))
+        cap = min(20000, max(0, int(cap)))
     except (TypeError, ValueError):
         cap = 4000
     heading = "## 已批准项目记忆（内容已校验，过期条目不注入）\n\n"
@@ -204,3 +204,49 @@ def active_text(workdir, *, cap=4000, query="", now=None):
         used += cost
     text = "\n\n".join(selected)
     return (heading + text + "\n\n") if text else ""
+
+
+def injection_preview(workdir, *, cap=4000, query="", now=None):
+    """Explain exactly which approved memory entries would be injected.
+
+    The returned text is the same bounded content as ``active_text``; metadata
+    is deliberately separate so callers can render provenance without putting
+    extra bookkeeping into the model context.
+    """
+    stamp = float(now if now is not None else time.time())
+    try:
+        cap = min(20000, max(0, int(cap)))
+    except (TypeError, ValueError):
+        cap = 4000
+    heading = "## 已批准项目记忆（内容已校验，过期条目不注入）\n\n"
+    body_cap = max(0, cap - len(heading) - 2)
+    terms = _query_terms(query)
+    candidates = []
+    for row in list_entries(workdir, now=stamp):
+        if row.get("status") != "approved" or row.get("expired") or not row.get("verified"):
+            continue
+        block = "### %s\n%s" % (row.get("title") or "项目记忆", row.get("content") or "")
+        candidates.append((row, block))
+    candidates.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 candidates:
+        cost = len(block) + (2 if selected else 0)
+        if used + cost > body_cap:
+            continue
+        selected.append((row, block))
+        used += cost
+    return {
+        "text": (heading + "\n\n".join(block for _row, block in selected) + "\n\n"
+                 if selected else ""),
+        "entries": [{"id": row.get("id"), "title": row.get("title"),
+                     "source_run": row.get("source_run", ""),
+                     "version": int(row.get("version") or 1),
+                     "content_sha256": row.get("content_sha256", ""),
+                     "feedback_score": int(row.get("feedback_score") or 0)}
+                    for row, _block in selected],
+        "budget": {"cap": cap, "used": len((heading + "\n\n".join(
+            block for _row, block in selected) + "\n\n") if selected else "")},
+        "query": str(query or "")[:500],
+    }

package/app/core/publish/auto.py

@@ -215,6 +215,67 @@ def pending(task_id, platform):
     return out, ""
 
 
+def chapter_review_states(task, items, quality, hard_ok, hard_reason="", direct_ok=True):
+    """逐章最新评审证据与实际发布门禁同时展示，不把单章通过当作放行。"""
+    from .. import store, quality_gate
+    try:
+        reviewed_through = int(quality.get("reviewed_through") or 0)
+    except (ValueError, TypeError):
+        reviewed_through = 0
+    runs = []
+    for tid in store.serial_chain_ids(task.get("id")):
+        runs.extend(store.task_runs(tid) or [])
+    evidence = {}
+    for run in sorted(runs, key=lambda r: str(r.get("id") or ""), reverse=True):
+        verdict = run.get("verdict") if run.get("status") == "done" else None
+        if not isinstance(verdict, dict):
+            continue
+        for score in verdict.get("chapter_scores") or []:
+            if not isinstance(score, dict):
+                continue
+            try:
+                n = int(score.get("chapter") or 0)
+            except (ValueError, TypeError):
+                continue
+            if n > 0 and n not in evidence:
+                evidence[n] = (score, run)
+    for item in items:
+        score, run = evidence.get(item["chapter_no"], ({}, {}))
+        state, reason = "pending", "尚无有效单章评审"
+        try:
+            valid = (score.get("passed") is True
+                     and int(score.get("reviewer_count") or 0) >= quality_gate.MIN_REVIEWERS
+                     and score.get("reviewer_consensus") is True)
+        except (ValueError, TypeError):
+            valid = False
+        if score.get("passed") is False:
+            state, reason = "failed", "单章质量评审未通过"
+        elif score and not valid:
+            reason = "有效评审人数不足或未形成共识"
+        elif valid:
+            state, reason = "passed_blocked", "单章已过审，发布门禁未过"
+            if not hard_ok:
+                reason = hard_reason
+            elif not quality.get("allowed"):
+                reason = "；".join(quality.get("blockers") or []) or reason
+            elif item["chapter_no"] > reviewed_through:
+                reason = "目标章节超出当前发布评审版本"
+            elif not direct_ok:
+                reason = "平台发布流程尚未校准，可人工确认发布，暂不可自动直发"
+            else:
+                state, reason = "ready", "单章及发布门禁均已通过"
+            try:
+                reviewed_at = time.mktime(time.strptime(run.get("ended_at") or "", "%Y-%m-%d %H:%M:%S"))
+                if os.path.getmtime(os.path.join(task.get("workdir") or "", item["file"])) > reviewed_at + 1:
+                    state, reason = "stale", "正文在评审后修改，需要重新评审"
+            except (OSError, ValueError, TypeError):
+                pass
+        item.update(review_status=state, review_reason=reason,
+                    review_passed=valid and state != "stale",
+                    publish_ready=state == "ready", review_run_id=run.get("id") or "")
+    return items
+
+
 def status(task_id):
     """前端视图：待发清单 + 护栏状态 + 自动发布进度。
 
@@ -233,6 +294,7 @@ def status(task_id):
         if not _book_ready(info):
             hard_ok, hard_why = False, "该平台建书结果未确认（缺少作品 ID），请重试创建作品或登记已有作品"
         blockers = []
+        quality = {"allowed": False, "blockers": []}
         if task and _book_ready(info):
             quality = manager._quality_release_guard(task, plat, action="publish")
             if not quality.get("allowed"):
@@ -240,15 +302,24 @@ def status(task_id):
         ok, why = hard_ok, hard_why
         if ok and blockers:
             ok, why = False, "质量门禁拦截：%s" % "；".join(blockers)
+        direct_ok = calibrated(plat)
+        chapter_review_states(task or {}, pend, quality, hard_ok, hard_why, direct_ok)
+        published = ledger.published_chapters(task_id, plat)
+        drafted = ledger.drafted_chapters(task_id, plat) - published
         books.append({"platform": plat, "bound": True,
                       "title": info.get("title") or "",
                       "pending": len(pend),
-                      "items": pend[:200],
+                      "items": pend,
+                      "published_latest": max(published, default=0),
+                      "next_chapter": pend[0]["chapter_no"] if pend else None,
+                      "ready_count": sum(p["publish_ready"] for p in pend),
+                      "review_passed_count": sum(p["review_passed"] for p in pend),
+                      "drafted_nos": sorted(drafted),
                       "guard_ok": ok, "guard_reason": why,
                       "draft_ok": hard_ok, "draft_reason": hard_why,
                       "quality_blockers": blockers,
-                      "drafted": len(ledger.drafted_chapters(task_id, plat)),
-                      "calibrated": calibrated(plat)})
+                      "drafted": len(drafted),
+                      "calibrated": direct_ok})
     run = _running.get(task_id) or None
     if run:
         run = dict(run)

package/app/core/publish/ledger.py

@@ -102,6 +102,11 @@ def published_chapters(task_id, platform):
                 out.add(int(n))
     try:
         ent = book_for(task_id, platform) or {}
+        # 用户确认的连续发布进度独立于平台数行结果；跨卷校准漏行不能
+        # 让已发布的旧章重新进入待发。它是章号边界，不是平台章节数量。
+        through = int(ent.get("confirmed_published_through") or 0)
+        if 0 < through <= 100000:
+            out.update(range(1, through + 1))
         for n in (ent.get("remote_published_nos") or []):
             n = int(n)
             if n > 0:

package/app/core/publish/manager.py

@@ -99,6 +99,7 @@ def _quality_release_guard(task, plat, action="publish", target_chapter=None,
     decision["version_snapshot"] = quality_gate.local_version(task.get("workdir") or "")
     decision["platform_snapshot"] = ledger.book_for(task.get("id"), plat) or {}
     if verdict:
+        decision["reviewed_through"] = verdict.get("end_chapter") or 0
         decision["quality_status"] = verdict.get("quality_status") or "continue_only"
         decision["review_run_id"] = run.get("id")
     return decision
@@ -720,7 +721,10 @@ def register_book(task_id, plat, title, book_id=""):
                 or old.get("title") != title[:120]):
         ledger.update_book(task_id, plat, remote_total=None, remote_published=None,
                            remote_review=None, remote_rejected=None,
-                           remote_synced_at=None, remote_error=None)
+                           remote_synced_at=None, remote_error=None,
+                           remote_published_nos=None,
+                           confirmed_published_through=None,
+                           confirmed_published_at=None)
     ledger.save_book(task_id, plat, {"book_id": str(book_id or "").strip(),
                                      "title": title[:120], "source": "manual"})
     return True, ""

package/app/core/registry.py

@@ -22,6 +22,41 @@ MOCK_AGENTS = [
 _LOCK = threading.RLock()
 
 
+def capability_manifest(entry):
+    """Return one explicit, UI-safe capability contract for a backend.
+
+    The manifest is descriptive only: it never grants a backend extra access.
+    Execution remains governed by the task contract, sandbox policy and command
+    authorization gates.
+    """
+    entry = entry or {}
+    orch = entry.get("orch") or {}
+    kind = str(orch.get("kind") or "")
+    transport = "acp" if kind == "acp" or str(entry.get("id") or "").startswith("acp-") else "cli"
+    resume = bool(orch.get("resume_argv_template"))
+    if kind == "mock":
+        transport = "mock"
+        resume = False
+    platforms = entry.get("platforms")
+    if not isinstance(platforms, list) or not platforms:
+        platforms = ["windows", "linux", "macos"]
+    platforms = [str(x) for x in platforms if str(x) in ("windows", "linux", "macos")]
+    if not platforms:
+        platforms = ["windows", "linux", "macos"]
+    declared = entry.get("capabilities") if isinstance(entry.get("capabilities"), dict) else {}
+    return {
+        "id": str(entry.get("id") or ""),
+        "transport": transport,
+        "resume": resume,
+        "sandbox": str(declared.get("sandbox") or "task-policy"),
+        "approval": str(declared.get("approval") or "task-contract"),
+        "mcp": bool(declared.get("mcp", kind in ("acp", "mcp"))),
+        "platforms": platforms,
+        "model_tiers": [str(x) for x in (declared.get("model_tiers") or
+                                           ["budget", "standard", "premium"])[:8]],
+    }
+
+
 def load_enabled():
     try:
         return json.loads(paths.ENABLED_FILE.read_text(encoding="utf-8"))

package/app/core/review_requests.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+"""Append-only external human-review requests with idempotent transitions."""
+from __future__ import annotations
+
+import json
+import secrets
+import threading
+import time
+from pathlib import Path
+
+from . import paths
+
+_LOCK = threading.RLock()
+_FILE = paths.DATA_DIR / "review-requests.jsonl"
+_STATUSES = {"requested", "assigned", "approved", "changes_requested", "dismissed", "expired"}
+_TRANSITIONS = {
+    "assign": ("requested", "assigned"),
+    "approve": ("assigned", "approved"),
+    "changes_requested": ("assigned", "changes_requested"),
+    "dismiss": (("requested", "assigned", "changes_requested"), "dismissed"),
+    "expire": (("requested", "assigned", "changes_requested"), "expired"),
+}
+
+
+def _normalize_paths(value):
+    if isinstance(value, str):
+        value = [value]
+    if not isinstance(value, (list, tuple, set)):
+        return []
+    return [str(item).strip()[:500] for item in value
+            if str(item or "").strip()][:200]
+
+
+def _read():
+    latest = {}
+    try:
+        lines = Path(_FILE).read_text(encoding="utf-8").splitlines()[-5000:]
+    except OSError:
+        return latest
+    for line in lines:
+        try:
+            row = json.loads(line)
+        except (TypeError, ValueError):
+            continue
+        if isinstance(row, dict) and row.get("id"):
+            latest[row["id"]] = row
+    return latest
+
+
+def list_requests():
+    """Return the latest version of each request in append-only storage."""
+    with _LOCK:
+        return list(_read().values())
+
+
+def _append(row):
+    path = Path(_FILE)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n")
+        handle.flush()
+
+
+def route_channel(paths_changed, rules=None, default_channel=""):
+    """Select the channel with the most matching changed files."""
+    paths_changed = _normalize_paths(paths_changed)
+    rules = [r for r in (rules or []) if isinstance(r, dict)]
+    best, best_count = "", 0
+    import fnmatch
+    for rule in rules:
+        channel = str(rule.get("channel") or "").strip()
+        patterns = _normalize_paths(rule.get("paths"))
+        count = sum(1 for path in paths_changed if any(fnmatch.fnmatchcase(path, str(p)) for p in patterns))
+        if channel and count > best_count:
+            best, best_count = channel, count
+    return best or str(default_channel or "")[:200]
+
+
+def create(run_id, *, summary="", paths=None, channel="", now=None):
+    if not str(run_id or "").strip():
+        raise ValueError("run_id 不能为空")
+    stamp = float(now if now is not None else time.time())
+    row = {"id": "review-" + secrets.token_hex(10), "run_id": str(run_id or "")[:100],
+           "summary": str(summary or "")[:1000],
+           "paths": _normalize_paths(paths),
+           "channel": str(channel or "")[:200], "status": "requested",
+           "version": 1, "created_at": stamp, "updated_at": stamp}
+    with _LOCK:
+        _append(row)
+    return row
+
+
+def get(request_id):
+    with _LOCK:
+        return _read().get(str(request_id or ""))
+
+
+def transition(request_id, action, *, reviewer="", reason="", now=None):
+    with _LOCK:
+        row = _read().get(str(request_id or ""))
+        if not row:
+            raise KeyError("评审请求不存在")
+        action = str(action or "").strip().lower()
+        if action not in _TRANSITIONS:
+            raise ValueError("不支持的评审状态操作")
+        allowed, target = _TRANSITIONS[action]
+        if row.get("status") == target:
+            return row
+        if row.get("status") not in allowed:
+            raise ValueError("当前评审状态不允许此操作")
+        stamp = float(now if now is not None else time.time())
+        updated = dict(row, status=target, version=int(row.get("version") or 1) + 1,
+                       updated_at=stamp)
+        if reviewer:
+            updated["reviewer"] = str(reviewer)[:200]
+        if reason:
+            updated["reason"] = str(reason)[:1000]
+        _append(updated)
+        return updated

package/app/core/runner.py

@@ -1775,7 +1775,11 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
         bash = find_git_bash()
         if bash:
             base_env.setdefault("CLAUDE_CODE_GIT_BASH_PATH", bash)
-        base_env.setdefault("CLAUDE_CODE_MAX_OUTPUT_TOKENS", "16000")
+        # 32000=claude CLI 官方默认（自定义网关模型常见上限）：旧值 16000 在
+        # 全局评审读 40 万字书稿时被输出顶爆——CLI 按 16000/轮反复续烧 23.5
+        # 分钟、$3 后报 "response exceeded the 16000 output token maximum"
+        # （2026-10-11 实案×3）；setdefault 保留：用户显式配置不覆盖
+        base_env.setdefault("CLAUDE_CODE_MAX_OUTPUT_TOKENS", "32000")
     sid = (resume or "").strip() if agent.get("mode") == "real" else ""
     if sid and kind == "generic" and not agent.get("resume_argv_template"):
         return {"ok": False, "text": "", "json": None, "cost_usd": 0.0, "tokens": 0,

package/app/core/runtime_lock.py

@@ -0,0 +1,75 @@
+"""One service per data directory, shared by CLI and desktop launchers."""
+from __future__ import annotations
+
+import atexit
+import os
+from pathlib import Path
+from typing import IO, Optional
+
+
+class ServiceAlreadyRunning(RuntimeError):
+    """Another process owns this data directory."""
+
+
+class ServiceLease:
+    """OS-backed lock; a crashed process releases it automatically."""
+
+    def __init__(self, directory: Path):
+        self.directory = Path(directory)
+        self._file: Optional[IO[bytes]] = None
+
+    def acquire(self) -> None:
+        if self._file is not None:
+            return
+        self.directory.mkdir(parents=True, exist_ok=True)
+        # Never unlink this file: replacing its inode defeats POSIX file locks.
+        handle = (self.directory / "service.lock").open("a+b")
+        try:
+            if os.name == "nt":
+                import msvcrt
+                handle.seek(0, os.SEEK_END)
+                if handle.tell() == 0:
+                    handle.write(b"0")
+                    handle.flush()
+                handle.seek(0)
+                msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)
+            else:
+                import fcntl
+                fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError as exc:
+            handle.close()
+            raise ServiceAlreadyRunning(
+                "CodeBee 已在使用此数据目录，请先退出已有服务：%s" % self.directory
+            ) from exc
+        self._file = handle
+
+    def release(self) -> None:
+        handle, self._file = self._file, None
+        if handle is not None:
+            # Closing the handle releases both flock and Windows byte locks.
+            handle.close()
+        key = str(self.directory.resolve())
+        if _LEASES.get(key) is self:
+            _LEASES.pop(key, None)
+
+    def __enter__(self) -> "ServiceLease":
+        self.acquire()
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.release()
+
+
+_LEASES = {}
+
+
+def acquire_service(directory: Path) -> ServiceLease:
+    """Keep a service lease until process exit; repeated startup calls reuse it."""
+    key = str(Path(directory).resolve())
+    lease = _LEASES.get(key)
+    if lease is None or lease._file is None:
+        lease = ServiceLease(Path(key))
+        lease.acquire()
+        _LEASES[key] = lease
+        atexit.register(lease.release)
+    return lease