@furongjun1999/dsh-memory 0.4.7 → 0.4.9

package/md_cg/audit.py

@@ -4,10 +4,11 @@
 架构约束：验证能力不在认知图内（跑测试/识图/验收都不是记忆基底的职责）。
 认知图只做三件事：按内容类型选验证器 → 调用 → 记账。缺能力返回 DEFER，绝不假装通过。
 
-六类内容 → 验证动作：
+内容类型 → 验证动作：
     code        代码内容 → 实测              image_desc  图像描述 → 识图确认
     text        文字内容 → 合规 + 纪律        permission  权限操作 → 是否具有权限
     work_done   工作完成 → 验收              work_wip    工作进行 → 完整成果 + 纪律
+    ccg_marks   CCG 六要素 → 编外验证方实测（生成方不得自证）
 
 裁决四态复用 judge_qualification：ACCEPT / REJECT / DEFER / BLINDSPOT
 验证器签名：fn(payload: dict, ctx: dict) -> {"state":..., "evidence":..., "detail":...}
@@ -28,16 +29,20 @@ CONTENT_KINDS = {
     "permission": "权限操作 → 是否具有权限",
     "work_done": "工作完成 → 工作项是否通过验收",
     "work_wip": "工作进行 → 是否已有完整成果 + 是否符合纪律",
+    "ccg_marks": "CCG 六要素候选 → 编外验证方实测确认（生成方不得自证）",
+    "hyperedge": "跨端验证超边 → 回放重建比对（回执逐字段一致）",
 }
 
 # content_kind → 建议的 verification_basis
 # （见 nodefile.VERIFICATION_BASIS：compiler|test|measurement|formal_proof|data|textbook|public_kb|other）
 KIND_BASIS = {"code": "test", "image_desc": "measurement", "text": "other",
-              "permission": "data", "work_done": "test", "work_wip": "other"}
+              "permission": "data", "work_done": "test", "work_wip": "other",
+              "ccg_marks": "test", "hyperedge": "test"}
 
 VERIFIERS = {}
 
 
+# 生效条件：kind 属于 CONTENT_KINDS 且（kind 不在 VERIFIERS 或 override 为真值）时把 fn 写入 VERIFIERS[kind]；kind 未知、或 kind 已在 VERIFIERS 而 override 为假值时抛 ValueError。
 def register_verifier(kind, fn, override=False):
     """注入/替换某类内容的验证器（外部能力接入点）。"""
     if kind not in CONTENT_KINDS:
@@ -47,6 +52,7 @@ def register_verifier(kind, fn, override=False):
     VERIFIERS[kind] = fn
 
 
+# 生效条件：传入 state、kind、evidence（detail 可缺省为 None）时，返回以 state/kind/evidence 为键、basis 取 KIND_BASIS.get(kind)（查不到即 None）的判定字典。
 def _verdict(state, kind, evidence, detail=None):
     return {"state": state, "kind": kind, "basis": KIND_BASIS.get(kind),
             "evidence": evidence, "detail": detail}
@@ -54,6 +60,7 @@ def _verdict(state, kind, evidence, detail=None):
 
 # ---------- 规则库（合规 / 纪律） ----------
 
+# 生效条件：path 为假值（None 或空串）时回落到 os.environ 的 MDCG_POLICY_FILE，所得路径仍为假值或 os.path.exists 判定为假时返回 {}；否则按 json.load 读取，抛 OSError/ValueError 或结果非 dict 时返回 {}，是 dict 则返回该 dict。
 def load_rulebook(path=None):
     """{"forbidden": [正则], "required": [正则]}；缺失返回空规则。"""
     path = path or os.environ.get("MDCG_POLICY_FILE")
@@ -67,6 +74,7 @@ def load_rulebook(path=None):
     return rules if isinstance(rules, dict) else {}
 
 
+# 生效条件：当 rules 的 forbidden 与 required 去空后非全空时，逐条对 text 做 re.search（非法正则跳过），无禁止命中且必需项全部命中才返回 ACCEPT，否则 REJECT；两类都为空时返回 DEFER。
 def _rule_check(text, rules):
     """规则为空 → DEFER（无规则不能假装合规）。"""
     forbidden = [r for r in (rules.get("forbidden") or []) if r]
@@ -93,12 +101,14 @@ def _rule_check(text, rules):
 
 # ---------- 内建验证器 ----------
 
+# 生效条件：以 payload['content']（为假值则回落 payload['text']，再为假值取空串）作为文本，用 ctx['rules']（为假值则回落 load_rulebook()）做规则检查，返回 _verdict(检查状态, 'text', 证据)。
 def _verify_text(payload, ctx):
     text = str(payload.get("content") or payload.get("text") or "")
     state, ev = _rule_check(text, ctx.get("rules") or load_rulebook())
     return _verdict(state, "text", ev)
 
 
+# 生效条件：ctx['principal'] 缺失或为 None 时恒 DEFER；否则按 payload['action']（为假值取空串）是否属于 admin/forget/restore/review_decide 分别取 p.can_admin 或 p.can_write，且 p 具 allows 方法而 payload['sensitivity'] 为真值时再叠加 p.allows(sensitivity)，按最终 ok 返回 ACCEPT/REJECT。
 def _verify_permission(payload, ctx):
     p = ctx.get("principal")
     if p is None:
@@ -116,6 +126,7 @@ def _verify_permission(payload, ctx):
                     f"can_admin={getattr(p, 'can_admin', None)}")
 
 
+# 生效条件：payload['content']（为假值取空串）经 ctx['rules']（为假值回落 load_rulebook()）检查后，state==REJECT 即 REJECT；否则 ctx['cg'] 非 None 且 payload['topic']（为假值回落 payload['query']，再为假值取空串）非空且 cg.search 结果含 ACCEPT 状态节点时 DEFER（查询抛异常则跳过该路）；再 state==DEFER 时 DEFER，否则 ACCEPT。
 def _verify_work_wip(payload, ctx):
     text = str(payload.get("content") or "")
     state, ev = _rule_check(text, ctx.get("rules") or load_rulebook())
@@ -137,6 +148,7 @@ def _verify_work_wip(payload, ctx):
     return _verdict(ACCEPT, "work_wip", f"纪律通过且未见重复成果（{ev}）")
 
 
+# 生效条件：payload['content']（为假值取空串）为空白即 REJECT '空内容'；ast.parse 抛 SyntaxError 即 REJECT 语法错误；payload['test_cmd'] 与 os.environ 的 MDCG_CODE_TEST_CMD 均为假值时 ACCEPT（仅静态验证）；否则 shlex.split 抛 ValueError 或 subprocess 抛 OSError/SubprocessError 即 DEFER，returncode 为 0 即 ACCEPT，非 0 即 REJECT 并附 returncode 与 stdout/stderr 尾部。
 def _verify_code(payload, ctx):
     """代码内容 → 实测：AST 可解析为最低门槛；给了 test_cmd 则真跑测试。
 
@@ -181,14 +193,85 @@ def _verify_code(payload, ctx):
     return _verdict(REJECT, "code", f"实测失败 rc={p.returncode}：{tail}")
 
 
+# 生效条件：调用 _pending 并传入 kind 与 why 后，其返回的内层闭包 _fn 对任意 payload/ctx 均求值为 _verdict(DEFER, kind, why)，其中 kind 与 why 来自外层 _pending 的闭包，而非 _fn 的形参；。
 def _pending(kind, why):
+# 生效条件：调用 _pending 并传入 kind 与 why 后，其返回的内层闭包 _fn 对任意 payload/ctx 均求值为 _verdict(DEFER, kind, why)，其中 kind 与 why 来自外层 _pending 的闭包，而非 _fn 的形参；。
     def _fn(payload, ctx):
         return _verdict(DEFER, kind, why)
     return _fn
 
 
+# 生效条件：payload['node_id'] 去空后为空即 DEFER；否则取 payload['unit_verdict']（为假值回落 payload['verdict']）去空转大写，其属于 STATES 时——verifier 为空即 DEFER、ctx['compiled_by']（为假值回落 payload['compiled_by']）非空且等于 verifier 即 REJECT E041、verdict==ACCEPT 而 evidence 为空即 DEFER、其余按该 verdict 裁定；其不属于 STATES 时经 units.probe 探测（探测抛异常亦恒 DEFER）后恒 DEFER 并给出通道与下一步提示。
+def _verify_ccg_marks(payload, ctx):
+    """CCG 六要素候选的验证闸门：**只认认知图外的复核裁决**（裁定 A）。
+
+    本闸门**不在写入路径里阻塞跑 LLM**——写入是同步闸门，等待外部单元会卡住写路径。
+    正确的异步三段式：compile（ccgc）→ 外部单元复核（蜂巢 reflect/verify，或
+    harness 端子代理）→ 带 `unit_verdict` 回到本闸门 → ACCEPT 才谈得上写入
+    （`ccgc.link` 仍**独立**校验签章，本闸门不是唯一防线）。
+
+    payload 键：
+        node_id       目标节点（必填）
+        unit_verdict  外部单元裁决 ACCEPT/REJECT/DEFER/BLINDSPOT
+                      （缺 → DEFER + 给出「下一步怎么拿到裁决」的通道提示）
+        verifier      验证方标识（须 != compiled_by，E041）
+        evidence      裁决依据（ACCEPT 而无依据 → DEFER：无依据不通过）
+        model/allow_degrade/channel  可选，仅用于探测降级通道
+    ctx 键：
+        compiled_by   编译执行者（E041 比对）
+    """
+    node_id = str(payload.get("node_id") or "").strip()
+    if not node_id:
+        return _verdict(DEFER, "ccg_marks", "缺少 node_id：六要素候选须指明目标节点")
+    verdict = str(payload.get("unit_verdict") or payload.get("verdict") or "").strip().upper()
+    verifier = str(payload.get("verifier") or "").strip()
+    evidence = str(payload.get("evidence") or "").strip()
+    compiled_by = str(ctx.get("compiled_by") or payload.get("compiled_by") or "").strip()
+
+    if verdict in STATES:
+        if not verifier:
+            return _verdict(DEFER, "ccg_marks",
+                            "有裁决但缺验证方标识（verifier）——无法证明是编外复核")
+        if compiled_by and verifier == compiled_by:
+            return _verdict(REJECT, "ccg_marks",
+                            "E041 自证拒绝：验证方标识 == 编译执行者（LLM 不得自己验证自己）")
+        if verdict == ACCEPT and not evidence:
+            return _verdict(DEFER, "ccg_marks",
+                            "ACCEPT 但未给出裁决依据（evidence 为空）——无依据不通过")
+        return _verdict(verdict, "ccg_marks", evidence or "（未给依据）",
+                        detail={"node_id": node_id, "verifier": verifier,
+                                "job_id": payload.get("job_id") or ""})
+
+    # 无裁决 → 探测复核通道，按三态给出「下一步怎么拿到裁决」（不阻塞、不假装通过）
+    try:
+        from . import units
+        p = units.probe(model=payload.get("model") or "",
+                        allow_degrade=bool(payload.get("allow_degrade")),
+                        channel=payload.get("channel") or "")
+    except Exception as exc:                      # noqa: BLE001 —— 探测失败亦不假装
+        return _verdict(DEFER, "ccg_marks",
+                        "未获复核裁决，且复核通道探测失败：%s: %s"
+                        % (type(exc).__name__, exc))
+    if p["state"] == units.HIVE:
+        nxt = ("复核通道=蜂巢（model=%s）：cg(op=ccg, action=review, node_id=%s, "
+               "blocking=true) 取得裁决后带 unit_verdict/verifier 重入本闸门"
+               % (p["model"], node_id))
+    elif p["state"] == units.SUBAGENT:
+        nxt = ("已降级 harness 端子代理（channel=%s）：把 units.review 返回的 prompt 交给"
+               "子代理执行，取回 JSON 裁决后带 unit_verdict/verifier 重入本闸门"
+               % p["channel"])
+    else:
+        nxt = p["hint"]
+    return _verdict(DEFER, "ccg_marks",
+                    "六要素候选尚未经编外复核（未获 unit_verdict）——缺复核恒不通过",
+                    detail={"channel_state": p["state"], "next": nxt,
+                            "jobs_dir": p["jobs_dir"], "model": p["model"],
+                            "node_id": node_id})
+
+
 # ---------- 分派入口 ----------
 
+# 生效条件：content_kind 去空后不在 CONTENT_KINDS 即 BLINDSPOT；否则取 VERIFIERS 中该 kind 的验证器，缺失即 DEFER，调用抛异常即 DEFER，成功则以返回值 state（不在 STATES 时降级为 DEFER）连同 evidence/detail 构造裁定。
 def audit(content_kind, payload=None, ctx=None):
     """按内容类型分派验证器。未知类型 → BLINDSPOT；缺验证器 → DEFER。"""
     kind = (content_kind or "").strip()
@@ -206,6 +289,7 @@ def audit(content_kind, payload=None, ctx=None):
     return _verdict(state, kind, str(v.get("evidence") or ""), v.get("detail"))
 
 
+# 生效条件：对模块级常量 CONTENT_KINDS 中的每个 k 返回 action=CONTENT_KINDS[k]、basis=KIND_BASIS[k]、verifier 为 'builtin'（k 在 VERIFIERS 中）否则 'missing'。
 def kinds():
     """内容类型清单 + 验证器可用性（供 service_info / health 自描述）。"""
     return {k: {"action": CONTENT_KINDS[k], "basis": KIND_BASIS[k],
@@ -226,6 +310,7 @@ def kinds():
 VERIFIER_MODULES_ENV = "MDCG_VERIFIER_MODULES"
 
 
+# 生效条件：modules 为 None 时按 os.environ 的 VERIFIER_MODULES_ENV（为假值取空串）取逗号分隔模块名，去空后列表为空即返回空报告；否则逐个 import_module 并调用其可调用的 register(本模块)，单个导入或调用失败记入 failed 且 strict 为真值时立即抛出、为假值时继续，成功者记入 loaded，最后以 CONTENT_KINDS 生成 verifiers 可用性映射。
 def load_external_verifiers(modules=None, strict=False):
     """按 `MDCG_VERIFIER_MODULES`（逗号分隔 import 路径）加载外部验证器模块。
 
@@ -278,3 +363,7 @@ register_verifier("code", _verify_code)
 # 诚实说明缺什么，绝不假装通过。
 register_verifier("image_desc", _pending("image_desc", "未注入识图验证器（需视觉能力）"))
 register_verifier("work_done", _pending("work_done", "未注入验收器（需验收标准）"))
+# ccg_marks：闸门本身不是「能力」而是**准入判据**——只认编外单元的裁决
+# （unit_verdict + verifier）；无裁决时探测复核通道（蜂巢→配置→子代理）并给出
+# 下一步，恒不假装通过。真实复核由外部单元完成，认知图只负责记账。
+register_verifier("ccg_marks", _verify_ccg_marks)

package/md_cg/autonomy.py

@@ -26,13 +26,24 @@ import json
 import os
 import time
 
-from . import metacognition, predict
+from . import d_meta, metacognition, predict
 from .fsutil import append_jsonl
 
 #: 信息差评分权重：不确定度二阶差分 |d2|（加速度）×1，
 #: BLINDSPOT ×2（资格失败最重）、DEFER ×1（降级但可确认）。
 W_D2, W_BLINDSPOT, W_DEFER = 1.0, 2.0, 1.0
 
+#: D_meta 排序加分（方案 §2.4，**默认生效**）：D_meta 只进**排序键**，
+#: 不改 `score`（ΔD 定价器口径不变）、不改资格判据（score>0 才是资格）、
+#: 也不改 σ(Gain) 筛选（#37 价值链）。加分取**单一指定代理**（DMETA_PROXY），
+#: 禁三代理加权合成（智能论3.4 DEV-002a）。`MDCG_D_META=0` → compute()
+#: 返回 enabled=False → 加分退化 0（回到旧排序）。
+#: 口径诚实标注：本轮取库侧 query 无关代理 → 同轮全部提案加分同值 → **当前
+#: 口径下排序不变**；区分性待 query-relative 口径（`_neg_coverage`）在
+#: reflect 侧落盘后自然生效（不提前编造区分性）。
+W_DMETA = 0.1
+DMETA_PROXY = "unmodeled_growth"
+
 EXPLORE_LOG = "_explore.jsonl"
 
 # P-T-40 信息增益门槛（#6/#37 投影）：Value = ΔD·σ(Gain)——
@@ -44,10 +55,12 @@ GAIN_COOLDOWN = 3600.0 # 冷却秒数：过期后 σ 回 1.0（给探索机会
 _GAIN_STUCK = ("carried", "unresolved", "unknowable", "no_anchor")
 
 
+# 生效条件：cg 无 root 属性时以 '.' 作为 os.path.join 的第一参数，有 root 属性时始终使用 cg.root 的值（即使为 None，也会传入 os.path.join 导致报错），再与模块常量 EXPLORE_LOG 拼接。
 def _explore_log_path(cg):
     return os.path.join(getattr(cg, "root", "."), EXPLORE_LOG)
 
 
+# 生效条件：给定 cg 与 bid 读取探索留痕，无该 bid 的 outcomes 时返回 gain=None、sigma=1.0，最近 window（默认 GAIN_WINDOW）次终态全属 _GAIN_STUCK 且 now-last_t 小于 cooldown（默认 GAIN_COOLDOWN）时返回 sigma=0.0、gain=0，终态全属 _GAIN_STUCK 但冷却已过、且与该 bid 相关轮次的 meta_outcomes.delta[DMETA_PROXY] 均值大于 0 时同样返回 sigma=0.0、gain=0（压力仍在扩大则不放行），其余返回 sigma=1.0、gain=1；meta_outcomes 键缺失、delta 非字典或其值为非数值的轮次不计入压力均值（缺键即不触发新分支，既有 ①-④ 行为逐字不变）。
 def gain_gate(cg, bid: str, now: float | None = None,
               window: int = GAIN_WINDOW, cooldown: float = GAIN_COOLDOWN) -> dict:
     """信息增益门槛（P-T-40 第四保护投影，纯读无副作用）。
@@ -61,7 +74,7 @@ def gain_gate(cg, bid: str, now: float | None = None,
     `now` 可注入以便测试冷却过期。
     """
     now = time.time() if now is None else float(now)
-    terminals, last_t = [], 0.0
+    terminals, last_t, meta_deltas = [], 0.0, []
     try:
         with open(_explore_log_path(cg), encoding="utf-8") as f:
             for line in f:
@@ -75,30 +88,58 @@ def gain_gate(cg, bid: str, now: float | None = None,
                 if bid in oc:
                     terminals.append(str(oc[bid]))
                     last_t = max(last_t, float(r.get("t") or 0.0))
+                    # D_meta 跨轮压力增量（缺键/关闭 → 不计入 → 不触发新分支）
+                    mo = r.get("meta_outcomes")
+                    dlt = mo.get("delta") if isinstance(mo, dict) else None
+                    v = dlt.get(DMETA_PROXY) if isinstance(dlt, dict) else None
+                    if isinstance(v, (int, float)) and not isinstance(v, bool):
+                        meta_deltas.append(float(v))
     except OSError:
         pass
     if not terminals:
         return {"sigma": 1.0, "gain": None, "last_t": 0.0,
                 "reason": "无探索历史（首探放行：无证据不否决）"}
     recent = terminals[-int(window):]
-    if (len(recent) >= int(window)
-            and all(t in _GAIN_STUCK for t in recent)
-            and (now - last_t) < float(cooldown)):
+    stuck = (len(recent) >= int(window)
+             and all(t in _GAIN_STUCK for t in recent))
+    rising = bool(meta_deltas) and (sum(meta_deltas) / len(meta_deltas)) > 0
+    meta_txt = ""
+    if rising:
+        meta_txt = ("；D_meta 压力均值 %+.4f（%s，近 %d 轮留痕）"
+                    % (sum(meta_deltas) / len(meta_deltas), DMETA_PROXY,
+                       len(meta_deltas)))
+    if stuck and (now - last_t) < float(cooldown):
         return {"sigma": 0.0, "gain": 0, "last_t": round(last_t, 3),
                 "reason": ("增益门槛（P-T-40）：连续 %d 次终态无变化 %s → "
-                           "DEFER_EXHAUSTED（冷却 %ds 内不再重复探索）"
-                           % (len(recent), list(recent), int(cooldown)))}
+                           "DEFER_EXHAUSTED（冷却 %ds 内不再重复探索）%s"
+                           % (len(recent), list(recent), int(cooldown),
+                              meta_txt))}
+    if stuck and rising:
+        return {"sigma": 0.0, "gain": 0, "last_t": round(last_t, 3),
+                "meta_rising": True,
+                "reason": ("增益门槛（P-T-40）：连续 %d 次终态无变化 %s 且 "
+                           "D_meta 压力仍在扩大%s → "
+                           "DEFER_EXHAUSTED_UNDER_PRESSURE（冷却已过但不放行："
+                           "压力扩大而终态停滞 = 重复探索不再产生增益）"
+                           % (len(recent), list(recent), meta_txt))}
     return {"sigma": 1.0, "gain": 1, "last_t": round(last_t, 3),
             "reason": "有增益证据或冷却已过"}
 
 
+# 生效条件：cg 的反思记录经 metacognition._reflections 取末 int(window) 条切片（window=0 时切片即全量），按非空 query 聚合后仅 score=W_D2*d2_abs+W_BLINDSPOT*blindspot+W_DEFER*defer>0 的项进入 out（**资格判据先于加分**：score<=0 即 continue，D_meta 不构成资格），其中 enforce_gain 为真值时还须 gain_gate(cg, …, now)["sigma"]>0 否则该项标 deferred_exhausted 转入 deferred，enforce_gain 为假值时不做增益筛选全数进入 out；D_meta 加分 W_DMETA*d_meta.pressure(d_meta.compute(cg, window), DMETA_PROXY) 每轮只算一次并在循环内复用，只写入 sort_score 与 reason 证据（不改 score、不改资格、不改 σ），MDCG_D_META 关闭或未启用时该加分为 0.0；最终 out 按 (-sort_score, -last_t) 排序后截取 max(1, int(limit)) 条（limit=0 或负数也返回 1 条）并随 n_signals=len(agg) 返回；
 def proposals(cg, window: int = 200, limit: int = 3,
               enforce_gain: bool = True) -> dict:
     """从反思日志聚合信息差信号，产出排序后的探索提案。
 
     每条提案携带证据明细（d2 之和/绝对值和、BLINDSPOT/DEFER 计数、样本数），
-    排序键 = W_D2*Σ|d2| + W_BLINDSPOT*BLINDSPOT + W_DEFER*DEFER。
-    无信号的查询不产生提案（不编造探索价值）。
+    `score` = W_D2*Σ|d2| + W_BLINDSPOT*BLINDSPOT + W_DEFER*DEFER（**ΔD 定价器，
+    口径不变**）；`sort_score` = score + W_DMETA×D_meta 边界压力（排序键）。
+    无信号的查询不产生提案（不编造探索价值）——**D_meta 加分不构成资格**：
+    `score<=0` 的项在加分之前就被 continue 掉。
+
+    D_meta 只影响**排序**、不改 σ(Gain) 筛选；本轮取库侧 query 无关的单一
+    代理（DMETA_PROXY），同轮各提案加分同值，故当前口径下排序不变——
+    区分性待 query-relative 口径落盘后自然生效（不提前编造）。
 
     `enforce_gain`（默认 True）：σ(Gain) 资格筛选（#37 价值链——score 是
     定价器，Gain 是筛选器）。被门槛拦下的提案不静默丢弃，落入 `deferred`
@@ -129,17 +170,24 @@ def proposals(cg, window: int = 200, limit: int = 3,
 
     out, deferred = [], []
     now = time.time()
+    mv = d_meta.compute(cg, window=window)   # 每轮一次、循环内复用（禁 N× 扫描）
+    bonus = (round(W_DMETA * d_meta.pressure(mv, DMETA_PROXY), 4)
+             if mv.get("enabled") else 0.0)
     for a in agg.values():
         score = (W_D2 * a["d2_abs"] + W_BLINDSPOT * a["blindspot"]
                  + W_DEFER * a["defer"])
         if score <= 0:
             continue                       # 无信息差信号 → 不提案（不编造）
         a = dict(a)
-        a["score"] = round(score, 4)
+        a["score"] = round(score, 4)       # ΔD 定价器：口径不变
+        a["d_meta_bonus"] = bonus          # D_meta 排序加分（只影响排序）
+        a["sort_score"] = round(score + bonus, 4)
         a["reason"] = ("信息差信号：Σ|d2|=%s（Σd2=%s）+ BLINDSPOT×%d + DEFER×%d"
-                       "（近 %d 次反思）"
+                       "（近 %d 次反思）；D_meta 排序加分 +%s（%s=%s，三代理"
+                       "不合成；不改资格/σ(Gain)）"
                        % (a["d2_abs"], a["d2_sum"], a["blindspot"],
-                          a["defer"], a["samples"]))
+                          a["defer"], a["samples"], bonus, DMETA_PROXY,
+                          d_meta.pressure(mv, DMETA_PROXY)))
         if enforce_gain:                   # P-T-40 增益门槛：资格由实现值裁决
             gate = gain_gate(cg, metacognition._key(a["query"]), now=now)
             a["gain_gate"] = gate
@@ -148,13 +196,17 @@ def proposals(cg, window: int = 200, limit: int = 3,
                 deferred.append(a)
                 continue
         out.append(a)
-    out.sort(key=lambda x: (-x["score"], -x["last_t"]))
+    out.sort(key=lambda x: (-x["sort_score"], -x["last_t"]))
     return {"ok": True, "proposals": out[:max(1, int(limit))],
             "n_signals": len(agg), "deferred": deferred,
+            "d_meta": {"enabled": bool(mv.get("enabled")), "bonus": bonus,
+                       "proxy": DMETA_PROXY},
             "value_chain": ("Value=ΔD·σ(Gain)：score 定价排序（ΔD 代理），"
-                            "σ(Gain) 资格筛选（实现值=outcomes 留痕）")}
+                            "σ(Gain) 资格筛选（实现值=outcomes 留痕）；"
+                            "D_meta 只加排序分、不改资格（DEV-002a）")}
 
 
+# 生效条件：cg 必需，该符号始终返回 ok=True、action="explore"；其中 bypass_gain 为真值时以 enforce_gain=False 调 proposals、为假值时以 True 调（window/limit 原样透传），逐条提案用 apply/actor 调 predict.learn_blindspots 并把其首个 step 的 terminal 记入 outcomes[bid]，同一 blindspot_id 本轮已见则记为 skipped，调用抛异常则记为 error（"%s: %s" % (type(exc).__name__, exc)），并额外取本轮 d_meta.compute（append 前状态）与上一条 explore 留痕的 meta_outcomes.before，并列写入 meta_outcomes={before, prev_before, delta, proxy, enabled}（**outcomes 值类型不变**），最后 append_jsonl 写 _explore_log_path(cg) 时仅 OSError 被忽略；
 def explore(cg, apply: bool = False, limit: int = 3, window: int = 200,
             actor: str = "autonomy", bypass_gain: bool = False) -> dict:
     """最小探索闭环：提案 → 逐盲区五态验证 →（apply）回写待补线索。
@@ -173,6 +225,11 @@ def explore(cg, apply: bool = False, limit: int = 3, window: int = 200,
         （绕过增益筛选照常探索，留痕 bypass_gain 字段可审计）。
     """
     pr = proposals(cg, window=window, limit=limit, enforce_gain=not bypass_gain)
+    mv = d_meta.compute(cg, window=window)      # 本轮 D_meta（append 前状态）
+    prev = None
+    for r in d_meta.tail_jsonl(_explore_log_path(cg), 1):
+        mo = r.get("meta_outcomes") if isinstance(r, dict) else None
+        prev = mo.get("before") if isinstance(mo, dict) else None
     steps, outcomes, seen = [], {}, set()
     for p in pr["proposals"]:
         bid = metacognition._key(p["query"])
@@ -201,6 +258,20 @@ def explore(cg, apply: bool = False, limit: int = 3, window: int = 200,
            "bids": [s["blindspot_id"] for s in steps],
            "outcomes": outcomes,
            "bypass_gain": bool(bypass_gain),
+           # D_meta 并列留痕（**outcomes 值类型不变**：终态字符串契约是
+           # gain_gate 停滞集比对的前提，改成 dict 会让 σ 静默恒为 1.0）：
+           #   before      = 本轮开始时的三代理（含上轮 apply 的效果）
+           #   prev_before = 上一条 explore 留痕的 before（无则 None）
+           #   delta       = before − prev_before（跨轮压力增量 → gain_gate 输入）
+           "meta_outcomes": {
+               "before": {k: float(mv.get(k) or 0.0)
+                          for k in d_meta.PROXY_KEYS},
+               "prev_before": ({k: float(prev.get(k) or 0.0)
+                                for k in d_meta.PROXY_KEYS}
+                               if isinstance(prev, dict) else None),
+               "delta": d_meta.diff(prev, mv),
+               "proxy": DMETA_PROXY,
+               "enabled": bool(mv.get("enabled"))},
            "gain_deferred": [(d.get("query"), d.get("gain_gate", {}).get("reason"))
                              for d in (pr.get("deferred") or [])]}
     try:
@@ -214,4 +285,4 @@ def explore(cg, apply: bool = False, limit: int = 3, window: int = 200,
                      "裁决资格）；终态五态由 learn_blindspots 诚实判定；"
                      "apply=True 仅落地 carried/unresolved 的 gap_hint 待补"
                      "线索（幂等）；P-T-40 四保护=单轮深度/本轮循环去重/"
-                     "增益冷却/预算 limit（bypass_gain 显式豁免可审计）")}
+                     "增益冷却/预算 limit（bypass_gain 显式豁免可审计）")}