codebee 0.1.71 → 0.1.73

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/step_runner.py

@@ -1,133 +1,133 @@
-# -*- coding: utf-8 -*-
-"""Step 执行器：压缩触发的重试守门（复用已渲染 prompt，不重复组装）。
-
-设计稿：docs/migration/02-context-compaction.md §1D。
-参考 dsh packages/core/agent-loop/src/agent.ts:307-378：
-  失败重试只在「前进 surface generation」时返回 {kind:'retry'}，
-  复用已渲染 PromptAssembly，不重跑 pre-step / 组装 / 用户消息准入。
-
-Tutti 语境：runner.run_agent 自带 prompt（已渲染）；重试的风险不是重复渲染
-（prompt 是同一个字符串），而是「不压缩直接重试」必然再次撑爆。
-本模块的守门：仅当 maybe_compact 真正前进了 surface generation 才重试一次。
-"""
-from __future__ import annotations
-
-import logging
-
-from .compaction import maybe_compact, DEFAULT_PRESSURE_THRESHOLD
-from .error_codes import ErrorCode
-
-log = logging.getLogger(__name__)
-
-# 触发「压缩后重试」的错误码
-_OVERFLOW_CODES = {ErrorCode.CONTEXT_OVERFLOW, ErrorCode.MAX_TOKENS}
-
-# 事前预检阈值：最近一次调用的上下文锚点已占本步模型容量九成 → 第一个请求
-# 大概率被供应商拒。只拦「大概率必死」，不提前压缩平时的高压（used() 是累计
-# 口径，比真实上下文偏大；0.8 的响应式阈值语义与此不同，勿混用）。
-_PRECHECK_RATIO = 0.9
-
-
-def _v2_compaction_tuning():
-    """settings_v2 orchestrator.compaction 微调 → (threshold|None, retain|None)。
-
-    None = 未配置（走 maybe_compact 的模块默认）；读取/注册失败静默回落。
-    retain 允许 0（尾部不保留），与 None（未配置）语义不同，勿合并。"""
-    try:
-        from .settings_schema import get as ss_get, register_default_namespaces
-        register_default_namespaces()
-        c = (ss_get("orchestrator") or {}).get("compaction") or {}
-        th = c.get("pressure_threshold")
-        rt = c.get("retain_tail_tokens")
-        return (float(th) if th else None,
-                int(rt) if rt is not None else None)
-    except Exception:
-        return None, None
-
-
-def execute_step(session, run_agent_fn, prompt, *, model: str = "",
-                 llm_caller=None, retain_tail_tokens=None, **kwargs):
-    """执行一次 step；撑爆时压缩并守门重试一次。
-
-    事前预检（借鉴 freebuff base-chat 每步容量重估）：换将切到小窗口模型后，
-    响应式路径要等供应商报 CONTEXT_OVERFLOW 才压缩——报得不干净就直接卡死。
-    先用「最近一次调用上下文 vs 本步模型容量」判一次，超阈先压缩再发。
-
-    Args:
-        session: session_log.Session（记录 replace_generation）
-        run_agent_fn: runner.run_agent（或测试替身），签名 (prompt, **kwargs) -> dict
-        prompt: 已渲染的提示词（重试时原样复用，不重新渲染）
-        model: 本步将要使用的模型名（容量与压力估算都按它算）
-        llm_caller: 压缩摘要 LLM（None = 不压缩，永不重试）
-        **kwargs: 透传 run_agent_fn
-
-    Returns:
-        (result, retried: bool)
-    """
-    v2_th, v2_rt = _v2_compaction_tuning()
-    compact_kwargs = {}
-    if retain_tail_tokens is not None:
-        compact_kwargs["retain_tail_tokens"] = retain_tail_tokens
-    elif v2_rt is not None:
-        compact_kwargs["retain_tail_tokens"] = v2_rt
-    if v2_th is not None:
-        compact_kwargs["threshold"] = v2_th
-    if llm_caller is not None and model:
-        try:
-            from .token_meter import token_meter
-            ctx = token_meter.last_context(session.run_id)
-            cap = token_meter.capacity(model)
-            if ctx > 0 and cap > 0 and ctx > cap * _PRECHECK_RATIO:
-                gen_p0 = session.replace_generation()
-                if maybe_compact(session, model=model, llm_caller=llm_caller,
-                                 run_id=session.run_id, **compact_kwargs) \
-                        and session.replace_generation() > gen_p0:
-                    log.info("precheck: last ctx~%d > %.0f%% of cap(%s)=%d, "
-                             "compacted before step", ctx, _PRECHECK_RATIO * 100,
-                             model, cap)
-        except Exception:
-            log.debug("precheck skipped", exc_info=True)
-    gen0 = session.replace_generation()
-    result = run_agent_fn(prompt, **kwargs)
-    code = result.get("error_code") or ""
-    if code not in _OVERFLOW_CODES or llm_caller is None:
-        return result, False
-    # 撑爆 → 尝试压缩
-    compacted = maybe_compact(session, model=model, llm_caller=llm_caller,
-                              run_id=session.run_id, **compact_kwargs)
-    gen1 = session.replace_generation()
-    if not compacted or gen1 <= gen0:
-        # 压缩未发生或未前进 generation：重试必然再次撑爆，不重试
-        log.info("overflow but no compaction progress (gen %s->%s), no retry",
-                 gen0, gen1)
-        return result, False
-    # 压缩生效：surface 已折叠。**真正替换 CLI 请求上下文**（2026-09-21
-    # 清最老待深挖项：此前重试仍发原 prompt + 续旧 resume 会话——摘要只进
-    # 审计日志，CLI 看到的上下文一点没小，重试必然再爆）：
-    # ①重试 prompt 改用 session 派生转录（折叠摘要 + 近尾消息，体量骤降）；
-    # ②弃 resume（旧会话本体仍是膨胀态，续上就前功尽弃）。
-    msgs = []
-    try:
-        msgs = session.derive_messages()
-    except Exception:
-        log.debug("derive_messages failed on retry", exc_info=True)
-    kwargs2 = dict(kwargs)
-    if msgs:
-        transcript = "\n\n".join("[%s] %s" % (m.get("role"), m.get("content"))
-                                 for m in msgs)
-        if len(transcript) > 24_000:
-            transcript = transcript[-24_000:]
-        retry_prompt = transcript
-        # 本步指令必须在场：被折叠/截断掉就显式补在尾部（缺失指令比重复严重）
-        tail = transcript[-2000:]
-        if prompt[:400] not in tail:
-            retry_prompt = transcript + "\n\n" + prompt
-        kwargs2.pop("resume", None)
-        log.info("compaction advanced gen %s->%s, retrying with derived "
-                 "context (%d msgs, resume dropped)", gen0, gen1, len(msgs))
-        result2 = run_agent_fn(retry_prompt, **kwargs2)
-    else:
-        log.info("compaction advanced gen %s->%s but no surface derived, "
-                 "retrying same prompt", gen0, gen1)
-        result2 = run_agent_fn(prompt, **kwargs)
+# -*- coding: utf-8 -*-
+"""Step 执行器：压缩触发的重试守门（复用已渲染 prompt，不重复组装）。
+
+设计稿：docs/migration/02-context-compaction.md §1D。
+参考 dsh packages/core/agent-loop/src/agent.ts:307-378：
+  失败重试只在「前进 surface generation」时返回 {kind:'retry'}，
+  复用已渲染 PromptAssembly，不重跑 pre-step / 组装 / 用户消息准入。
+
+Tutti 语境：runner.run_agent 自带 prompt（已渲染）；重试的风险不是重复渲染
+（prompt 是同一个字符串），而是「不压缩直接重试」必然再次撑爆。
+本模块的守门：仅当 maybe_compact 真正前进了 surface generation 才重试一次。
+"""
+from __future__ import annotations
+
+import logging
+
+from .compaction import maybe_compact, DEFAULT_PRESSURE_THRESHOLD
+from .error_codes import ErrorCode
+
+log = logging.getLogger(__name__)
+
+# 触发「压缩后重试」的错误码
+_OVERFLOW_CODES = {ErrorCode.CONTEXT_OVERFLOW, ErrorCode.MAX_TOKENS}
+
+# 事前预检阈值：最近一次调用的上下文锚点已占本步模型容量九成 → 第一个请求
+# 大概率被供应商拒。只拦「大概率必死」，不提前压缩平时的高压（used() 是累计
+# 口径，比真实上下文偏大；0.8 的响应式阈值语义与此不同，勿混用）。
+_PRECHECK_RATIO = 0.9
+
+
+def _v2_compaction_tuning():
+    """settings_v2 orchestrator.compaction 微调 → (threshold|None, retain|None)。
+
+    None = 未配置（走 maybe_compact 的模块默认）；读取/注册失败静默回落。
+    retain 允许 0（尾部不保留），与 None（未配置）语义不同，勿合并。"""
+    try:
+        from .settings_schema import get as ss_get, register_default_namespaces
+        register_default_namespaces()
+        c = (ss_get("orchestrator") or {}).get("compaction") or {}
+        th = c.get("pressure_threshold")
+        rt = c.get("retain_tail_tokens")
+        return (float(th) if th else None,
+                int(rt) if rt is not None else None)
+    except Exception:
+        return None, None
+
+
+def execute_step(session, run_agent_fn, prompt, *, model: str = "",
+                 llm_caller=None, retain_tail_tokens=None, **kwargs):
+    """执行一次 step；撑爆时压缩并守门重试一次。
+
+    事前预检（借鉴 freebuff base-chat 每步容量重估）：换将切到小窗口模型后，
+    响应式路径要等供应商报 CONTEXT_OVERFLOW 才压缩——报得不干净就直接卡死。
+    先用「最近一次调用上下文 vs 本步模型容量」判一次，超阈先压缩再发。
+
+    Args:
+        session: session_log.Session（记录 replace_generation）
+        run_agent_fn: runner.run_agent（或测试替身），签名 (prompt, **kwargs) -> dict
+        prompt: 已渲染的提示词（重试时原样复用，不重新渲染）
+        model: 本步将要使用的模型名（容量与压力估算都按它算）
+        llm_caller: 压缩摘要 LLM（None = 不压缩，永不重试）
+        **kwargs: 透传 run_agent_fn
+
+    Returns:
+        (result, retried: bool)
+    """
+    v2_th, v2_rt = _v2_compaction_tuning()
+    compact_kwargs = {}
+    if retain_tail_tokens is not None:
+        compact_kwargs["retain_tail_tokens"] = retain_tail_tokens
+    elif v2_rt is not None:
+        compact_kwargs["retain_tail_tokens"] = v2_rt
+    if v2_th is not None:
+        compact_kwargs["threshold"] = v2_th
+    if llm_caller is not None and model:
+        try:
+            from .token_meter import token_meter
+            ctx = token_meter.last_context(session.run_id)
+            cap = token_meter.capacity(model)
+            if ctx > 0 and cap > 0 and ctx > cap * _PRECHECK_RATIO:
+                gen_p0 = session.replace_generation()
+                if maybe_compact(session, model=model, llm_caller=llm_caller,
+                                 run_id=session.run_id, **compact_kwargs) \
+                        and session.replace_generation() > gen_p0:
+                    log.info("precheck: last ctx~%d > %.0f%% of cap(%s)=%d, "
+                             "compacted before step", ctx, _PRECHECK_RATIO * 100,
+                             model, cap)
+        except Exception:
+            log.debug("precheck skipped", exc_info=True)
+    gen0 = session.replace_generation()
+    result = run_agent_fn(prompt, **kwargs)
+    code = result.get("error_code") or ""
+    if code not in _OVERFLOW_CODES or llm_caller is None:
+        return result, False
+    # 撑爆 → 尝试压缩
+    compacted = maybe_compact(session, model=model, llm_caller=llm_caller,
+                              run_id=session.run_id, **compact_kwargs)
+    gen1 = session.replace_generation()
+    if not compacted or gen1 <= gen0:
+        # 压缩未发生或未前进 generation：重试必然再次撑爆，不重试
+        log.info("overflow but no compaction progress (gen %s->%s), no retry",
+                 gen0, gen1)
+        return result, False
+    # 压缩生效：surface 已折叠。**真正替换 CLI 请求上下文**（2026-09-21
+    # 清最老待深挖项：此前重试仍发原 prompt + 续旧 resume 会话——摘要只进
+    # 审计日志，CLI 看到的上下文一点没小，重试必然再爆）：
+    # ①重试 prompt 改用 session 派生转录（折叠摘要 + 近尾消息，体量骤降）；
+    # ②弃 resume（旧会话本体仍是膨胀态，续上就前功尽弃）。
+    msgs = []
+    try:
+        msgs = session.derive_messages()
+    except Exception:
+        log.debug("derive_messages failed on retry", exc_info=True)
+    kwargs2 = dict(kwargs)
+    if msgs:
+        transcript = "\n\n".join("[%s] %s" % (m.get("role"), m.get("content"))
+                                 for m in msgs)
+        if len(transcript) > 24_000:
+            transcript = transcript[-24_000:]
+        retry_prompt = transcript
+        # 本步指令必须在场：被折叠/截断掉就显式补在尾部（缺失指令比重复严重）
+        tail = transcript[-2000:]
+        if prompt[:400] not in tail:
+            retry_prompt = transcript + "\n\n" + prompt
+        kwargs2.pop("resume", None)
+        log.info("compaction advanced gen %s->%s, retrying with derived "
+                 "context (%d msgs, resume dropped)", gen0, gen1, len(msgs))
+        result2 = run_agent_fn(retry_prompt, **kwargs2)
+    else:
+        log.info("compaction advanced gen %s->%s but no surface derived, "
+                 "retrying same prompt", gen0, gen1)
+        result2 = run_agent_fn(prompt, **kwargs)
     return result2, True

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):
     """把「旧默认保存路径」下的任务目录搬到新默认路径下，并更新任务记录。