codebee 0.1.69 → 0.1.70

package/app/core/modelhub.py

@@ -2452,7 +2452,9 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
 
     call_chain 是跨厂商降级链（唯一真源）：每条 {model, env, provider, [codex_provider]}，
     按序尝试；供应商失效（停用/删除/无密钥/协议不可注入）的条目被跳过，全链失效
-    → 整体回落 CLI 默认（None）。纯链条目（无供应商）不注入 env，只传 -m。
+    → 整体回落 CLI 默认（None）。纯链条目（无供应商）不注入 env，只传 -m，
+    并带 no_cred=True 标记供 runner 审计层点名（零凭据条目走本机登录态，
+    本机无登录态必死在凭据闸门——2026-09-25 Mac claude 实案）。
     难度路由只在无显式链时生效。
     """
     # Local-credential-only CLIs must never expose a binding, including legacy
@@ -2487,7 +2489,11 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
             pid = (item.get("provider_id") or "").strip()
             if not pid:
                 if model:
-                    entries.append({"model": model, "env": {}, "provider": None})
+                    # 纯模型条目：零凭据注入，只传 -m 走 CLI 本机登录态。
+                    # no_cred 标记供 runner 审计行/登录指引点名（Mac claude 案：
+                    # 零注入死在登录闸门，起跑前无人知、死后只能靠 init JSON 反推）
+                    entries.append({"model": model, "env": {}, "provider": None,
+                                    "no_cred": True})
                 continue
             prov = provs.get(pid)
             if not prov or not prov.get("enabled", True) or not prov.get("api_key"):
@@ -2803,12 +2809,84 @@ def models_view():
             if m.get("hidden"):
                 continue
             pr = pricing.get(m["name"]) or {}
+            if m.get("price_in") is not None or m.get("price_out") is not None:
+                pr = {"in": m.get("price_in"), "out": m.get("price_out")}   # 手标优先
             rows.append(dict(base, name=m["name"], enabled=bool(m.get("enabled", True)),
                              priority=m.get("priority", 0),
                              price_in=pr.get("in"), price_out=pr.get("out")))
     return rows
 
 
+def model_price(model_name, provider=""):
+    """模型单价（¥ / 百万 tokens）：指定供应商的手标价优先，回落 CCSwitch
+    导入价表；都没有返回 None——不猜价，台账不记钱、预算不计入。
+
+    手标是「按供应商」标定的（同名模型在不同网关价格可不同），因此指定
+    供应商未标价时不继承别家手标，直接看价表。
+    列名沿用台账 cost_usd 字段，语义自本函数起 = 费用（¥）。
+    """
+    def _manual(prov_id):
+        with _LOCK:
+            for p in _load().get("providers", []):
+                if not prov_id or p.get("id") != prov_id:
+                    continue
+                for m in p.get("models") or []:
+                    if m.get("name") != model_name:
+                        continue
+                    try:
+                        pin = float(m.get("price_in"))
+                        pout = float(m.get("price_out"))
+                    except (TypeError, ValueError):
+                        continue
+                    if pin >= 0 and pout >= 0 and (pin or pout):
+                        return {"in": pin, "out": pout}
+        return None
+
+    try:
+        pr = _manual(provider)
+        if pr:
+            return pr
+        with _LOCK:
+            raw = (_load().get("pricing") or {}).get(model_name) or {}
+        pin, pout = float(raw.get("in") or 0), float(raw.get("out") or 0)
+        if pin > 0 or pout > 0:
+            return {"in": pin, "out": pout}
+    except Exception:
+        pass
+    return None
+
+
+def set_model_price(provider_id, name, price_in, price_out):
+    """手标模型单价（¥/百万 tokens；空串=清除标定，回落价表/未标价）。"""
+    def _num(v):
+        v = str(v if v is not None else "").strip()
+        return float(v) if v != "" else None
+    try:
+        pin, pout = _num(price_in), _num(price_out)
+    except (TypeError, ValueError):
+        return "单价必须是数字"
+    if (pin is not None and pin < 0) or (pout is not None and pout < 0):
+        return "单价不能为负"
+    with _LOCK:
+        data = _load()
+        prov = next((p for p in data.get("providers", []) if p.get("id") == provider_id), None)
+        if not prov:
+            return "供应商不存在"
+        m = next((x for x in prov.get("models") or [] if x.get("name") == name), None)
+        if not m:
+            return "模型不存在"
+        if pin is None:
+            m.pop("price_in", None)
+        else:
+            m["price_in"] = pin
+        if pout is None:
+            m.pop("price_out", None)
+        else:
+            m["price_out"] = pout
+        _save(data)
+    return None
+
+
 def reorder_models(provider_id, ordered_names):
     """按给定名称顺序重设优先级（列表中未出现的模型排在最后，保持相对顺序）。"""
     with _LOCK:
@@ -3103,6 +3181,111 @@ def test_model(provider_id, model_name, key_id=""):
     return finish(last)
 
 
+def generate_once(provider_id, model_name, prompt, max_tokens=2048, timeout_s=120):
+    """单轮真实生成（评测基准台等需要「自定义 prompt 实答」的场景）。
+
+    与 test_model 同一套 wire 解析（auto 探测/多 KEY 回退/KEY 健康记账），
+    但发的是真实生成请求并取回正文。返回
+    {ok, text, usage{input,output}, protocol, key_id, latency_ms, error}；
+    任何失败折叠进 ok=False + error，绝不抛出。
+    """
+    import time as _t
+    with _LOCK:
+        prov = next((p for p in providers() if p.get("id") == provider_id), None)
+    if not prov:
+        return {"ok": False, "text": "", "usage": None, "error": "供应商不存在"}
+    keys = _chain_keys(prov)
+    if not keys:
+        return {"ok": False, "text": "", "usage": None, "error": "无可用 API KEY"}
+    allow_private = bool(prov.get("allow_private"))
+    t0 = _t.time()
+
+    def out(ok, text="", usage=None, protocol="", key_id="", error=""):
+        return {"ok": ok, "text": text, "usage": usage, "protocol": protocol,
+                "key_id": key_id, "error": error,
+                "latency_ms": int((_t.time() - t0) * 1000)}
+
+    last_err = "无可用 wire"
+    for key_index, kk in enumerate(keys):
+        probe_key_id = (kk.get("id") or "") if key_index > 0 else ""
+        protos, note = _ensure_wire_candidates(provider_id, prov, model_name,
+                                               key_id=probe_key_id,
+                                               force_probe=bool(probe_key_id))
+        if not protos:
+            last_err = "无已验证的兼容 wire" + ("（%s）" % note if note else "")
+            note_key_error(provider_id, kk.get("id") or "", last_err)
+            continue
+        for proto, pbase in protos:
+            base = (pbase or "").rstrip("/")
+            if proto == "google":
+                url = base + ("/models/%s:generateContent" % model_name
+                              if base.endswith("/v1beta")
+                              else "/v1beta/models/%s:generateContent" % model_name)
+                headers = {"x-goog-api-key": kk["key"]}
+                body = {"contents": [{"parts": [{"text": prompt}]}],
+                        "generationConfig": {"maxOutputTokens": max_tokens}}
+            else:
+                path = "/messages" if proto == "anthropic" else "/chat/completions"
+                url = (base + path) if base.endswith("/v1") else (base + "/v1" + path)
+                if proto == "anthropic":
+                    headers = {"x-api-key": kk["key"], "anthropic-version": "2023-06-01"}
+                else:
+                    headers = {"Authorization": "Bearer " + kk["key"]}
+                body = {"model": model_name, "max_tokens": max_tokens,
+                        "messages": [{"role": "user", "content": prompt}]}
+            status, data, err = _post_json_http(url, headers, body, allow_private,
+                                                timeout=timeout_s)
+            if status == 0:
+                last_err = err or "连接失败"
+                note_key_error(provider_id, kk.get("id") or "", last_err)
+                continue
+            if not (200 <= status < 300):
+                last_err = "HTTP %s %s" % (status, _response_error_text(data) or "")
+                note_key_error(provider_id, kk.get("id") or "", last_err)
+                continue
+            text, usage_d = _extract_generation(proto, data)
+            if not (text or "").strip():
+                last_err = "HTTP 200 空响应"
+                note_key_error(provider_id, kk.get("id") or "", last_err)
+                continue
+            note_key_ok(provider_id, kk.get("id") or "")
+            return out(True, text, usage_d, proto, kk.get("id") or "")
+    return out(False, error=last_err)
+
+
+def _extract_generation(proto, data):
+    """从三族 wire 的生成响应里取正文与 token 细分。取不到返回 ("", None)。"""
+    if not isinstance(data, dict):
+        return "", None
+    text, usage_d = "", None
+    try:
+        if proto == "openai":
+            msg = ((data.get("choices") or [{}])[0] or {}).get("message") or {}
+            c = msg.get("content")
+            text = c if isinstance(c, str) else "".join(
+                p.get("text") or "" for p in c) if isinstance(c, list) else ""
+            u = data.get("usage") or {}
+            usage_d = {"input": u.get("prompt_tokens") or 0,
+                       "output": u.get("completion_tokens") or 0}
+        elif proto == "anthropic":
+            text = "".join(b.get("text") or "" for b in data.get("content") or []
+                           if isinstance(b, dict) and b.get("type") == "text")
+            u = data.get("usage") or {}
+            usage_d = {"input": u.get("input_tokens") or 0,
+                       "output": u.get("output_tokens") or 0}
+        elif proto == "google":
+            cand = ((data.get("candidates") or [{}])[0] or {})
+            text = "".join(p.get("text") or "" for p in (cand.get("content") or {}).get("parts") or [])
+            u = data.get("usageMetadata") or {}
+            usage_d = {"input": u.get("promptTokenCount") or 0,
+                       "output": u.get("candidatesTokenCount") or 0}
+    except Exception:
+        pass
+    if usage_d is not None and not any(isinstance(v, (int, float)) for v in usage_d.values()):
+        usage_d = None
+    return text, usage_d
+
+
 # ---------------------------------------------------------------- wire 协议适配
 # 聚合中转网关（new-api/one-api 系）通常同一密钥同时开 openai(/chat/completions)
 # 与 anthropic(/v1/messages) 两面 wire。在「模型接入」页用 1 token 最小对话实测，

package/app/core/notify.py

@@ -1,9 +1,12 @@
 # -*- coding: utf-8 -*-
-"""运行结果群推送（借鉴 agency-orchestrator 的 --notify）：任务跑完把结果摘要
+"""运行结果推送（借鉴 agency-orchestrator 的 --notify）：任务跑完把结果摘要
 推到钉钉/飞书/企业微信群机器人，配合定时自动化就是「AI 团队每天定点交活」。
 
-webhook 一个地址全包——按域名自动适配三种机器人格式（同 agency-orchestrator
-思路）；也接受任意 https 地址（按钉钉 text 形状发，自建 n8n 等自选）。
+两类通道：
+  - 群机器人 webhook 一个地址全包——按域名自动适配三种机器人格式；也接受
+    任意 https 地址（按钉钉 text 形状发，自建 n8n 等自选）。
+  - 个人推送通道（Bark / ntfy / Server酱 / Telegram Bot）：推到私人手机，
+    无人值守场景「半夜失败/待裁决」的刚需；群机器人是给群里看的，这是给你看的。
 推送在后台线程、失败只记日志——通知永远不影响任务本身。
 """
 from __future__ import annotations
@@ -36,29 +39,117 @@ def _webhook():
         return ""
 
 
-def _post(hook, text):
-    """curl 子进程 POST（Python 不经手响应体）；网络失败只记日志。"""
+def _send(url, json_body=None, form=None):
+    """curl 子进程发送（Python 不经手响应体）；网络失败只记日志。返回 bool。
+
+    json_body=JSON 体；form=表单体（值需 UTF-8 百分号编码，urlencode 负责）。
+    中文一律走请求体（Server酱表单 / ntfy JSON publish），不走 HTTP 头——
+    头里的非 ASCII 会被网关拒收（历史坑）。
+    """
     from . import runner
     import json as _json
-    body = _json.dumps(_payload_for(hook, text), ensure_ascii=False)
-    r = runner.run_process(
-        argv=["curl", "-sS", "--max-time", "20",
-              "-H", "Content-Type: application/json",
-              "-d", body, hook],
-        timeout=30)
+    argv = ["curl", "-sS", "--max-time", "20"]
+    if json_body is not None:
+        argv += ["-H", "Content-Type: application/json",
+                 "-d", _json.dumps(json_body, ensure_ascii=False)]
+    elif form is not None:
+        from urllib.parse import urlencode
+        argv += ["-H", "Content-Type: application/x-www-form-urlencoded",
+                 "-d", urlencode(form)]
+    argv.append(url)
+    r = runner.run_process(argv=argv, timeout=30)
     return bool(r["ok"])
 
 
-def push_text(text):
-    """推一条文本到群。配置了 webhook 才推；失败返回 False 不抛错。"""
+def _post(hook, text):
+    return _send(hook, json_body=_payload_for(hook, text))
+
+
+def _personal_channels():
+    """读设置里的个人推送配置，返回 [(通道名, 发送函数(title, body)), ...]。
+
+    只收录配置完整的通道；键名与 settings.DEFAULTS 对齐。
+    """
+    from . import settings
+    s = settings.load()
+    chs = []
+
+    bark_key = str(s.get("notify_bark_key") or "").strip()
+    if bark_key:
+        server = (str(s.get("notify_bark_server") or "").strip().rstrip("/")
+                  or "https://api.day.app")
+        chs.append(("bark", lambda t, b: _send(
+            server + "/push",
+            json_body={"device_key": bark_key, "title": t, "body": b})))
+
+    ntfy = str(s.get("notify_ntfy_topic") or "").strip()
+    if ntfy:
+        from urllib.parse import urlparse
+        u = urlparse(ntfy if "://" in ntfy else "https://ntfy.sh/" + ntfy.lstrip("/"))
+        topic = u.path.strip("/")
+        if topic:
+            server = "%s://%s" % (u.scheme, u.netloc)
+            chs.append(("ntfy", lambda t, b: _send(
+                server + "/",
+                json_body={"topic": topic, "title": t, "message": b})))
+
+    sc_key = str(s.get("notify_serverchan_key") or "").strip()
+    if sc_key:
+        chs.append(("serverchan", lambda t, b: _send(
+            "https://sctapi.ftqq.com/%s.send" % sc_key,
+            form={"title": t, "desp": b})))
+
+    tg_token = str(s.get("notify_telegram_token") or "").strip()
+    tg_chat = str(s.get("notify_telegram_chat_id") or "").strip()
+    if tg_token and tg_chat:
+        chs.append(("telegram", lambda t, b: _send(
+            "https://api.telegram.org/bot%s/sendMessage" % tg_token,
+            json_body={"chat_id": tg_chat, "text": (t + "\n" + b).strip()})))
+    return chs
+
+
+def _split_title(text):
+    """首行作标题（≤40 字），其余作正文；单行文本标题正文同文。"""
+    lines = [ln for ln in str(text).splitlines() if ln.strip()]
+    title = (lines[0].strip() if lines else "CodeBee")[:40]
+    body = "\n".join(ln.strip() for ln in lines[1:]).strip() or title
+    return title, body
+
+
+def push_text_ex(text):
+    """推一条文本到全部已配置通道，返回 {通道名: 是否成功}。
+
+    未配置任何通道返回 {}；单通道失败不影响其他通道。
+    """
+    results = {}
     hook = _webhook()
-    if not hook:
-        return False
-    if not hook.startswith("https://"):
-        log.warning("notify webhook 必须是 https")
-        return False
+    if hook:
+        if not hook.startswith("https://"):
+            log.warning("notify webhook 必须是 https")
+            results["webhook"] = False
+        else:
+            try:
+                results["webhook"] = _post(hook, text)
+            except Exception as e:
+                log.warning("notify push failed: %s", e)
+                results["webhook"] = False
+    try:
+        title, body = _split_title(text)
+    except Exception:
+        title, body = "CodeBee", str(text)
+    for name, fn in _personal_channels():
+        try:
+            results[name] = bool(fn(title, body))
+        except Exception as e:
+            log.warning("notify %s push failed: %s", name, e)
+            results[name] = False
+    return results
+
+
+def push_text(text):
+    """推一条文本；任一通道成功即 True；全未配置/全失败返回 False，不抛错。"""
     try:
-        return _post(hook, text)
+        return any(push_text_ex(text).values())
     except Exception as e:
         log.warning("notify push failed: %s", e)
         return False
@@ -71,13 +162,10 @@ def push_run_async(run_id):
 
 
 def push_run(run_id):
-    """组装 run 结果摘要并推送（webhook 未配置时静默跳过）。
+    """组装 run 结果摘要并推送（群 webhook 或任一个人通道配置了才推）。
 
     摘要末尾附分享页路径（notify_base_url 设置非空时拼完整链接，否则只给
     run_id 供在本机 CodeBee 界面查找）。"""
-    hook = _webhook()
-    if not hook:
-        return False
     from . import store
     run = store.get_run(run_id) or {}
     if not run:
@@ -100,6 +188,13 @@ def push_run(run_id):
             lines.append("📄 详情：%s/api/runs/%s/share" % (base, run_id))
     except Exception:
         pass
+    # 分支待裁决：任务跑完有改动等人拍板时点名提醒（手机端看到即可去详情处理）
+    try:
+        task = store.get_task(run.get("task_id")) if run.get("task_id") else None
+        if task and task.get("git_state") == "isolated":
+            lines.append("⚠ 任务分支待裁决（合并/丢弃）")
+    except Exception:
+        pass
     return push_text("\n".join(lines))
 
 

package/app/core/novel_quality.py

@@ -0,0 +1,189 @@
+# -*- coding: utf-8 -*-
+"""Deterministic quality checks for signing-oriented Chinese web fiction.
+
+The LLM remains responsible for literary judgment.  This module supplies
+stable rubric defaults and small text signals so reviewers can cite evidence
+for the common rejection reasons instead of relying on vague impressions.
+"""
+from __future__ import annotations
+
+import re
+
+
+SIGNING_RUBRIC = [
+    "开篇吸引力",
+    "情节推进",
+    "文风统一",
+    "情感细腻度",
+    "节奏控制",
+]
+
+OPENING_DIM = "开篇吸引力"
+SIGNING_CHECKPOINT_WORDS = 20000   # 平台口径：前 2 万字用于签约评估
+
+_SENTENCE_RE = re.compile(r"[^。！？!?；;\n]+[。！？!?；;]?")
+_DIALOGUE_RE = re.compile(r"[“‘\"「『](.*?)[”’\"」』]", re.S)
+_EMOTION_RE = re.compile(r"哭|泪|笑|怒|怕|颤|抖|咬|攥|握紧|心跳|呼吸|喉咙|指甲|沉默")
+
+
+def rubric_for(task):
+    """Return the configured rubric, or the signing rubric for serial novels."""
+    task = task if isinstance(task, dict) else {}
+    raw = task.get("rubric")
+    if isinstance(raw, str):
+        raw = [x.strip() for x in raw.replace("，", ",").split(",") if x.strip()]
+    if isinstance(raw, (list, tuple)):
+        values = [str(x).strip() for x in raw if str(x).strip()]
+        if values:
+            return values[:8]
+    if str(task.get("type") or "").lower() == "serial_novel":
+        return list(SIGNING_RUBRIC)
+    return []
+
+
+def opening_requirements(chapter, target_words=None):
+    """Return concise, chapter-aware acceptance requirements for prompts."""
+    try:
+        chapter = int(chapter)
+    except (TypeError, ValueError):
+        chapter = 1
+    if chapter == 1:
+        try:
+            short = int(target_words or 0) < 1200
+        except (TypeError, ValueError):
+            short = False
+        core = ("前 1200 字" if short else "前 2000 字")
+        return ("黄金一章门禁：前 100 字让读者知道主角是谁；前 200 字出现异常、欲望或冲突；"
+                "前 600 字把困境具体化；%s 展示核心卖点；结尾必须留下可兑现的钩子。" % core
+                + "禁止用世界观、环境或人物关系长铺垫开场。")
+    return "本章门禁：开头尽快承接上一章并制造新变化；结尾必须留下下一步行动或可兑现的章末钩子。"
+
+
+def signal_summary(text, chapter=None):
+    """Extract explainable text signals; no claim is made that they are scores."""
+    text = str(text or "").replace("\r\n", "\n").strip()
+    paragraphs = [p.strip() for p in re.split(r"\n\s*\n", text) if p.strip()]
+    sentences = [s.strip() for s in _SENTENCE_RE.findall(text) if s.strip()]
+    sentence_lengths = [len(re.sub(r"\s+", "", s)) for s in sentences]
+    dialogue_chars = sum(len(x) for x in _DIALOGUE_RE.findall(text))
+    emotion_hits = len(_EMOTION_RE.findall(text))
+    chars = len(re.sub(r"\s+", "", text))
+    avg = round(sum(sentence_lengths) / len(sentence_lengths), 1) if sentence_lengths else 0.0
+    long_sentences = sum(1 for n in sentence_lengths if n >= 55)
+    hints = []
+    if chapter == 1 and chars and chars < 600:
+        hints.append("首章正文不足 600 字，无法证明前 600 字已进入具体困境")
+    if avg >= 35 or long_sentences:
+        hints.append("存在偏长句，复查长定语、重复说明与动作拆分")
+    if len(paragraphs) >= 4 and chars / len(paragraphs) > 220:
+        hints.append("段落偏长，复查手机阅读下的节奏与信息密度")
+    if text and dialogue_chars == 0:
+        hints.append("缺少对白证据，复查是否用场景/行动推进冲突")
+    if text and emotion_hits == 0:
+        hints.append("缺少可见的情绪动作或生理反应，复查复杂情感是否写得过于概括")
+    return {
+        "chapter": chapter,
+        "chars": chars,
+        "paragraphs": len(paragraphs),
+        "sentences": len(sentences),
+        "avg_sentence_chars": avg,
+        "long_sentences": long_sentences,
+        "dialogue_chars": dialogue_chars,
+        "emotion_action_hits": emotion_hits,
+        "hints": hints[:6],
+    }
+
+
+def format_signal_summary(summary):
+    """Render signal_summary output as a compact prompt block."""
+    if not isinstance(summary, dict):
+        return ""
+    parts = [
+        "文本信号（仅作证据，不替代文学判断）：约 %s 字；%s 段；%s 句；平均句长 %s 字；长句 %s；对白 %s 字；情绪动作线索 %s 处。"
+        % (summary.get("chars", 0), summary.get("paragraphs", 0),
+           summary.get("sentences", 0), summary.get("avg_sentence_chars", 0),
+           summary.get("long_sentences", 0), summary.get("dialogue_chars", 0),
+           summary.get("emotion_action_hits", 0))]
+    hints = summary.get("hints") or []
+    if hints:
+        parts.append("确定性复查提示：" + "；".join(str(x) for x in hints))
+    return "\n".join(parts)
+
+
+def style_anchor_block(anchor):
+    """Render the book-level style anchor as a prompt block; empty when absent."""
+    anchor = str(anchor or "").strip()
+    if not anchor:
+        return ""
+    return ("## 全书文风锚（大纲裁定，所有章节起草/修订/评审必须遵守；"
+            "与其冲突处以本锚为准）\n%s\n" % anchor[:400])
+
+
+def fingerprint(summary):
+    """Normalize a signal_summary into per-1000-char style metrics."""
+    if not isinstance(summary, dict):
+        return {}
+    chars = max(1, int(summary.get("chars") or 0))
+    return {
+        "avg_sentence_chars": float(summary.get("avg_sentence_chars") or 0.0),
+        "dialogue_per_k": round(1000.0 * float(summary.get("dialogue_chars") or 0) / chars, 1),
+        "emotion_per_k": round(1000.0 * float(summary.get("emotion_action_hits") or 0) / chars, 1),
+    }
+
+
+def _median(values):
+    xs = sorted(float(v) for v in values if isinstance(v, (int, float)))
+    if not xs:
+        return 0.0
+    mid = len(xs) // 2
+    return xs[mid] if len(xs) % 2 else round((xs[mid - 1] + xs[mid]) / 2.0, 1)
+
+
+def style_deviation_notes(baselines, summary, min_baseline=2):
+    """Cross-chapter style drift warnings from deterministic fingerprints.
+
+    baselines: signal_summary dicts of the book's previous chapters.  Needs at
+    least ``min_baseline`` chapters before speaking (开篇几章没有稳定基线)；
+    all notes are evidence hints for reviewers/revisers, never scores.
+    """
+    notes = []
+    base = [fingerprint(b) for b in (baselines or []) if isinstance(b, dict)]
+    base = [b for b in base if b]
+    if len(base) < min_baseline:
+        return notes
+    cur = fingerprint(summary)
+    if not cur:
+        return notes
+    avg_base = _median([b["avg_sentence_chars"] for b in base])
+    if avg_base >= 12 and cur["avg_sentence_chars"] > avg_base * 1.45:
+        notes.append("本章平均句长 %s 字，此前各章中位 %s 字——句式明显变长，"
+                     "复查长定语、说明性插叙与节奏拖沓"
+                     % (cur["avg_sentence_chars"], avg_base))
+    elif avg_base >= 12 and cur["avg_sentence_chars"] < avg_base * 0.62:
+        notes.append("本章平均句长 %s 字，此前各章中位 %s 字——句式明显变碎，"
+                     "复查是否为凑字数拆散动作与因果"
+                     % (cur["avg_sentence_chars"], avg_base))
+    dial_base = _median([b["dialogue_per_k"] for b in base])
+    if dial_base >= 40 and cur["dialogue_per_k"] < dial_base * 0.45:
+        notes.append("对白占比骤降（本章 %s/千字，此前中位 %s/千字）——"
+                     "复查是否换成了大段叙述，文风与推进方式是否漂移"
+                     % (cur["dialogue_per_k"], dial_base))
+    emo_base = _median([b["emotion_per_k"] for b in base])
+    if emo_base >= 1.5 and cur["emotion_per_k"] < emo_base * 0.4:
+        notes.append("情绪动作密度骤降（本章 %s/千字，此前中位 %s/千字）——"
+                     "复查复杂情感是否退回「很伤心/很愤怒」式概括"
+                     % (cur["emotion_per_k"], emo_base))
+    return notes
+
+
+def opening_below(means, threshold):
+    """True when the signing opening dimension is scored below the line."""
+    try:
+        value = float((means or {}).get(OPENING_DIM))
+    except (TypeError, ValueError):
+        return False
+    try:
+        line = float(threshold)
+    except (TypeError, ValueError):
+        return False
+    return value < line

package/app/core/paths.py

@@ -66,3 +66,7 @@ LOG_TAIL_CHARS = 4000  # API 返回日志时的截断长度
 def ensure_dirs():
     for p in (DATA_DIR, TASKS_DIR, RUNS_DIR):
         p.mkdir(parents=True, exist_ok=True)
+    # 内置默认保存路径（settings.builtin_workdir）启动即建，用户没自定义时
+    # 「打开目录」/选目录不会撞上不存在的路径。这里不能 import settings（会环），
+    # 且即使用户自定义了默认路径，多建一个空 workspace 也无害。
+    (DATA_DIR / "workspace").mkdir(parents=True, exist_ok=True)