codebee 0.1.70 → 0.1.72

package/app/core/publish/manager.py

@@ -23,7 +23,7 @@ import re
 import threading
 import time
 
-from .. import operations, paths
+from .. import operations, paths, quality_gate
 from . import fanqie, flow, ledger, qimao
 from .browser import Browser, BrowserError, Page
 
@@ -73,6 +73,37 @@ def _st(plat):
     return (_state.get("platforms") or {}).get(plat) or {}
 
 
+def _quality_release_guard(task, plat, action="publish", target_chapter=None,
+                           force=False, force_confirmed=False, force_reason=""):
+    """Return a release decision backed by the latest completed review.
+
+    Non-fiction/code tasks keep their existing publish workflow; novel release
+    actions must carry a verifiable quality verdict.  This keeps the gate
+    focused on the signing failure mode without breaking generic file publish.
+    """
+    if str(task.get("type") or "").lower() not in ("novel", "serial_novel") \
+            and (task.get("engine") or "") != "review":
+        return {"allowed": True, "status": "not_applicable", "blockers": [],
+                "warnings": [], "forced": False}
+    from .. import store
+    verdict = None
+    for run in sorted(store.task_runs(task.get("id")) or [],
+                      key=lambda item: str(item.get("id") or ""), reverse=True):
+        if run.get("status") == "done" and isinstance(run.get("verdict"), dict):
+            verdict = run["verdict"]
+            break
+    decision = quality_gate.evaluate_release(
+        verdict or {}, action=action, target_chapter=target_chapter,
+        platform_version=ledger.book_for(task.get("id"), plat) or {},
+        force=force, force_confirmed=force_confirmed, force_reason=force_reason)
+    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["quality_status"] = verdict.get("quality_status") or "continue_only"
+        decision["review_run_id"] = run.get("id")
+    return decision
+
+
 def view():
     """前端状态视图：平台状态 + 是否找到浏览器 + 作品登记。"""
     from .browser import find_browser
@@ -381,7 +412,8 @@ def _create_preflight(plat, data):
     return ""
 
 
-def create_book_async(task_id, plat, auto_submit=False):
+def create_book_async(task_id, plat, auto_submit=False, force=False,
+                      force_confirmed=False, force_reason=""):
     """按任务 book_meta 的资料在平台建书。返回 (ok, err)。"""
     from .. import store
     if plat not in PLATFORMS:
@@ -389,16 +421,32 @@ def create_book_async(task_id, plat, auto_submit=False):
     task = store.get_task(task_id)
     if not task:
         return False, "任务不存在"
-    meta = ((task.get("book_meta") or {}).get(plat) or {})
+    # 连载链沿链继承（都是用第一个）：续写批次从自己身上建书也用首批生成的资料
+    meta = store.inherited_book_meta(task, plat)
     if meta.get("status") != "done" or not meta.get("data"):
         return False, "请先生成该平台的作品信息"
     if _st(plat).get("status") == "busy":
         return False, "该平台有操作正在进行中"
-    if ledger.book_for(task_id, plat):
-        return False, "该任务已在此平台登记过作品，请直接发章"
+    existing = ledger.book_for(task_id, plat)
+    # A title-only manual registration is usable as a binding. For legacy
+    # entries without source metadata, only a recorded failed create-book
+    # attempt is safe to retry; otherwise it may be a real manual binding.
+    if existing:
+        if existing.get("book_id") or existing.get("source") == "manual":
+            return False, "该任务已在此平台登记过作品，请直接发章"
+        failed_create = any(
+            r.get("action") == "create_book" and not r.get("ok")
+            for r in ledger.recent(task_id=task_id, platform=plat, limit=50))
+        if not failed_create:
+            return False, "该任务已有作品登记但未确认，请登记已有作品或先在平台核对"
     why = _create_preflight(plat, meta["data"])
     if why:
         return False, why
+    quality = _quality_release_guard(
+        task, plat, action="publish", force=force,
+        force_confirmed=force_confirmed, force_reason=force_reason)
+    if not quality.get("allowed"):
+        return False, "质量门禁拦截：%s" % "；".join(quality.get("blockers") or [])
     ok_login, why = _login_guard(plat)
     if not ok_login:
         return False, why
@@ -458,7 +506,8 @@ def create_book_async(task_id, plat, auto_submit=False):
                           shot=str(ledger.shot_path(plat, task_id, "")),
                           operation_id=operation_id, operation_status=operation_status,
                           remote_receipt=book_id)
-            ledger.save_book(task_id, plat, {"book_id": book_id, "title": book_name})
+            ledger.save_book(task_id, plat, {"book_id": book_id, "title": book_name,
+                                             "source": "create"})
             _set(plat, status="connected", error="")
         except Exception as e:
             operations.finish_exception(operation_id, e)
@@ -498,7 +547,7 @@ def register_book(task_id, plat, title, book_id=""):
                            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]})
+                                     "title": title[:120], "source": "manual"})
     return True, ""
 
 
@@ -608,7 +657,8 @@ def read_chapter(fp):
     return ch_no, title, body, ""
 
 
-def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False):
+def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False,
+                         force=False, force_confirmed=False, force_reason=""):
     """把一章发到平台（或填好待人工确认）。幂等：已成功发布的章号拒绝重发。"""
     from .. import store
     if plat not in PLATFORMS:
@@ -619,6 +669,8 @@ def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False):
     book = ledger.book_for(task_id, plat)
     if not book:
         return False, "该任务尚未在此平台建书，请先「创建作品」"
+    if not book.get("book_id") and book.get("source") != "manual":
+        return False, "该平台建书结果未确认（缺少作品 ID），请重试创建作品或登记已有作品"
     # 闭包中需要在找回 book_id 后更新书籍引用；使用独立副本避免
     # Python 将 book 误判为 run() 的局部变量，导致前置解析触发
     # UnboundLocalError。
@@ -628,6 +680,11 @@ def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False):
     ch_no, title, body, err = read_chapter(chapter_file)
     if err:
         return False, err
+    quality = _quality_release_guard(
+        task, plat, action="publish", target_chapter=ch_no or None,
+        force=force, force_confirmed=force_confirmed, force_reason=force_reason)
+    if not quality.get("allowed"):
+        return False, "质量门禁拦截：%s" % "；".join(quality.get("blockers") or [])
     n_chars = len(body.replace("\n", "").replace(" ", ""))
     if n_chars < 100:
         return False, "正文过短（%d 字），疑似未完成章节" % n_chars
@@ -665,16 +722,27 @@ def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False):
                 values.update(_url_values(mod, book_ref))
                 ledger.save_book(task_id, plat, book_ref)
                 logs.append("已按书名找回 book_id=%s 并更新登记" % bid)
+            elif not book_ref.get("book_id"):
+                raise RuntimeError("未按作品名找到远端作品，未打开章节编辑器；"
+                                   "请检查平台作品名或补填作品 ID")
             flow.run_flow(page, load_flow(plat, "upload_chapter"), values=values,
                           config=mod.CONFIG, auto_submit=auto_submit,
                           shot=lambda n: page.screenshot(ledger.shot_path(plat, task_id, n)),
                           log=logs.append)
-            operations.confirm(operation_id, metadata={"platform": plat,
-                                                        "action": "upload_chapter",
-                                                        "chapter_no": ch_no})
-            ledger.record(plat, "upload_chapter", task_id=task_id, chapter_no=ch_no,
-                          book_id=book_ref.get("book_id") or "", title=title, ok=True,
-                          operation_id=operation_id, operation_status="confirmed")
+            if auto_submit:
+                operations.confirm(operation_id, metadata={"platform": plat,
+                                                            "action": "upload_chapter",
+                                                            "chapter_no": ch_no})
+                ledger.record(plat, "upload_chapter", task_id=task_id, chapter_no=ch_no,
+                              book_id=book_ref.get("book_id") or "", title=title, ok=True,
+                              operation_id=operation_id, operation_status="confirmed")
+            else:
+                # run_flow stops immediately before the submit step. Keep the
+                # operation pending and never count the filled form as published.
+                ledger.record(plat, "upload_chapter_pending", task_id=task_id,
+                              chapter_no=ch_no, book_id=book_ref.get("book_id") or "",
+                              title=title, ok=False, error="等待人工提交",
+                              operation_id=operation_id, operation_status="pending")
             _set(plat, status="connected", error="")
         except Exception as e:
             operations.finish_exception(operation_id, e)
@@ -692,6 +760,45 @@ def upload_chapter_async(task_id, plat, chapter_file, auto_submit=False):
     return True, ""
 
 
+def confirm_manual_chapter(task_id, plat, chapter_no):
+    """Record an explicit user confirmation after submitting in the browser."""
+    from .. import store
+    if plat not in PLATFORMS:
+        return False, "未知平台"
+    if not store.get_task(task_id):
+        return False, "任务不存在"
+    try:
+        chapter_no = int(chapter_no or 0)
+    except (TypeError, ValueError):
+        chapter_no = 0
+    if chapter_no <= 0:
+        return False, "章号无效"
+    if chapter_no in ledger.published_chapters(task_id, plat):
+        return True, ""
+    pending = next((r for r in ledger.recent(task_id=task_id, platform=plat, limit=100)
+                    if r.get("action") == "upload_chapter_pending"
+                    and int(r.get("chapter_no") or 0) == chapter_no), None)
+    if not pending:
+        return False, "没有找到待确认的填稿记录，请先重新填入该章"
+    op_id = pending.get("operation_id") or ""
+    current = operations.get(op_id) if op_id else None
+    if current and current.get("status") == "pending":
+        ok = operations.confirm(op_id, remote_receipt="manual-confirmed",
+                                metadata={"platform": plat, "action": "upload_chapter"})
+    elif current:
+        ok = operations.reconcile(op_id, "confirmed", remote_receipt="manual-confirmed",
+                                  metadata={"platform": plat, "action": "upload_chapter"})
+    else:
+        ok = True
+    if not ok:
+        return False, "待确认操作状态已变化，请重新校准后再试"
+    ledger.record(plat, "upload_chapter", task_id=task_id, chapter_no=chapter_no,
+                  book_id=pending.get("book_id") or "", title=pending.get("title") or "",
+                  ok=True, operation_id=op_id, operation_status="confirmed",
+                  remote_receipt="manual-confirmed")
+    return True, ""
+
+
 # ------------------------------------------------ 已发章数校准（平台实况对账）
 # 台账只记得 CodeBee 自己发成功的章：用户在平台窗口里手工补交/平台驳回/
 # 台账重复记录都会让「已发 N」漂移（2026-09-28 实案：番茄平台 8 章台账 7）。

package/app/core/quality_gate.py

@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+"""Deterministic quality and release gates for generated fiction.
+
+LLM reviewers provide judgements; this module decides whether the evidence is
+valid enough to support a release action.  It deliberately treats missing,
+malformed, out-of-range and non-consensus scores as unevaluated.
+"""
+from __future__ import annotations
+
+import math
+import re
+from pathlib import Path
+
+
+MIN_REVIEWERS = 2
+DEFAULT_MAX_SPREAD = 2.0
+_CHAPTER_RE = re.compile(r"^chapter-(\d{1,4})\.(?:md|txt)$", re.I)
+
+
+def normalize_scores(raw, dimensions):
+    """Return (scores, errors); incomplete scores are invalid as a set."""
+    raw = raw if isinstance(raw, dict) else {}
+    scores, errors = {}, {}
+    for dim in dimensions or []:
+        value = raw.get(dim)
+        try:
+            number = float(value)
+        except (TypeError, ValueError):
+            errors[dim] = "非数字"
+            continue
+        if not math.isfinite(number) or number < 1.0 or number > 10.0:
+            errors[dim] = "必须在 1-10 之间"
+            continue
+        scores[dim] = round(number, 2)
+    if errors or len(scores) != len(list(dimensions or [])):
+        return {}, errors or {str(d): "缺失" for d in dimensions or [] if d not in scores}
+    return scores, {}
+
+
+def aggregate_reviews(reviews, dimensions, threshold=7.0,
+                      min_reviewers=MIN_REVIEWERS,
+                      max_spread=DEFAULT_MAX_SPREAD):
+    """Validate reviewers, calculate means, and require reviewer consensus."""
+    dims = list(dimensions or [])
+    valid = []
+    invalid = []
+    seen = set()
+    for idx, review in enumerate(reviews or []):
+        review = review if isinstance(review, dict) else {}
+        reviewer_id = str(review.get("id") or "reviewer-%d" % idx)
+        if reviewer_id in seen:
+            continue
+        seen.add(reviewer_id)
+        scores, errors = normalize_scores(review.get("scores"), dims)
+        if errors:
+            invalid.append({"id": reviewer_id, "errors": errors})
+        else:
+            valid.append({"id": reviewer_id, "scores": scores})
+
+    reasons = []
+    eligible = len(valid) >= int(min_reviewers)
+    if not eligible:
+        reasons.append("至少需要 %d 名有效评审，当前 %d 名" %
+                       (int(min_reviewers), len(valid)))
+    means = {}
+    spreads = {}
+    for dim in dims:
+        values = [r["scores"][dim] for r in valid]
+        if values:
+            means[dim] = round(sum(values) / len(values), 1)
+            spreads[dim] = round(max(values) - min(values), 1)
+
+    consensus = bool(eligible and means and
+                     all(spreads.get(dim, float("inf")) <= float(max_spread)
+                         for dim in dims))
+    if eligible and not consensus:
+        bad = [dim for dim in dims if spreads.get(dim, float("inf")) > float(max_spread)]
+        reasons.append("评审分歧超过 %.1f 分：%s" % (float(max_spread), "、".join(bad)))
+    passed = bool(consensus and means and
+                  all(value >= float(threshold) for value in means.values()))
+    if consensus and not passed:
+        reasons.append("综合分存在低于 %.1f 的维度" % float(threshold))
+    return {
+        "eligible": eligible,
+        "consensus": consensus,
+        "passed": passed,
+        "means": means,
+        "spreads": spreads,
+        "valid_reviewers": valid,
+        "invalid_reviewers": invalid,
+        "reviewer_count": len(valid),
+        "reasons": reasons,
+    }
+
+
+def local_version(workdir):
+    """Return the local manuscript version used for a release decision."""
+    root = Path(workdir or "")
+    rows = []
+    if root.is_dir():
+        for path in root.iterdir():
+            match = _CHAPTER_RE.match(path.name)
+            if not match or not path.is_file():
+                continue
+            try:
+                text = path.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                continue
+            rows.append((int(match.group(1)), len(re.sub(r"\s", "", text))))
+    return {
+        "local_total": len(rows),
+        "local_latest": max((n for n, _ in rows), default=0),
+        "local_words": sum(words for _, words in rows),
+    }
+
+
+def evaluate_release(verdict, action="publish", target_chapter=None,
+                     platform_version=None, force=False,
+                     force_confirmed=False, force_reason=""):
+    """Decide whether a publish/signing action is allowed.
+
+    ``continue`` is intentionally separate: writers may continue improving an
+    unready manuscript, while publishing and signing remain gated.
+    """
+    verdict = verdict if isinstance(verdict, dict) else {}
+    action = str(action or "publish").strip().lower()
+    if action == "continue":
+        return {"allowed": True, "status": "continue_only", "forced": False,
+                "blockers": [], "warnings": []}
+
+    blockers = []
+    warnings = []
+    if verdict.get("publishable") is not True:
+        blockers.append("最近一次质量评审未达标")
+    if verdict.get("global_pass") is False:
+        blockers.append("全局一致性评审未通过")
+    if verdict.get("global_reviewer_count", 0) < MIN_REVIEWERS:
+        blockers.append("有效全局评审不足 %d 名" % MIN_REVIEWERS)
+    if verdict.get("global_reviewer_consensus") is False:
+        blockers.append("全局评审未形成共识")
+    chapter_scores = verdict.get("chapter_scores") or []
+    if target_chapter is not None:
+        try:
+            target = int(target_chapter)
+        except (TypeError, ValueError):
+            target = 0
+        try:
+            reviewed_end = int(verdict.get("end_chapter") or 0)
+        except (TypeError, ValueError):
+            reviewed_end = 0
+        if target > 0 and reviewed_end < target:
+            blockers.append("目标章节超出最近评审版本（目标第 %d 章，评审至第 %d 章）" %
+                            (target, reviewed_end))
+    if chapter_scores and any(c.get("passed") is not True for c in chapter_scores):
+        blockers.append("存在未达标章节")
+    if any(c.get("reviewer_count", MIN_REVIEWERS) < MIN_REVIEWERS or
+           c.get("reviewer_consensus") is False for c in chapter_scores):
+        blockers.append("存在评审人数不足或无共识章节")
+    majors = [x for x in (verdict.get("major_issues") or [])
+              if isinstance(x, dict) and x.get("severity") == "major"]
+    if majors:
+        blockers.append("存在 major 问题（共 %d 条）" % len(majors))
+
+    if action == "signing":
+        checkpoint = verdict.get("signing_checkpoint") or {}
+        if checkpoint.get("passed") is not True:
+            blockers.append("2 万字签约检查点未通过")
+        if checkpoint.get("reviewer_count", MIN_REVIEWERS) < MIN_REVIEWERS:
+            blockers.append("签约检查点有效评审不足 %d 名" % MIN_REVIEWERS)
+        if checkpoint.get("reviewer_consensus") is False:
+            blockers.append("签约检查点评审未形成共识")
+        remote = platform_version if isinstance(platform_version, dict) else {}
+        remote_n = remote.get("remote_published")
+        if remote_n is None:
+            remote_n = remote.get("remote_total")
+        end_chapter = int(target_chapter or verdict.get("end_chapter") or 0)
+        if end_chapter and (remote_n is None or int(remote_n or 0) < end_chapter):
+            blockers.append("平台版本与申请评审版本不一致（本地第 %d 章，平台已发布第 %d 章）" %
+                            (end_chapter, int(remote_n or 0)))
+
+    forced = bool(force)
+    if blockers and forced:
+        if not force_confirmed:
+            blockers.append("强制放行必须二次确认")
+        if not str(force_reason or "").strip():
+            blockers.append("强制放行必须填写人工复核原因")
+        if force_confirmed and str(force_reason or "").strip() and \
+                all("强制放行必须" not in x for x in blockers):
+            warnings = list(blockers)
+            blockers = []
+    allowed = not blockers
+    return {"allowed": allowed, "status": "allowed" if allowed else "blocked",
+            "forced": bool(allowed and forced), "blockers": blockers,
+            "warnings": warnings}

package/app/core/settings.py

@@ -16,7 +16,8 @@ _FILE = paths.DATA_DIR / "settings.json"
 # 「导出诊断包」是用户手动操作不受此开关限制）
 # publish_daily_cap / publish_fail_streak：自动发布护栏——每任务每平台每日
 # 成功发章上限、平台连续失败几次后暂停自动发布（publish/auto.py 读取）
-# pet_enabled / pet_mode：桌面蜜蜂（app/pet.py）开关与显示模式。关闭后看护线程
+# pet_enabled / pet_mode：桌面蜜蜂（app/pet.py）开关与显示模式（默认关，设置页
+# 可开）。关闭后看护线程不再拉起、在岗蜜蜂轮询到 false 自行退出；mode=always
 # 不再拉起、在岗蜜蜂轮询到 false 自行退出；mode=always 常驻，tasks_only 仅任务
 # 运行时出现（空闲 90s 隐身）。
 # cleanup_enabled / cleanup_retention_days：每日垃圾清理（core/cleanup.py）——
@@ -39,7 +40,7 @@ DEFAULTS = {"max_concurrent_jobs": 12, "default_workdir": "", "hooks_token": "",
             # 端点（Basic auth）；密钥只存本机
             "backup_remote_enabled": False, "backup_remote_url": "",
             "backup_remote_user": "", "backup_remote_pass": "",
-            "pet_enabled": True, "pet_mode": "always", "pet_skin": "plush",
+            "pet_enabled": False, "pet_mode": "always", "pet_skin": "plush",
             "cleanup_enabled": True, "cleanup_retention_days": 14,
             # claude_config_sync：打开/运行前防线是否直写 ~/.claude/settings.json。
             # 关闭后交互 claude 配置归用户手动管理（cc-switch 等），编排步骤经

package/app/core/skill_scan.py

@@ -66,6 +66,23 @@ _PATTERNS = [
     (r"(you (are|must) (now|act as)|从此你是|你现在必须"
      r"|从现在起你(?:是|扮演|成为|要[^。\n]{0,4}服从)|请你扮演)",
      "越权人格", "试图重设助手人格"),
+    # SkillSpector 规则对表补充（0929 第四轮：AR/OH/TR 三族缺口）
+    (r"(do not|don't|never|不用|无需|不必)[^\n]{0,14}"
+     r"(refuse|decline|reject|reject)|(?:拒绝|推辞)[^\n]{0,6}(?:是)?(?:禁止|不允许|违规)"
+     r"|you (?:will|must) (?:always|never fail to) comply",
+     "提示注入", "反拒答抑制（试图关掉模型的拒绝能力）"),
+    (r"(omit|skip|remove)[^\n]{0,16}(disclaimer|warning|safety)"
+     r"|(?:省略|跳过|不要加|去掉)[^\n]{0,10}(?:免责|声明|安全(?:提示|警告|策略))",
+     "提示注入", "免责/安全声明抑制"),
+    (r"(?:your|the) (?:output|response|answer)[^\n]{0,30}"
+     r"(?:will be|is) (?:executed|run|evaluated as (?:code|commands?))"
+     r"|(?:输出|回答)(?:会|将)[^\n]{0,12}(?:被)?(?:直接)?(?:执行|当作命令|作为代码)",
+     "数据外发", "输出即执行指示（作答将被当命令跑——OH1 输出注入）"),
+    (r"(?:keyword|trigger|关键词|触发)[^\n]{0,50}"
+     r"(?:any|every|all|任何|所有|一切)|"
+     r"(?:any|every|all|任何|所有|一切)[^\n]{0,30}"
+     r"(?:keyword|trigger|关键词|触发)",
+     "可疑意图", "过宽触发条件（任何输入都激活——TR1 触发滥用）"),
     (r"exfiltrat|渗透|后门|backdoor|keylog", "可疑意图", "包含可疑渗透/后门词汇"),
 ]
 

package/app/core/skills.py

@@ -23,6 +23,7 @@ import json
 import re
 import threading
 import time
+from datetime import datetime
 from pathlib import Path
 
 from . import paths, revisions
@@ -338,6 +339,52 @@ def _karma(item):
     return (hits - lost + _KARMA_PRIOR) / (hits + 2 * _KARMA_PRIOR)
 
 
+_DECAY_GRACE_DAYS = 30   # 宽限期：30 天内不衰减（新条目与常用条目都不受影响）
+_DECAY_RAMP_DAYS = 60    # 宽限期后线性爬满（再 60 天衰减到底）
+
+
+def _surplus_decay(item, now=None):
+    """衰减后的「信任盈余」(ds, lost)：won==0 且闲置超宽限期的条目，盈余
+    (hits−lost)⁺ 随时长线性衰减到 0——过去的注入证据会过期（hippo-memory 借鉴，
+    066 班深挖）；lost 是失守证据，粘滞不衰减。won≥1 有结局归因背书不衰减；
+    无时间戳的条目不衰减（无从判旧不臆测）。updated_at 随每次 upsert 刷新，
+    被再次触及即重置。只压排序，不删除、不改数据。"""
+    hits = max(0, int(item.get("hits") or 0))
+    lost = min(max(0, int(item.get("lost") or 0)), hits)
+    if int(item.get("won") or 0) > 0:
+        return hits - lost, lost
+    stamp = item.get("updated_at") or item.get("created_at")
+    if not stamp:
+        return hits - lost, lost
+    try:
+        then = datetime.strptime(str(stamp)[:19], "%Y-%m-%d %H:%M:%S")
+    except ValueError:
+        return hits - lost, lost
+    now = now or datetime.now()
+    idle = (now - then).days
+    if idle <= _DECAY_GRACE_DAYS:
+        return hits - lost, lost
+    ramp = min(1.0, (idle - _DECAY_GRACE_DAYS) / float(_DECAY_RAMP_DAYS))
+    return int(round((hits - lost) * (1.0 - ramp))), lost
+
+
+def _eff_karma(item, now=None):
+    """有效可信度：以衰减后盈余重算 karma。ramp=0 时与 _karma 完全等价
+    （(hits−lost+1)/(hits+2) 恒等变形），满衰减时未归因条目回中性 0.5——
+    与新鲜条目同位，先后交给「新者优先」尾键；失守者因 lost 粘滞继续下沉。"""
+    ds, lost = _surplus_decay(item, now=now)
+    return (ds + _KARMA_PRIOR) / (ds + lost + 2 * _KARMA_PRIOR)
+
+
+def _ts(item):
+    """created_at → epoch 秒（排序用，可取负实现新者优先）；缺失/坏值记 0。"""
+    stamp = str(item.get("created_at") or "")[:19]
+    try:
+        return datetime.strptime(stamp, "%Y-%m-%d %H:%M:%S").timestamp()
+    except ValueError:
+        return 0.0
+
+
 def list_lessons(scope=None, only_enabled=False, category=None):
     with _LOCK:
         items = list((_load().get("lessons") or []))
@@ -349,11 +396,13 @@ def list_lessons(scope=None, only_enabled=False, category=None):
     if only_enabled:
         items = [x for x in items if x.get("enabled", True)]
     # karma 感知排序（UI 列表用；注入排序在 relevance_top 不走这里）：
-    # 首键是可信度下界（注入多且很少失守的居首），被点名归因过成功的（won）作次键
-    # 提权，再按注入热度；失守多的自然沉底（不隐藏——降权不删除）。
-    items.sort(key=lambda x: (-_karma(x), -int(x.get("won") or 0),
-                              -int(x.get("hits") or 0), -int(x.get("seen") or 1),
-                              x.get("created_at") or ""))
+    # 首键是有效可信度（未归因条目的信任盈余随闲置衰减——证据会过期；won 背书与
+    # 失守证据都粘滞），被点名归因过成功的（won）作次键提权，再按衰减后盈余；
+    # 失守多的自然沉底（不隐藏——降权不删除）。衰减到中性的同分者按新者优先
+    # （-_ts 尾键）——「先试新的」是衰减语义的一部分。
+    items.sort(key=lambda x: (-_eff_karma(x), -int(x.get("won") or 0),
+                              -_surplus_decay(x)[0], -int(x.get("seen") or 1),
+                              -_ts(x), x.get("id") or ""))
     return items
 
 
@@ -495,12 +544,13 @@ def relevance_top(lessons, task, limit):
         return lessons[:limit]
 
     # 使用反馈闭环（pmb「量化记忆真实帮助」+ tradememory「按结局加权召回」）：
-    # 相关性优先；同分比可信度下界，再比归因成功的次数，最后比注入热度。
+    # 相关性优先；同分比有效可信度（未归因盈余随闲置衰减），再比归因成功的次数，
+    # 最后比衰减后盈余；同到中性的按新者优先。
     def rank(x):
         grams = _text_bigrams(x.get("title")) | _text_bigrams(x.get("content"))
         overlap = -len(probe & grams)
-        return (overlap, -_karma(x), -int(x.get("won") or 0),
-                -int(x.get("hits") or 0), x.get("id") or "")
+        return (overlap, -_eff_karma(x), -int(x.get("won") or 0),
+                -_surplus_decay(x)[0], -_ts(x), x.get("id") or "")
 
     return sorted(lessons, key=rank)[:limit]
 

package/app/core/store.py

@@ -502,6 +502,57 @@ def list_tasks(limit=None, archived=None):
         return out
 
 
+def serial_chain_ids(task_id):
+    """连载链条全部任务 id，根任务在前（一本书一条链：开书资料/发布绑定沿链共享）。
+
+    含祖先（沿 serial.continues 上溯）与后代（全量扫 continues 指向链条成员）；
+    非连载/未知任务回退 [task_id]。环与超深链安全（上限 50）。"""
+    task_id = str(task_id or "")
+    if not task_id:
+        return []
+    with LOCK:
+        by_id = {str(t.get("id")): t for t in _TASKS.values()}
+    if task_id not in by_id:
+        return [task_id]
+    order, seen = [], set()
+    cur = task_id
+    while cur and cur in by_id and cur not in seen and len(seen) < 50:
+        seen.add(cur)
+        order.append(cur)
+        cur = str(((by_id[cur].get("serial") or {}).get("continues")) or "") or ""
+    order.reverse()                      # 根在前
+    in_chain, grew = set(order), True
+    while grew:                          # 后代收进链条，迭代到收敛
+        grew = False
+        for tid, t in by_id.items():
+            if tid in in_chain:
+                continue
+            parent = str(((t.get("serial") or {}).get("continues")) or "")
+            if parent and parent in in_chain:
+                order.append(tid)
+                in_chain.add(tid)
+                grew = True
+    return order
+
+
+def inherited_book_meta(task, platform):
+    """任务在某平台的作品信息：连载链上「生成完成」的条目整链共用（都是用第一个）。
+
+    根在前找第一个 status=done 且有 data 的条目；整链都没有则返回任务自己的
+    条目（可能为空——调用方按未生成口径处理）。"""
+    task = task or {}
+    platform = str(platform)
+    own = ((task.get("book_meta") or {}).get(platform)) or {}
+    for tid in serial_chain_ids(task.get("id") or ""):
+        t = task if tid == str(task.get("id")) else get_task(tid)
+        if not t:
+            continue
+        e = ((t.get("book_meta") or {}).get(platform)) or {}
+        if e.get("status") == "done" and e.get("data"):
+            return e
+    return own
+
+
 def migrate_task_workdirs(old_root, new_root):
     """把「旧默认保存路径」下的任务目录搬到新默认路径下，并更新任务记录。