@furongjun1999/dsh-memory 0.7.1 → 0.7.3

package/md_cg/freshness.py

@@ -179,22 +179,31 @@ def resolve_gamma(gamma=None) -> float:
 # 核（一律经 time_core；本模块不写指数核）
 # --------------------------------------------------------------------------
 
-# 生效条件：gamma 与 dt_days（单位=天）任意可转 float 时，返回 time_core.cred_factor(gamma, dt_days, floor, ceil)；dt 非有限值（inf/nan）时同样交给 cred_factor（inf → 取 floor）；
+# 生效条件：gamma 与 dt_days（单位=天）任意可转 float 时，返回 time_core.cred_factor(gamma, dt_days, floor, ceil)；dt 非有限值（inf/nan）时同样交给 cred_factor（inf → 取 floor）；enabled 为 None（缺省）时自算（模块级 enabled()），显式传 bool 时按传入值——两者皆假值即恒返回 1.0；
 def decay_factor(gamma: float, dt_days: float, floor: float = SCORE_FLOOR,
-                 ceil: float = SCORE_CEIL) -> float:
+                 ceil: float = SCORE_CEIL, enabled=None) -> float:
     """时间衰减乘子 `e^(-γ·Δt)`（**核来自唯一权威** `time_core.cred_factor`）。
 
     ⚠ `dt_days` 的单位**必须**是「天」（`DT_UNIT`）；调用方负责换算，
     换算单点是 `entry_weight`（`(now - created_at) / SECONDS_PER_DAY`）。
+
+    `enabled`（N274）：None=自算（默认，行为与改动前逐位一致）；显式传
+    bool 时不再自算——供 `entry_weight`/`_score` 把开关**循环外解析一次**
+    后透传，消掉逐节点 env 读取。自算分支写 `globals()["enabled"]()` 而非
+    直接 `enabled()`：形参同名会遮蔽模块函数，而 `globals()` 的解析语义与
+    改前那句 `enabled()` 逐位一致（含测试对模块函数的打桩/替换面）。
     """
-    if not enabled():
+    if enabled is None:
+        enabled = globals()["enabled"]()
+    if not enabled:
         return 1.0
     return _tc.cred_factor(float(gamma), float(dt_days), float(floor),
                            float(ceil))
 
 
-# 生效条件：access_count 与 last_access 任意（不可转数值按 0 处理）、importance 任意可转 float；按 REFRESH_PARAMS 的三档判定返回 1.0+gain / 1.0−gain / 1.0；
-def refresh_factor(access_count=0, last_access=0, importance=0.0) -> float:
+# 生效条件：access_count 与 last_access 任意（不可转数值按 0 处理）、importance 任意可转 float；enabled 为 None（缺省）时自算（模块级 enabled()），显式传 bool 时按传入值——两者皆假值即恒返回 1.0；否则按 REFRESH_PARAMS 的三档判定返回 1.0+gain / 1.0−gain / 1.0；
+def refresh_factor(access_count=0, last_access=0, importance=0.0,
+                   enabled=None) -> float:
     """访问刷新/降权乘子（**门槛与步长照抄 AEIS** `consolidate_cycle`）。
 
     判定序（与 AEIS 同序同门）：
@@ -209,8 +218,13 @@ def refresh_factor(access_count=0, last_access=0, importance=0.0) -> float:
     在**从未被访问**（`access_count == 0`）时也为真——照抄原样会让「刚写、
     从未调用的高重要度节点」白拿一次刷新。加此闸后「未被调用」只能不刷新，
     不会反被奖励（语义仍与 §7.1「被经常调用的记忆其权重被刷新」一致）。
+
+    `enabled`（N274）：None=自算（默认，行为与改动前逐位一致）；显式传
+    bool 时不再自算——与 `decay_factor` 同一透传口径（见其 docstring）。
     """
-    if not enabled():
+    if enabled is None:
+        enabled = globals()["enabled"]()
+    if not enabled:
         return 1.0
     p = REFRESH_PARAMS
     try:
@@ -251,8 +265,8 @@ def protected_floor(entry) -> float:
     return max(SCORE_FLOOR, min(1.0, IMPORTANCE_PROTECT / imp))
 
 
-# 生效条件：entry 为可取 created_at / access_count / last_access / importance / protected 的映射；fm 为真值时上述五个键优先取自 fm（缺键回落 entry）；now 为假值（None）时取 freshness_now()；无条件返回 (乘子, 依据 dict)——乘子 = decay_factor(gamma, |now-created_at|/86400, protected_floor(取数后的映射), SCORE_CEIL) × refresh_factor(...)；created_at 缺失/不可转数值/≤0 时 dt_days 取 inf（判「距参照无穷远」，由 floor 兜住）；
-def entry_weight(entry, now=None, gamma=None, fm=None) -> tuple:
+# 生效条件：entry 为可取 created_at / access_count / last_access / importance / protected 的映射；fm 为真值时上述五个键优先取自 fm（缺键回落 entry）；now 为假值（None）时取 freshness_now()；enabled 为 None（缺省）时自算（模块级 enabled()），显式传 bool 时按传入值——两者皆假值即早退返回 (1.0, {"disabled": True})（早退先于 now/γ 解析，与改前同序）；否则无条件返回 (乘子, 依据 dict)——乘子 = decay_factor(gamma, |now-created_at|/86400, protected_floor(取数后的映射), SCORE_CEIL, enabled=…) × refresh_factor(..., enabled=…)；created_at 缺失/不可转数值/≤0 时 dt_days 取 inf（判「距参照无穷远」，由 floor 兜住）；
+def entry_weight(entry, now=None, gamma=None, fm=None, enabled=None) -> tuple:
     """索引条目 → 分数乘子 `(乘子, 依据)`（**检索期唯一取数点**，免读文件）。
 
     `entry` 直接来自索引快照（`_node_entry` 已落 `created_at` /
@@ -260,6 +274,11 @@ def entry_weight(entry, now=None, gamma=None, fm=None) -> tuple:
 
     `fm` 为可选覆盖源（写面刚落的 frontmatter 可能比索引条目新）：只为
     避免在热路径上拷贝 dict 而设，取数优先级 `fm > entry > 缺省`。
+
+    `enabled`（N274）：None=自算（默认，行为与改动前逐位一致）；显式传
+    bool 时不再自算，且向下透传给 `decay_factor`/`refresh_factor`——它们
+    同样不再各自读 env。自算分支经 `globals()["enabled"]()`（形参遮蔽，
+    解析语义同改前的 `enabled()`，见 `decay_factor` 同注）。
     """
     e = entry or {}
     keys = ("created_at", "access_count", "last_access", "importance",
@@ -269,7 +288,9 @@ def entry_weight(entry, now=None, gamma=None, fm=None) -> tuple:
                for k in keys}
     else:
         src = {k: e.get(k) for k in keys}
-    if not enabled():
+    if enabled is None:
+        enabled = globals()["enabled"]()
+    if not enabled:
         return 1.0, {"disabled": True}
     g = resolve_gamma(gamma)
     ref = freshness_now() if now is None else float(now)
@@ -286,9 +307,9 @@ def entry_weight(entry, now=None, gamma=None, fm=None) -> tuple:
         # 微变）且两侧跨语言同值。详见 DT_QUANTUM_DAYS 的说明。
         dt_days = float(int(dt_days / DT_QUANTUM_DAYS)) * DT_QUANTUM_DAYS
     floor = protected_floor(src)
-    d = decay_factor(g, dt_days, floor, SCORE_CEIL)
+    d = decay_factor(g, dt_days, floor, SCORE_CEIL, enabled=enabled)
     r = refresh_factor(src.get("access_count"), src.get("last_access"),
-                       src.get("importance"))
+                       src.get("importance"), enabled=enabled)
     return d * r, {"gamma": g, "dt_days": dt_days, "unit": DT_UNIT,
                    "decay": d, "refresh": r, "floor": floor,
                    "protected": bool(src.get("protected"))}

package/md_cg/ghostref.py

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+"""幽灵引用检查器（A2 落地）：短语层标记 + id 层降级告警——**只标记、不拒收**。
+
+背景（多主体世界模型对齐 v0.1 §2 L1「转引不得升级」）：CD-WHALE-01（鲸娘语料
+731 轮）发现 C 的现实形态是**自然语言回指**（「上次的香薰蜡烛」「明明讲过的那
+件事」）——被引对象在库里没有任何记录，引用悬空且无任何防线（探针读数：
+短语层零痕迹、id 层「目标晚于自身」零告警）。本模块补两条**标记级**防线：
+
+  ① 短语层：正文以回指短语（「上次的」「之前说的」「明明讲过」）指代一个
+     在句内**无可解析出处**（句内无库内 id）的对象时，产出幽灵引用短语清单
+     ——写入链把它落 `fm.uncertain_refs` 并在出口告警；**不拒收**（回指是
+     现实写作的常态，拒收会把正常记忆挡在门外；标记让「不确定」可被后续
+     裁决与检索看见）。
+  ② id 层：正文引用了一个库内目标，但本文档声明的生效起点（valid_from /
+     effective_from）**早于**目标创建时刻——「引用了当时尚不存在的目标」。
+     产出 late_refs 告警清单；同样**不改建边判定、不拒收**。
+
+判据边界（如实）：
+  · 句级判定：短语所在**句子**（[。！？；\n] 为界）内无库内 id ⇒ 幽灵；
+    跨句引用（一句短语、邻句 id）不消解标记——保守方向是「宁标勿漏」。
+  · 仅写链（MCP op=write）路径生效（与 linkref 同界）；库层直调 cg.add
+    不经检测。
+  · 短语表保守（明确的时间/人称回指词），**不含**「那条/那根」这类泛指示词
+    （误报率高，标记面宁可窄）；误报后果 = fm 多一个标记。
+  · 检测面**不查源节点 id 形态**（不同于 linkref 的 is_linkable_source
+    门槛）：标记是**内容属性**——无论节点 id 是否合规，正文里的无出处回指
+    都值得标记；建边是**图属性**，才需要形态门槛（防图污染）。两者有意
+    不同界。**late 面例外**：它消费 linkref 解析出的 targets，源 id 不合
+    形态 ⇒ 无 targets ⇒ late 静默不查（与 linkref 同界，2026-10-05 复核
+    info-④ 登记）。
+"""
+from __future__ import annotations
+
+import re
+
+__all__ = ["PHRASES", "SENTENCE_SPLIT_RE", "find_ghost_phrases", "late_targets",
+           "check"]
+
+#: 回指短语表（时间回指 + 人称回指；CD-WHALE-01 发现 C 的词形采样，
+#: 对齐评估 v0.1 §2 L1 的「上次的/之前的/明明讲过」三例）。
+PHRASES = (
+    "上次的", "上次说", "上次买", "上次那", "上次提",
+    "之前的", "之前说", "之前买", "之前那", "之前提",
+    "明明讲过", "明明说过", "明明说", "明明提",
+    "刚才说", "刚才的", "前述的", "先前说", "早先的",
+    "你说的", "我说过的", "你提过的",
+)
+
+#: 句界（句级判定的切分面）。保留句子文本、丢弃界符。
+SENTENCE_SPLIT_RE = re.compile(r"[。！？；\n]+")
+
+
+def find_ghost_phrases(text, known=None) -> list:
+    """短语层检测：返回**无可解析出处**的回指短语列表（去重保序）。
+
+    known —— 库内节点 id 集合（白名单）。句内含形态合法**且在册**的 id 即
+    视为「有出处」（该句非幽灵）；传 None 时降级为只判形态（保守少报）。
+    """
+    if not text:
+        return []
+    from . import linkref
+    out = []
+    seen = set()
+    for sent in SENTENCE_SPLIT_RE.split(str(text)):
+        hits = [p for p in PHRASES if p in sent]
+        if not hits:
+            continue
+        # 句内子串去重（最长优先）：「明明说过」同时命中「明明说过」与
+        # 「明明说」——同一现象的一个更长粒度标记即可（复核 info-2：
+        # 冗余双标记挤占 cap 16）。跨句不去重（不同句各自独立）。
+        hits = [p for p in hits
+                if not any(p != q and p in q for q in hits)]
+        # 句内是否有可解析出处：id 形态命中 + （调用方给了 known 时）在册。
+        refs = linkref.extract_refs(sent, known=known)
+        if refs:
+            continue
+        for p in hits:
+            if p not in seen:
+                seen.add(p)
+                out.append(p)
+    return out
+
+
+def late_targets(cg, targets, own_from) -> list:
+    """id 层检测：目标创建时刻晚于本文档声明的生效起点 ⇒「目标晚于自身」。
+
+    targets  —— linkref 解析出的引用目标 id 列表（ctx["linkref_targets"]）。
+    own_from —— 本文档声明的生效起点（valid_from / effective_from）；缺省
+                None 表示未声明时间轴，此时不做检查（写入 created_at=now，
+                「目标晚于自身」结构上不可能）。
+
+    返回 [{target, target_created, own_from}]（cap 10，保序）。
+    """
+    if own_from is None or not targets:
+        return []
+    try:
+        own = float(own_from)
+    except (TypeError, ValueError):
+        return []
+    nodes = (getattr(cg, "index", None) or {}).get("nodes") or {}
+    out = []
+    for tid in targets:
+        tid = str(tid)
+        e = nodes.get(tid) or {}
+        tc = e.get("created_at")
+        if tc is None:
+            rec = cg.get(tid) or {}
+            tc = ((rec.get("frontmatter")) or {}).get("created_at")
+        try:
+            tc = float(tc)
+        except (TypeError, ValueError):
+            continue
+        if tc > own:
+            out.append({"target": tid, "target_created": tc, "own_from": own})
+            if len(out) >= 10:
+                break
+    return out
+
+
+# 生效条件：总是返回 {"ghost_phrases": [...], "late_refs": [...]} 两键 dict（各可为空列表）；
+# 内部对 text 做短语层检测（known 取 cg 索引键集合），对 ctx 已解析的 linkref 目标做 id 层检测；
+# 不做任何落盘/短路（纯读）。
+def check(cg, text, linkref_targets=None, own_from=None) -> dict:
+    """组合检测（纯读，无副作用）：供写入链闸调用。"""
+    nodes = (getattr(cg, "index", None) or {}).get("nodes") or {}
+    known = set(nodes.keys())
+    return {
+        "ghost_phrases": find_ghost_phrases(text, known=known),
+        "late_refs": late_targets(cg, linkref_targets or [], own_from),
+    }

package/md_cg/judgment_manifest.py

@@ -33,6 +33,7 @@ hive serve 心跳）用的是 `scripts/judgment_manifest.py`，两侧 PATTERNS
   md_cg/test_*.py         Python 侧测试套件
   compiler/tests/*.py     compiler 测试
   swarm/tests/*.py        swarm 测试
+  test/{hive_exec,hive_wm}_test.py   test/ 侧逐文件裁决可收件（A6；精确名冻结）
 
 安装态（出货包）只有 `md_cg/test_*.py` 一组可得——其余组命中数为 0，
 `missing_patterns` 显式随清单与冻结凭证落盘（不静默少算）；A3 两侧必须在
@@ -55,6 +56,12 @@ PATTERNS = [
     ("md_cg", "test_*.py"),
     ("compiler/tests", "*.py"),
     ("swarm/tests", "*.py"),
+    # test/（A6，2026-10-05）：与 scripts/ 版逐字同步——test/ 侧逐文件裁决可收件的
+    # 精确名冻结（未过裁决的件不进判据面）。批次99 补收：chaos 套件的陈旧登记已
+    # 同步（FI-M04 读码代理断言改 AST 语义判据 + 去锁定点变异自证）。
+    ("test", "hive_exec_test.py"),
+    ("test", "hive_wm_test.py"),
+    ("test/chaos_injection", "run_all.py"),
 ]
 
 

package/md_cg/mcp_server.py

@@ -59,6 +59,26 @@ from utf8_boot import ensure_utf8  # noqa: E402
 ensure_utf8(__file__)
 
 
+# ------------------------------------------- 入口自保证 OpenBLAS 线程数（2026-10-05）
+# 根因（返修取证）：numpy（md_cg 可选依赖，经 whitebox_kb 系列模块加载）在**导入期**
+# 由 OpenBLAS 按线程数（默认 = 核数）申请每线程缓冲——本机 32 核实测单进程
+# `import numpy` 的**全机提交内存**增量 0.73 GiB。启动链上的代校验
+# （verify_delegations → 导入含 numpy 的目标模块，见 main）把这笔分配带到
+# **服务应答之前**：机器提交内存吃紧、或**多进程同启**（并行测试套件 / 多会话
+# 并存 / 常驻扫描）时，OpenBLAS 重试 10 次后放弃并 exit(1)——进程在 initialize
+# 应答前死亡，桥侧只见「握手失败 / 插件激活失败」，子进程 stderr 里的
+# `OpenBLAS error: Memory allocation still failed after 10 retries` 是唯一线索。
+# 实测（本机，2026-10-05；随提交内存压力波动）：12 个并发 `import numpy` 默认
+# 4~9/12 失败（两轮独立读数，stderr 同上），置本值后 0/12（两轮）；单进程提交
+# 增量 0.73 → 0.013 GiB（4 线程 0.100 GiB）。md_cg 现有数值面是向量点积/范数/
+# 小矩阵，单线程对其**无已观测的性能意义**（⚠ 未做基准实测，出现 BLAS 密集路径
+# 须在性能轮复测）。显式设值优先，只填空缺/空白（仓库口径：空白视为未设置）。
+# 位置钉死：必须在 numpy 可被导入之前——模块级，早于 main() 的代校验；
+# 且晚于 ensure_utf8（其重启形态经 env 继承本值，两条保证互不干扰）。
+if not (os.environ.get("OPENBLAS_NUM_THREADS") or "").strip():
+    os.environ["OPENBLAS_NUM_THREADS"] = "1"
+
+
 # SERVER_VERSION 从包根 package.json 动态读取（issue #42：硬编码 0.1.0 与发布
 # 版本脱节，握手自报假版本）；读不到（文件缺失/损坏/裁剪）回落保底值不阻塞启动。
 # v21-R1（2026-09-28）：**回落必须覆盖全形态**——修前只捉 (OSError, ValueError)
@@ -593,6 +613,8 @@ KERNEL_TOOLS = [
                        "建议能力名（不执行，由调用方决定）；op=read：召回/检索/按 id 取"
                        "（长内容自动截断 2000 行 / 50KB，返回 truncated+next_offset，"
                        "续读传 offset=next_offset，不静默丢内容）；"
+                       "op=audit：证据审计视图（只读组装，需 node_id；返回"
+                       "现值/出处链/两存备择/盲区/退役史五面；路线 C）；"
                        "op=write：写入前按 content_kind 审核（ACCEPT 落盘 / REJECT 进负记忆 / "
                        "DEFER 进审核队列）+ 节点间冲突检测（三级决策：情绪→反思→递归反思；"
                        "consistency=false 可关，on_conflict=reject|defer|record）；"
@@ -712,7 +734,7 @@ KERNEL_TOOLS = [
                             "scrub|predict|causal|"
                             "forget|goal|task|recent|info|index_code|index_doc|ref|whitebox|"
                             "theory|link|session|ingest|export|maintain|consolidate|"
-                            "insight|ccg|status|edges|help", True),
+                            "insight|ccg|status|edges|audit|help", True),
             ccg=_p("object", "CCG 六要素编译器入参：{action, node_id, dialog, marks, "
                              "slots, strict_spans, role, verdict, verifier, compiled_by, "
                              "evidence, slot_corrections, model, jobs, blocking, wait_s, "
@@ -782,6 +804,13 @@ KERNEL_TOOLS = [
             depth=_p("integer", "consistency：递归反思深度上限"),
             condition_space=_p("object", "条件空间"),
             verification_basis=_p("string", "验证基底"),
+            # A1 补接（2026-10-05，路线 C 动工时经 audit 现值面发现写链漏传后
+            # 一并补齐的三处接线之一）：检验强度（与验证基底正交的裁决力分级）。
+            check_strength=_p("string", "检验强度：hoop|smoking_gun|doubly_decisive"
+                                       "（与 verification_basis 正交的裁决力分级；"
+                                       "覆写既有节点时默认继承）"),
+            # 路线 C（2026-10-05）：audit 的截断上限。
+            cap=_p("integer", "audit：各面截断上限（1–64，缺省 8）"),
             non_applicable_conditions=_p("array", "不适用条件"),
             context=_p("object", "当前情境"),
             k=_p("integer", "返回条数（sustain pool_bench 亦用）"),
@@ -2337,6 +2366,26 @@ def _cg_dispatch(cg, a):
              "reason": q2.get("reason"), **refindex.ref_fields(n)}
             for n, s, q2 in res]}
 
+    if op == "audit":
+        # 路线 C（2026-10-05，多主体世界模型对齐 v0.1 §4）：证据审计面——
+        # 只读组装器（md_cg/auditview.py），零写路径改动。node_id 类型闸与
+        # read 面同口径（类型错 ⇒ 结构化 error，不静默降级）；截断参数用
+        # `cap`（**故意不用 view/limit 等既有名**——view 已被 roleviews 占用，
+        # 设计稿复核修订的命名约束）。
+        _nid = a.get("node_id")
+        if not isinstance(_nid, str) or not _nid.strip():
+            return {"ok": False, "error": "node_id_not_str",
+                    "node_id": _nid, "got_type": type(_nid).__name__,
+                    "hint": "audit 需字符串 node_id（证据审计视图按节点组装）；"
+                            "要按关键词检索请改用 query（read）"}
+        from . import auditview
+        _cap = a.get("cap")
+        try:
+            _cap = int(_cap) if _cap is not None else auditview.DEFAULT_CAP
+        except (TypeError, ValueError):
+            _cap = auditview.DEFAULT_CAP
+        return auditview.build(cg, _nid, cap=max(1, min(64, _cap)))
+
     if op == "write":
         # 写入路径拦截器链（Pi 钩子化移植，writepipe.py）：六道闸以扩展
         # 形态注册于 writepipe.default_pipeline()，次序/启停不再硬编码于
@@ -3341,6 +3390,9 @@ def _dispatch(cg, name, args):
                 role=a.get("role"), tags=a.get("tags"),
                 condition_space=a.get("condition_space"),
                 verification_basis=a.get("verification_basis"),
+                # A1 补接（2026-10-05）：检验强度同族透传（remember_gated 内部
+                # add(**kw) 直达；此前声明在 gated 分支静默丢弃）。
+                check_strength=a.get("check_strength"),
                 non_applicable_conditions=a.get("non_applicable_conditions"),
                 importance_hint=hint, override=bool(a.get("override")),
                 consistency=bool(a.get("consistency", True)),
@@ -3390,6 +3442,9 @@ def _dispatch(cg, name, args):
             _meta = {k: a[k] for k in
                      ("tags", "condition_space", "verification_basis",
                       "non_applicable_conditions", "derived_from", "relation",
+                      # A1 补接（2026-10-05）：检验强度入复现 meta——与
+                      # writepipe._AUTONOMY_META_KEYS 同款（两条路径元数据等价）。
+                      "check_strength",
                       "role", "importance") if a.get(k) is not None}
             # 直写面的裁决参数（本分支的 add 会自己跑冲突闸）：随单落进复现 meta，
             # 否则「确认后落盘」与「直接落盘」两条路径的判据不等价。
@@ -3416,6 +3471,8 @@ def _dispatch(cg, name, args):
                          condition_space=a.get("condition_space"),
                          importance=float(a.get("importance", 0.5)),
                          verification_basis=a.get("verification_basis"),
+                         # A1 补接（2026-10-05）：检验强度透传（同 B2）。
+                         check_strength=a.get("check_strength"),
                          non_applicable_conditions=a.get("non_applicable_conditions"),
                          override=bool(a.get("override")),
                          consistency=bool(a.get("consistency", True)),