codebee 0.1.69 → 0.1.70

package/app/core/publish/manager.py

@@ -452,8 +452,9 @@ def create_book_async(task_id, plat, auto_submit=False):
                     metadata={"platform": plat, "action": "create_book"})
             ledger.record(plat, "create_book", task_id=task_id, title=book_name,
                           book_id=book_id, ok=bool(book_id),
-                          error=("\n".join(logs)[:2000] if book_id else
-                                 "建书结果未知：未取得远端 book_id；请先对账"),
+                          error=((("" if book_id else
+                                   "建书结果未知：未取得远端 book_id；请先对账\n")
+                                  + "\n".join(logs))[:2000] or None),
                           shot=str(ledger.shot_path(plat, task_id, "")),
                           operation_id=operation_id, operation_status=operation_status,
                           remote_receipt=book_id)
@@ -489,6 +490,13 @@ def register_book(task_id, plat, title, book_id=""):
     title = (title or "").strip()
     if not title:
         return False, "作品名必填（发章按作品名在平台找书）"
+    # 换绑另一本书（book_id/title 变了）时旧书的校准数作废，防张冠李戴
+    old = ledger.book_for(task_id, plat) or {}
+    if old and (old.get("book_id") != str(book_id or "").strip()
+                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)
     ledger.save_book(task_id, plat, {"book_id": str(book_id or "").strip(),
                                      "title": title[:120]})
     return True, ""
@@ -684,6 +692,130 @@ def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False):
     return True, ""
 
 
+# ------------------------------------------------ 已发章数校准（平台实况对账）
+# 台账只记得 CodeBee 自己发成功的章：用户在平台窗口里手工补交/平台驳回/
+# 台账重复记录都会让「已发 N」漂移（2026-09-28 实案：番茄平台 8 章台账 7）。
+# 校准 = 打开章节管理页数行，按状态关键词分桶后写回 books.json 的 remote_*。
+
+_STATUS_PUB = "已发布"
+_STATUS_REVIEW = ("待审核", "审核中", "排队")
+_STATUS_BAD = ("未通过", "驳回")
+
+
+def bucket_chapter_rows(rows):
+    """章节管理页的行文本 → {total, published, review, rejected}。
+
+    行里含状态关键词才计入对应桶；total=识别出的章节数据行数。"""
+    out = {"total": 0, "published": 0, "review": 0, "rejected": 0}
+    for t in rows or []:
+        t = str(t)
+        if not t:
+            continue
+        if "章节名称" in t:                     # 表头兜底（正常到不了这）
+            continue
+        out["total"] += 1
+        if any(k in t for k in _STATUS_BAD):
+            out["rejected"] += 1
+        elif _STATUS_PUB in t:
+            out["published"] += 1
+        elif any(k in t for k in _STATUS_REVIEW):
+            out["review"] += 1
+    return out
+
+
+def sync_published(task_id, plat, manual=False):
+    """同步执行一次校准（manager.sync_published_async 的线程体）。
+
+    manual=False（打开作品页自动触发）只 attach 在跑的浏览器实例，绝不
+    静默 launch 新窗口吓人；manual=True（用户点「校准」按钮）才允许
+    attach-or-launch。识别不到章节行（改版/未登录/分页）时只记 note
+    不覆写 remote_*——宁可显示旧数也不把 0 当真相。"""
+    from .browser import Browser
+    book = ledger.book_for(task_id, plat)
+    if not book:
+        return False, "该任务未在此平台登记作品"
+    if _st(plat).get("status") == "busy":
+        return False, "该平台有操作正在进行中"
+    mod = PLATFORMS[plat]
+    js = mod.CONFIG.get("count_rows_js")
+    if not js:
+        return False, "该平台未配置章节计数"
+    try:
+        if manual:
+            b, page = _open_page(plat)
+        else:
+            port = _st(plat).get("port") or 0
+            b = Browser.attach(int(port))       # 实例已死 → 异常 → 只记原因
+            page = b.first_page(create=True)
+    except Exception as e:
+        return False, "浏览器未连接，点「连接平台」后再校准"
+    try:
+        page.navigate(mod.chapter_manage_url(book), timeout=40)
+        time.sleep(4.0)                         # SPA 表格慢渲染
+        url = str(page.url() or "")
+        if any(m in url for m in mod.CONFIG["login_url_marks"]) \
+                or url.startswith("chrome-error://"):
+            return False, "平台登录态已失效，请重连后校准"
+        rows = page.call(js) or []
+        st = bucket_chapter_rows(rows)
+        if st["total"] <= 0:
+            return False, "章节管理页未识别到章节列表（可能改版）"
+        ledger.update_book(task_id, plat,
+                           remote_total=st["total"],
+                           remote_published=st["published"],
+                           remote_review=st["review"],
+                           remote_rejected=st["rejected"],
+                           remote_synced_at=time.strftime("%Y-%m-%d %H:%M:%S"))
+        return True, ""
+    except Exception as e:
+        return False, "校准失败：%s" % str(e)[:160]
+
+
+def _sync_preflight(task_id, plat, manual):
+    """校准前置检查（同步、不碰浏览器页面）：登记在案/没在忙/平台支持；
+    自动触发（manual=False）时还要求浏览器实例活着——绝不静默 launch。"""
+    from .browser import Browser
+    if plat not in PLATFORMS:
+        return False, "未知平台"
+    if not ledger.book_for(task_id, plat):
+        return False, "该任务未在此平台登记作品"
+    if _st(plat).get("status") == "busy":
+        return False, "该平台有操作正在进行中"
+    if not PLATFORMS[plat].CONFIG.get("count_rows_js"):
+        return False, "该平台未配置章节计数"
+    if not manual:
+        port = _st(plat).get("port") or 0
+        try:
+            Browser.attach(int(port))
+        except Exception:
+            return False, "浏览器未连接，点「连接平台」后再校准"
+    return True, ""
+
+
+def sync_published_async(task_id, plat, manual=False):
+    """校准进后台线程（浏览器操作绝不能堵 HTTP 线程）。
+
+    返回 (ok, err)：预检失败时线程都不起，接口即时回报 skipped 原因。"""
+    ok, err = _sync_preflight(task_id, plat, manual)
+    if not ok:
+        return False, err
+
+    def run():
+        ok2, err2 = sync_published(task_id, plat, manual=manual)
+        if not ok2:
+            ledger.update_book(task_id, plat, remote_error=err2,
+                               remote_synced_at=time.strftime("%Y-%m-%d %H:%M:%S"))
+
+    threading.Thread(target=run, daemon=True,
+                     name="pub-sync-%s" % plat).start()
+    return True, ""
+
+
+def published_local(task_id, plat):
+    """本地台账口径的已发章数（去重后的章号数，记录数会因重试虚高）。"""
+    return len(ledger.published_chapters(task_id, plat))
+
+
 def history(task_id=None, plat=None, limit=50):
     return ledger.recent(task_id=task_id, platform=plat, limit=limit)
 

package/app/core/publish/qimao.py

@@ -19,6 +19,11 @@ CONFIG = {
     # 编辑器顶栏明示「正文字数最少 1000 字」——不足时「立即发布」被静默拦截
     "min_chapter_chars": 1000,
     "login_url_marks": ["login", "signin", "passport", "sso"],
+    # 章节管理页计数（2026-09-28 实机校准）：Element UI 表格，.el-table__row
+    # 只中数据行（表头在独立的 header-wrapper 表里），与发章流程的等待选择器同源
+    "count_rows_js":
+        "()=>[...document.querySelectorAll('.el-table__row')]"
+        ".map(tr => tr.innerText.replace(/\\s+/g, ' ').trim()).filter(Boolean)",
 }
 
 CREATE_BOOK = [

package/app/core/remotesync.py

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+"""备份包远程推送（WebDAV / S3 兼容 PUT 端点）：data/ 不在 git 里、磁盘一坏
+全没——本机产品额外给备份包一条出站活路。
+
+L0 自由层（读 settings + 依赖 runner 起进程都合法）。curl -T 流式上传：
+备份包可能 GB 级（含工作目录），绝不能整包读进内存。密钥只存本机
+settings.json，推送时才带 Basic auth 发给用户自己配的端点。
+"""
+from __future__ import annotations
+
+import json
+
+from . import runner   # L0→L2 合法方向（小层号依赖大层号）；模块级绑定便于测试打桩
+
+_MAX_TIMEOUT_S = 3600
+
+
+def _cfg():
+    try:
+        from . import settings
+        s = settings.load()
+        return {"enabled": bool(s.get("backup_remote_enabled")),
+                "url": str(s.get("backup_remote_url") or "").strip().rstrip("/"),
+                "user": str(s.get("backup_remote_user") or "").strip(),
+                "pass": str(s.get("backup_remote_pass") or "")}
+    except Exception:
+        return {"enabled": False, "url": "", "user": "", "pass": ""}
+
+
+def push_remote(zip_path, timeout_s=1800):
+    """把备份包 PUT 到远程端点。返回 {"ok","skipped","status","error"}。"""
+    cfg = _cfg()
+    if not cfg["enabled"] or not cfg["url"]:
+        return {"ok": False, "skipped": True, "status": 0, "error": "未启用远程备份"}
+    from pathlib import Path
+    p = Path(zip_path)
+    if not p.is_file():
+        return {"ok": False, "skipped": False, "status": 0, "error": "备份包不存在"}
+    argv = ["curl", "-sS", "-f", "-T", str(p), "--max-time", str(max(60, timeout_s)),
+            cfg["url"] + "/" + p.name]
+    if cfg["user"] or cfg["pass"]:
+        argv += ["--user", cfg["user"] + ":" + cfg["pass"]]
+    try:
+        r = runner.run_process(argv=argv, timeout=timeout_s + 100)
+    except Exception as e:
+        return {"ok": False, "skipped": False, "status": 0, "error": str(e)[:200]}
+    err = (r.get("stderr") or "").strip().splitlines()
+    return {"ok": bool(r.get("ok")), "skipped": False,
+            "status": 200 if r.get("ok") else 0,
+            "error": "" if r.get("ok") else (err[-1] if err else "上传失败")[:200]}
+
+
+def test_remote():
+    """连通性测试：PUT 一个小探针文件（同端点同凭据）。"""
+    import os
+    import tempfile
+    fd, p = tempfile.mkstemp(prefix="codebee-remote-", suffix=".txt")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write("CodeBee remote backup probe")
+        return push_remote(p, timeout_s=60)
+    finally:
+        try:
+            os.unlink(p)
+        except OSError:
+            pass
+
+
+def _curl_common_args():
+    cfg = _cfg()
+    argv = ["curl", "-sS", "-f", "--max-time", "120"]
+    if cfg["user"] or cfg["pass"]:
+        argv += ["--user", cfg["user"] + ":" + cfg["pass"]]
+    return cfg, argv
+
+
+def list_remote():
+    """列远程端点上的备份包（WebDAV PROPFIND，其他端点回落 GET 目录页）。
+    返回 (文件名列表, 错误)。仅支持 push 时同款 URL 前缀。"""
+    cfg, argv = _curl_common_args()
+    if not cfg["enabled"] or not cfg["url"]:
+        return None, "未启用远程备份"
+    r = runner.run_process(
+        argv=argv + ["-X", "PROPFIND", "-H",
+                     "Content-Type: application/xml", "-H", "Depth: 1",
+                     "--data-binary", "", cfg["url"] + "/"], timeout=150)
+    if not r.get("ok"):
+        err = (r.get("stderr") or "").strip().splitlines()
+        return None, (err[-1] if err else "列举失败（端点可能不支持 PROPFIND）")[:200]
+    import re as _re
+    text = str(r.get("stdout") or "")
+    names = sorted({m for m in _re.findall(
+        r"codebee-backup-\d{8}-\d{6}\.zip", text)}, reverse=True)
+    return names, None
+
+
+def pull_remote(name):
+    """从远程端点拉备份包到本机 imports 目录（走现有导入向导）。
+    name 必须精确匹配 codebee-backup-*.zip 形态（防路径注入）。
+    返回 (本地路径, 错误)。"""
+    import re as _re
+    name = str(name or "").strip()
+    if not _re.match(r"^codebee-backup-\d{8}-\d{6}\.zip$", name):
+        return None, "非法的备份包名"
+    cfg, argv = _curl_common_args()
+    if not cfg["enabled"] or not cfg["url"]:
+        return None, "未启用远程备份"
+    from . import paths
+    dest_dir = paths.DATA_DIR / "imports"
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / name
+    r = runner.run_process(
+        argv=argv + ["-o", str(dest), cfg["url"] + "/" + name], timeout=1900)
+    if not r.get("ok") or not dest.is_file() or dest.stat().st_size == 0:
+        try:
+            dest.unlink()
+        except OSError:
+            pass
+        err = (r.get("stderr") or "").strip().splitlines()
+        return None, (err[-1] if err else "拉取失败")[:200]
+    return str(dest), None

package/app/core/runner.py

@@ -631,7 +631,7 @@ def _normalize_abort_markers(value):
 def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                 timeout=DEFAULT_TIMEOUT, cancel_event=None, log_path=None,
                 stall_timeout=0, repeat_abort=None, deadline=None,
-                abort_markers=None, activity_timeout=0):
+                abort_markers=None, activity_timeout=0, audit_notes=None):
     """通用子进程执行：并发读管道防死锁；超时/取消杀整棵进程树。
 
     stall_timeout：停滞看门狗（秒，0=关闭）——超过该时长 stdout/stderr 无任何
@@ -652,6 +652,10 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
     到点会杀掉进程树并返回 deadline_exceeded=True，调用方可把整个任务收口
     为 timeout，而不是把它误记成普通供应商失败。
 
+    audit_notes：可选字符串列表，逐行追加在审计头命令行下方——用于把
+    argv/env 里看不出的运行形态钉进日志（如 claude 凭据=绑定链注入/本机默认），
+    事后诊断不用靠猜。只写形态名，绝不写密钥值。
+
     返回 {ok, exit_code, stdout, stderr, duration, cancelled, timed_out, stalled,
     deadline_exceeded, abort_marker}；杀树后未能确认整树清空时额外带
     quiescence_unknown=True（孙进程可能仍在，诊断用，不改变终态语义）。
@@ -695,6 +699,9 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
         try:
             head = ["===== 下达 %s =====" % time.strftime("%Y-%m-%d %H:%M:%S"),
                     "$ " + " ".join(str(a) for a in argv)]
+            for _note in (audit_notes or []):
+                if _note:
+                    head.append("· " + str(_note))
             if stdin_text:
                 capped = stdin_text[:12000]
                 head.append("--- 指令（%d 字符%s）---" % (
@@ -1063,6 +1070,64 @@ def _claude_drift_note(att_model, parsed):
     return "[模型漂移] 请求 %s，上游实服 %s" % (att_model, ",".join(served))
 
 
+_LOGIN_FIX_HINTS = {
+    "claude": ("① 绑定页为 claude-code 配置供应商链（如 Bigmodel anthropic 面）；"
+               "② 在 ~/.claude/settings.json 的 env 里配 ANTHROPIC_BASE_URL"
+               " + ANTHROPIC_AUTH_TOKEN"),
+    "codex": ("① 绑定页为 codex 配置供应商链；② 本机执行 codex login 完成登录"),
+}
+
+
+def _login_hint(kind, error_code, error_text):
+    """凭据注入型 CLI 撞登录闸门的修复指引；非缺凭据或非登录措辞返回空。
+
+    「无链回落本机默认」时 runner 不注入任何凭据（_resolve_attempts 的 env
+    恒空），本机 CLI 又没登录 → 每步必死还烧满退避。把修法直接写进错误串，
+    别让一句「Not logged in」冒充死因（2026-09-25 Mac 端 claude 实案：init
+    JSON 里 apiKeySource=none，链上零候选可换将）。措辞闸保持窄词：
+    login failed / invalid credentials 是 AUTH 语义，不进缺凭据指引。"""
+    if error_code_value(error_code) != ErrorCode.MISSING_CREDENTIAL:
+        return ""
+    low = str(error_text or "").lower()
+    if ("not logged in" not in low and "please run /login" not in low
+            and "please log in" not in low):
+        return ""
+    fix = _LOGIN_FIX_HINTS.get(kind) or (
+        "① 绑定页为该 CLI 配置供应商链（带密钥的供应商条目）；"
+        "② 完成该 CLI 的本机登录或在其自家配置里注入 API Key")
+    return ("；%s CLI 未登录且本步未注入绑定链凭据，修复二选一：%s"
+            % (kind, fix))
+
+
+def _cred_audit_note(kind, att, argv):
+    """步骤审计头的凭据模式行（run_process audit_notes 用，所有 CLI 通用）。
+
+    注入真值按 kind 分流：claude 只认 argv 里的 --settings（_build_call 只在
+    env 带 ANTHROPIC_* 时落它——ORCH_API_KEY 这类别家约定的键对 claude 无效，
+    不得按 env 非空误报「绑定链注入」）；其余 kind 的 env 直接传给进程，
+    env 非空即有效注入。条目级 no_cred 标记（resolve_binding 给纯模型条目
+    打标）独立点名。只写形态名与变量名，密钥值绝不入日志。
+    2026-09-25 Mac 实案：纯模型条目零注入，进程死在登录闸门后只能靠 init
+    JSON 的 apiKeySource=none 反推死因；起跑就把凭据模式钉进日志头，且不限
+    claude——codex/kimi/qwen 等 generic 的零凭据起跑同样一眼可读。"""
+    if kind == "claude":
+        if any(str(a) == "--settings" for a in (argv or [])):
+            return "凭据=绑定链（一次性 --settings 注入 ANTHROPIC_*）"
+        if att.get("no_cred"):
+            return ("凭据=无注入（链上纯模型条目零凭据，只传 -m 走本机 claude "
+                    "登录态；未登录则 -p 必死在登录闸门）")
+        return ("凭据=本机默认（未注入 ANTHROPIC_*，走本机 claude 登录态；"
+                "未登录则 -p 必死在登录闸门）")
+    if att.get("no_cred"):
+        return ("凭据=无注入（链上纯模型条目零凭据，只传 -m 走本机 CLI 登录态；"
+                "本机未登录/未配置则必死在凭据闸门）")
+    env = att.get("env") or {}
+    if env:
+        return "凭据=绑定链注入（env: %s）" % ",".join(sorted(env))
+    return ("凭据=本机默认（本步未注入任何凭据 env，走 CLI 本机登录态/配置；"
+            "未登录则必死在登录/凭据闸门）")
+
+
 def _log_note(log_path, text):
     if not log_path or not text:
         return
@@ -1189,9 +1254,11 @@ def _classify_failure(res, *, parsed=None, kind="", attempt_done=False, empty_ou
         classified = classify_error_text(detail)
         if classified is not None:
             return classified
-    # claude 解析失败（进程 ok 但 JSON 不可解析）
+    # claude 解析失败（进程 ok 但无 result 事件）：先按 stdout 认错误——未登录
+    # 闸门只吐一行「Not logged in · Please run /login」就退出，认不出才是
+    # 真正的解析失败
     if kind == "claude" and parsed is None:
-        return ErrorCode.PARSE_FAIL
+        return classify_error_text(res.get("stdout") or "") or ErrorCode.PARSE_FAIL
     # claude 明确 is_error
     if parsed and parsed.get("is_error"):
         return ErrorCode.VENDOR_REFUSAL
@@ -1226,7 +1293,8 @@ def _resolve_attempts(agent):
                  "own_cp": "codex_provider" in e,
                  "codex_provider": e.get("codex_provider"),
                  "provider_id": e.get("provider_id") or "",
-                 "key_id": e.get("key_id") or ""} for e in chain]
+                 "key_id": e.get("key_id") or "",
+                 "no_cred": bool(e.get("no_cred"))} for e in chain]
     base_model = agent.get("model")
     fb = [m for m in (agent.get("model_fallbacks") or []) if m and m != base_model]
     models_to_try = ([base_model] if base_model else []) + fb
@@ -1693,6 +1761,9 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                     att["model"], prompt,
                     images=images if kind == "codex" else None,
                     workdir=workdir)
+                # 凭据模式起跑钉进审计头（所有 CLI）：注入真值按 kind 分流，
+                # claude 以 argv 的 --settings 为准，见 _cred_audit_note
+                audit_notes = [_cred_audit_note(kind, att, argv)]
                 try:
                     repeat_guard = (("Reconnecting...", 2)
                                     if kind == "codex" else None)
@@ -1715,7 +1786,8 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                                       log_path=log_path, stall_timeout=stall_t,
                                       activity_timeout=activity_t,
                                       repeat_abort=repeat_guard,
-                                      abort_markers=stream_abort_markers)
+                                      abort_markers=stream_abort_markers,
+                                      audit_notes=audit_notes)
                 finally:
                     # 超长指令临时文件：CLI 进程已结束（管道已收），即刻清场不污染工作目录
                     for tf in tmp_files:
@@ -1796,6 +1868,8 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                                       if _permission_error(out["error"])
                                       else classify_error_text(out["error"])
                                       or _classify_failure(res, kind=kind))
+                out["error"] += _login_hint(kind, out["error_code"],
+                                            out["error"])
                 break
             if kind == "codex":
                 out["text"], out["usage"], out_sid = _parse_codex_jsonl(res["stdout"])
@@ -1830,6 +1904,7 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                     out["ok"] = False
                     out["error"] = "claude 输出无法解析为 JSON；stdout 尾部: " + res["stdout"][-500:]
                     out["error_code"] = _classify_failure(res, kind="claude", parsed=None)
+                    out["error"] += _login_hint("claude", out["error_code"], out["error"])
                     break
                 out["text"] = parsed["text"]
                 out["cost_usd"] = parsed["cost_usd"]

package/app/core/settings.py

@@ -21,9 +21,24 @@ _FILE = paths.DATA_DIR / "settings.json"
 # 运行时出现（空闲 90s 隐身）。
 # cleanup_enabled / cleanup_retention_days：每日垃圾清理（core/cleanup.py）——
 # 运行过程日志/发布截图/bak 残留等超期自动清理；retention 为保留天数。
+# 个人推送通道（core/notify.py 读取）：Bark（iOS）/ ntfy（自托管友好）/
+# Server酱（微信）/ Telegram Bot。密钥只存本机 settings.json，不出网（推送
+# 时才带着发给对应服务）。bark_server 留空回落官方 api.day.app。
 DEFAULTS = {"max_concurrent_jobs": 12, "default_workdir": "", "hooks_token": "",
             "telemetry_errors": True, "publish_daily_cap": 10,
             "publish_fail_streak": 3, "notify_webhook": "", "notify_base_url": "",
+            "notify_bark_server": "", "notify_bark_key": "",
+            "notify_ntfy_topic": "", "notify_serverchan_key": "",
+            "notify_telegram_token": "", "notify_telegram_chat_id": "",
+            # 评测台定时回归（evalbench.fire_due，automation tick 调用）：
+            # enabled=False 关；days 间隔天数控节流；mcp_servers=内置智能体的
+            # MCP 服务器清单（JSON 数组字符串，stdio 形态）
+            "bench_auto_enabled": False, "bench_auto_days": 7,
+            "mcp_servers": "",
+            # 备份远程通道（remotesync）：导出成功后自动 PUT 到 WebDAV/S3 兼容
+            # 端点（Basic auth）；密钥只存本机
+            "backup_remote_enabled": False, "backup_remote_url": "",
+            "backup_remote_user": "", "backup_remote_pass": "",
             "pet_enabled": True, "pet_mode": "always", "pet_skin": "plush",
             "cleanup_enabled": True, "cleanup_retention_days": 14,
             # claude_config_sync：打开/运行前防线是否直写 ~/.claude/settings.json。
@@ -40,8 +55,10 @@ MIN_WORKERS, MAX_WORKERS = 1, 24
 
 
 def builtin_workdir():
-    """内置默认保存路径：<data 目录同级>/workspace。"""
-    return str(paths.DATA_DIR.parent / "workspace")
+    """内置默认保存路径：数据目录内的 workspace/（CodeBee 自己的地盘，
+    启动 ensure_dirs 即创建；老版本落在数据目录同级——Windows 上是
+    AppData\\Roaming\\workspace，平时不存在点开即报错，已废弃）。"""
+    return str(paths.DATA_DIR / "workspace")
 
 
 def default_workdir():
@@ -118,6 +135,26 @@ def save(patch):
             cur["notify_webhook"] = str(patch.get("notify_webhook") or "").strip()[:300]
         if "notify_base_url" in patch:
             cur["notify_base_url"] = str(patch.get("notify_base_url") or "").strip()[:200]
+        for _nk, _nmax in (("notify_bark_server", 200), ("notify_bark_key", 128),
+                           ("notify_ntfy_topic", 200), ("notify_serverchan_key", 128),
+                           ("notify_telegram_token", 128), ("notify_telegram_chat_id", 64)):
+            if _nk in patch:
+                cur[_nk] = str(patch.get(_nk) or "").strip()[:_nmax]
+        if "bench_auto_enabled" in patch:
+            cur["bench_auto_enabled"] = bool(patch.get("bench_auto_enabled"))
+        if "bench_auto_days" in patch:
+            try:
+                cur["bench_auto_days"] = max(1, min(90, int(patch.get("bench_auto_days"))))
+            except (TypeError, ValueError):
+                return cur, "bench_auto_days 必须是 1-90 的整数"
+        if "mcp_servers" in patch:
+            cur["mcp_servers"] = str(patch.get("mcp_servers") or "").strip()[:4000]
+        if "backup_remote_enabled" in patch:
+            cur["backup_remote_enabled"] = bool(patch.get("backup_remote_enabled"))
+        for _rk, _rmax in (("backup_remote_url", 300), ("backup_remote_user", 128),
+                           ("backup_remote_pass", 128)):
+            if _rk in patch:
+                cur[_rk] = str(patch.get(_rk) or "").strip()[:_rmax]
         if "pet_enabled" in patch:
             cur["pet_enabled"] = bool(patch.get("pet_enabled"))
         if "pet_mode" in patch:

package/app/core/settings_schema.py

@@ -248,6 +248,14 @@ def register_default_namespaces():
                 FieldDef("max_tokens_per_run", "int", 0,
                          "单次运行 token 预算上限（0=不限；超额停止后续步骤，等自动续跑）",
                          clamp=(0, 100_000_000)),
+                # 花费硬顶（¥，按台账标定单价折算：手标单价优先，回落导入价表；
+                # 未标定单价的调用不记钱也不计入——宁缺毋滥）：0 = 不限。
+                FieldDef("daily_cost_yuan", "float", 0.0,
+                         "每日花费上限（¥，按标定单价折算；0=不限；超额停止后续步骤）",
+                         clamp=(0, 1_000_000)),
+                FieldDef("monthly_cost_yuan", "float", 0.0,
+                         "每月花费上限（¥，按标定单价折算；0=不限；超额停止后续步骤）",
+                         clamp=(0, 1_000_000)),
             ],
             validate=lambda v: None,
         )

package/app/core/store.py

@@ -18,7 +18,7 @@ import threading
 import time
 from pathlib import Path
 
-from . import artifacts, paths, runner, tracing, volumes
+from . import artifacts, audit, paths, runner, tracing, volumes
 
 LOCK = threading.RLock()
 _TASKS = {}
@@ -148,7 +148,7 @@ def create_task(payload):
         raise ValueError("目标描述不能为空")
     title = title or goal.splitlines()[0][:30]  # 标题可省略，自动取目标首行
     if not workdir:
-        # 未指定目录 → 用「默认保存路径」（设置里可改；内置回落 <data 同级>/workspace）。
+        # 未指定目录 → 用「默认保存路径」（设置里可改；内置回落 <数据目录>/workspace）。
         # 默认路径允许自动创建；用户显式给的目录仍必须已存在。
         from . import settings as settings_mod
         workdir = settings_mod.default_workdir()
@@ -487,8 +487,8 @@ def get_task(task_id):
     return None
 
 
-def list_tasks(limit=100, archived=None):
-    """archived=None 返回全部；False 仅未归档；True 仅已归档。按 id（含时间戳）倒序。"""
+def list_tasks(limit=None, archived=None):
+    """按 id 倒序列任务。archived 筛选归档态；limit=None 返回全部。"""
     with LOCK:
         ids = sorted(_TASKS.keys(), reverse=True)
         out = []
@@ -497,7 +497,7 @@ def list_tasks(limit=100, archived=None):
             if archived is not None and bool(t.get("archived")) != archived:
                 continue
             out.append(t)
-            if len(out) >= limit:
+            if limit is not None and len(out) >= limit:
                 break
         return out
 
@@ -1435,8 +1435,12 @@ def archive_task(task_id, archived=True):
     return True, ""
 
 
-def delete_task(task_id):
-    """删除任务及其全部运行记录（含日志与报告目录）。返回 (ok, 错误信息)。"""
+def delete_task(task_id, actor=""):
+    """删除任务及其全部运行记录（含日志与报告目录）。返回 (ok, 错误信息)。
+
+    不可逆且无回收站，故落审计（谁/何时/删了什么——2026-09-28 连载根任务
+    被删案：事后无人能回答这两问）。连载链的前序任务被后续任务 serial.continues
+    依赖，删了会把整条链的「继续连载/断点续跑」地基抽掉——这类任务只许归档。"""
     if not _valid_id(task_id):
         return False, "非法的任务 ID"
     with LOCK:
@@ -1445,6 +1449,11 @@ def delete_task(task_id):
             return False, "任务不存在"
         if task.get("status") in ("queued", "running"):
             return False, "运行中的任务不能删除，请先取消"
+        if task.get("type") == "serial_novel":
+            for other in _TASKS.values():
+                if other.get("id") != task_id and \
+                        (other.get("serial") or {}).get("continues") == task_id:
+                    return False, "该任务是连载链的前序任务（后续任务依赖它），请用「归档」隐藏而不是删除"
         run_ids = []
         for rid, r in _RUNS.items():
             if r.get("task_id") != task_id:
@@ -1458,6 +1467,15 @@ def delete_task(task_id):
     for rid in run_ids:
         _schedule_run_dir_cleanup(rid)
     (paths.TASKS_DIR / (task_id + ".json")).unlink(missing_ok=True)
+    audit.record("task_delete", {
+        "task_id": task_id,
+        "title": task.get("title") or "",
+        "type": task.get("type") or "",
+        "status": task.get("status") or "",
+        "workdir": task.get("workdir") or "",
+        "run_ids": run_ids,
+        "actor": actor or "local",
+    })
     bump_state()
     return True, ""
 
@@ -1880,7 +1898,7 @@ def clear_stream_state(run_id=None, n=None):
 
 def finish_step(run_id, n, status, summary="", exit_code=None,
                 cost_usd=0.0, tokens=0.0, duration_s=None, model=None, output=None,
-                followups=None, thinking=None):
+                followups=None, thinking=None, partial=False):
     with LOCK:
         run = _RUNS.get(run_id)
         if not run:
@@ -1911,6 +1929,10 @@ def finish_step(run_id, n, status, summary="", exit_code=None,
                     s["thinking"] = runner.strip_ansi(str(thinking))[:LIVE_TEXT_MAX]
                 if followups:
                     s["followups"] = list(followups)[:3]
+                if partial:
+                    s["partial"] = True
+                else:
+                    s.pop("partial", None)
                 # 收尾即清运行中态：stream/activity/live 只是过程快照，留着会让
                 # 前端把「已结束」的步骤仍当实时流渲染（也白占 run.json 体积）
                 s.pop("stream", None)