@furongjun1999/dsh-memory 0.4.6 → 0.4.8

package/lib/lib/mdcg_client.js

@@ -35,6 +35,7 @@
  *   的**所有写入**（记忆沉淀 / 角色定义 / 对话转录）统一经 `mdcg_remember`。
  */
 import { LingshuBridge } from '../bridge.js';
+import { pythonPathValue, repoRoot } from './datapath.js';
 const DEFAULT_ARGS = ['-m', 'md_cg.mcp_server'];
 /** 认知图依据强度：这些 basis 视为「强依据」，可支撑 pass。
  *  取值须在 md_cg.mdcg.VERIFICATION_BASIS 允许集内：
@@ -62,6 +63,10 @@ function collectItems(payload) {
 export class MdcgClient {
     bridge;
     constructor(opts) {
+        // issue #12：cwd 与 PYTHONPATH 双保险锚定插件仓根——cwd 是 `python -m`
+        // 解析随包包的主通道，PYTHONPATH 覆盖显式自定义 args 的场景。opts.env
+        // 显式提供 PYTHONPATH 时完全接管（其展开在最后：显式配置原样尊重）。
+        const cwd = opts.cwd ?? repoRoot();
         const env = {
             // ⚠️ 必须显式 utf-8：Windows 下 piped 子进程默认 gbk + surrogateescape，
             // Node 写出的 UTF-8 中文会被解成孤立代理字符（\udcXX），md_cg 在落盘 /
@@ -74,6 +79,7 @@ export class MdcgClient {
             MDCG_MCP_SURFACE: opts.surface ?? 'full',
             MDCG_TENANT: opts.tenant ?? 'default',
             MDCG_CLEARANCE: opts.clearance ?? 'private',
+            PYTHONPATH: pythonPathValue(),
             ...(opts.actor ? { MDCG_ACTOR: opts.actor } : {}),
             ...(opts.identity ? { MDCG_IDENTITY: opts.identity } : {}),
             ...(opts.env ?? {}),
@@ -82,6 +88,7 @@ export class MdcgClient {
             python: opts.python,
             args: opts.args ?? DEFAULT_ARGS,
             env,
+            cwd,
             timeoutMs: opts.timeoutMs ?? 60_000,
             maxRetryDelayMs: opts.maxRetryDelayMs ?? 30_000,
         });

package/lib/lib/mutual.js

@@ -15,6 +15,7 @@ import { exec, spawn } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
+import { pythonPathValue, repoRoot } from './datapath.js';
 const DEFAULTS = {
     heartbeatMs: 10 * 60 * 1000,
     warnMs: 25 * 60 * 1000,
@@ -119,6 +120,10 @@ export async function ensureHarness(python = 'python', opts = DEFAULTS) {
                 windowsHide: true,
                 detached: true,
                 stdio: 'ignore',
+                // issue #12 同类：锚定插件仓根 + PYTHONPATH，与 mdcg_client / token_store
+                // 同口径——不随宿主 cwd 漂移；harness 包不在仓内时注入不劣化（回落用户环境）。
+                cwd: repoRoot(),
+                env: { ...process.env, PYTHONPATH: pythonPathValue() },
             });
         }
         catch (e) {

package/lib/lib/prompt_safety.d.ts

@@ -0,0 +1,48 @@
+/**
+ * prompt_safety.ts · 注入边界文本安全（宿主严格模板的转义）
+ *
+ * ── 根因（issue #16，2026-09-16）────────────────────────────────────────
+ * dsh 宿主 `@deepseek-ai/dsh-system-prompt` 的 `interpolate()` 会对**每个
+ * section / context** 文本做严格 `{{variable}}` 插值，且**四类一律 throw**：
+ *   ① `{{` 之后能找到 `}}` 但不成简单组（GROUP_AT = /^\{\{([^{}]*)\}\}/ 不匹配）
+ *   ② 组成立但名不匹配 /^[a-z][a-z0-9_]*$/（如 `{{.Architecture}}`）
+ *   ③ 名合法但未注册（如 `{{name}}`）
+ *   ④ 已注册但值为 undefined
+ * `renderContextSections()` 逐 context 调用它，throw 直接冒泡到
+ * `system-prompt/assemble` → **该轮请求整体失败**。
+ *
+ * ── 伤害路径 ───────────────────────────────────────────────────────────
+ * 自动记忆把用户命令原样沉淀（如 `docker inspect --format '{{.Architecture}}'`）
+ * → auto-recall 把含裸 `{{` 的预览推入 `assembly.contexts`
+ * → 宿主每轮 assemble 必抛 → **会话永久不可用**（记忆永久在库，非偶发故障）。
+ *
+ * ── 处置：为何只在注入边界转义，不在写入侧 ────────────────────────────
+ *   ① 记忆真源必须保真：`{{.Architecture}}` 是用户命令原文，写入侧转义会
+ *      不可逆失真，且 cg(op=read) / 工具面 / 检索都依赖原文（= 污染真源）；
+ *   ② 伤害面就是「注入到 prompt 的文本」，在注入边界处理即**最小充分**；
+ *   ③ 与写入侧 desensitize 不冲突：脱敏是**隐私**要求（不许落盘），
+ *      转义是**渲染安全**要求（落盘保真、渲染时规避）——层次不同。
+ *
+ * ── 转义策略：确保文本中不出现连续两个 `{` ────────────────────────────
+ * 依据（宿主源码 `lib/index.js:109-116`）：`interpolate` 以
+ * `text.indexOf("{{")` 为**唯一扫描锚点**；破坏 `{{` 序列后循环不进入，
+ * 文本走 `text.slice(last)` 原样返回。
+ *   · `}}` 无需处理——它只在 `{{` 成组时参与解析，锚点已破即无意义；
+ *   · 逐对打断（而非 `split('{{').join(...)`）：后者对 `{{{a}}}` 会产出
+ *     `{ {{a}}}`——新锚点仍在（相邻 `{` 重新合成），不幂等也不安全；
+ *   · 跨 context 拼接安全：`joinContextSections` 以 `"\n\n"` 分隔并带固定
+ *     前缀（`lib/index.js:85-87`，前缀以 `.` 结尾），边界不会合成新 `{{`；
+ *   · 为何不用零宽字符：显示上「看起来一样」但复制会带入不可见字符
+ *     （终端粘贴即出错）——诚实性优先，宁可让改写可见。
+ *
+ * 幂等：结果中不存在 `{{`，重复调用结果不变。
+ * 边界：本函数只服务**注入到宿主 prompt 的文本**；记忆真源与工具返回原文
+ *       一律不动（工具结果不进 assembly 插值面）。
+ */
+/**
+ * 把文本中每一对相邻的 `{` 打断（插入半角空格），使其不再包含 `{{`。
+ *
+ * 不含 `{{` 的文本**原样返回**（零改写，保真）。
+ * 例：`{{.Architecture}}` → `{ {.Architecture}}`；`{{{a}}}` → `{ { {a}}}`。
+ */
+export declare function escapePromptBraces(text: string): string;

package/lib/lib/prompt_safety.js

@@ -0,0 +1,62 @@
+/**
+ * prompt_safety.ts · 注入边界文本安全（宿主严格模板的转义）
+ *
+ * ── 根因（issue #16，2026-09-16）────────────────────────────────────────
+ * dsh 宿主 `@deepseek-ai/dsh-system-prompt` 的 `interpolate()` 会对**每个
+ * section / context** 文本做严格 `{{variable}}` 插值，且**四类一律 throw**：
+ *   ① `{{` 之后能找到 `}}` 但不成简单组（GROUP_AT = /^\{\{([^{}]*)\}\}/ 不匹配）
+ *   ② 组成立但名不匹配 /^[a-z][a-z0-9_]*$/（如 `{{.Architecture}}`）
+ *   ③ 名合法但未注册（如 `{{name}}`）
+ *   ④ 已注册但值为 undefined
+ * `renderContextSections()` 逐 context 调用它，throw 直接冒泡到
+ * `system-prompt/assemble` → **该轮请求整体失败**。
+ *
+ * ── 伤害路径 ───────────────────────────────────────────────────────────
+ * 自动记忆把用户命令原样沉淀（如 `docker inspect --format '{{.Architecture}}'`）
+ * → auto-recall 把含裸 `{{` 的预览推入 `assembly.contexts`
+ * → 宿主每轮 assemble 必抛 → **会话永久不可用**（记忆永久在库，非偶发故障）。
+ *
+ * ── 处置：为何只在注入边界转义，不在写入侧 ────────────────────────────
+ *   ① 记忆真源必须保真：`{{.Architecture}}` 是用户命令原文，写入侧转义会
+ *      不可逆失真，且 cg(op=read) / 工具面 / 检索都依赖原文（= 污染真源）；
+ *   ② 伤害面就是「注入到 prompt 的文本」，在注入边界处理即**最小充分**；
+ *   ③ 与写入侧 desensitize 不冲突：脱敏是**隐私**要求（不许落盘），
+ *      转义是**渲染安全**要求（落盘保真、渲染时规避）——层次不同。
+ *
+ * ── 转义策略：确保文本中不出现连续两个 `{` ────────────────────────────
+ * 依据（宿主源码 `lib/index.js:109-116`）：`interpolate` 以
+ * `text.indexOf("{{")` 为**唯一扫描锚点**；破坏 `{{` 序列后循环不进入，
+ * 文本走 `text.slice(last)` 原样返回。
+ *   · `}}` 无需处理——它只在 `{{` 成组时参与解析，锚点已破即无意义；
+ *   · 逐对打断（而非 `split('{{').join(...)`）：后者对 `{{{a}}}` 会产出
+ *     `{ {{a}}}`——新锚点仍在（相邻 `{` 重新合成），不幂等也不安全；
+ *   · 跨 context 拼接安全：`joinContextSections` 以 `"\n\n"` 分隔并带固定
+ *     前缀（`lib/index.js:85-87`，前缀以 `.` 结尾），边界不会合成新 `{{`；
+ *   · 为何不用零宽字符：显示上「看起来一样」但复制会带入不可见字符
+ *     （终端粘贴即出错）——诚实性优先，宁可让改写可见。
+ *
+ * 幂等：结果中不存在 `{{`，重复调用结果不变。
+ * 边界：本函数只服务**注入到宿主 prompt 的文本**；记忆真源与工具返回原文
+ *       一律不动（工具结果不进 assembly 插值面）。
+ */
+/** 宿主严格模板的扫描锚点。 */
+const TEMPLATE_OPEN = '{{';
+/**
+ * 把文本中每一对相邻的 `{` 打断（插入半角空格），使其不再包含 `{{`。
+ *
+ * 不含 `{{` 的文本**原样返回**（零改写，保真）。
+ * 例：`{{.Architecture}}` → `{ {.Architecture}}`；`{{{a}}}` → `{ { {a}}}`。
+ */
+export function escapePromptBraces(text) {
+    if (!text.includes(TEMPLATE_OPEN))
+        return text;
+    let out = '';
+    for (let i = 0; i < text.length; i++) {
+        const ch = text.charAt(i);
+        out += ch;
+        // 该 `{` 与下一个字符构成锚点 → 立即插入空格打断
+        if (ch === '{' && text.charAt(i + 1) === '{')
+            out += ' ';
+    }
+    return out;
+}

package/lib/lib/roleplay_web.js

@@ -9,7 +9,7 @@
  *    转录、历史、翻译、落图全部不依赖「身体」，始终可用。
  *  · 身体（可选 capability 后端）：生成能力 roleplay_chat / role_create /
  *    role_import 属「身」，主仓默认不挂载；未挂载时这些接口 **fail-closed**
- *    返回明确原因（不编造回复）。启用见 config.capability（cordis.yml.example）。
+ *    返回明确原因（不编造回复）。启用见 config.capability（dsh/cordis.yml.example）。
  */
 import { join, dirname } from 'node:path';
 import { readFileSync, mkdirSync, appendFileSync, existsSync, writeFileSync, renameSync } from 'node:fs';

package/lib/lib/token_store.js

@@ -30,6 +30,7 @@ import { spawnSync } from 'node:child_process';
 import { chmodSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
+import { pythonPathValue, repoRoot } from './datapath.js';
 /** 默认密钥环路径：与 md_cg 的 `~/.mdcg/` 约定同目录（`_tokens.json` 亦在此）。 */
 export function defaultKeyringPath() {
     return join(homedir(), '.mdcg', 'token');
@@ -64,8 +65,17 @@ function issueToken(python, role, actor, clearance) {
             encoding: 'utf-8',
             windowsHide: true,
             timeout: 15_000,
-            // 与工作纪律第 15 条同源：显式 UTF-8 + PYTHONUTF8，规避 Windows GBK 解码异常
-            env: { ...process.env, PYTHONUTF8: '1', PYTHONIOENCODING: 'utf-8' },
+            // 与工作纪律第 15 条同源：显式 UTF-8 + PYTHONUTF8，规避 Windows GBK 解码异常。
+            // issue #12：cwd+PYTHONPATH 锚定插件仓根——否则 npm 包形态下宿主在仓外
+            // 启动时 `python -m md_cg.tokens` 找不到随包 md_cg，首启签发静默失败，
+            // md_cg 侧降级只读 guest（写入全不落盘且无报错）。
+            cwd: repoRoot(),
+            env: {
+                ...process.env,
+                PYTHONPATH: pythonPathValue(),
+                PYTHONUTF8: '1',
+                PYTHONIOENCODING: 'utf-8',
+            },
         });
     }
     catch (e) {

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,12 +29,14 @@ CONTENT_KINDS = {
     "permission": "权限操作 → 是否具有权限",
     "work_done": "工作完成 → 工作项是否通过验收",
     "work_wip": "工作进行 → 是否已有完整成果 + 是否符合纪律",
+    "ccg_marks": "CCG 六要素候选 → 编外验证方实测确认（生成方不得自证）",
 }
 
 # 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"}
 
 VERIFIERS = {}
 
@@ -187,6 +190,73 @@ def _pending(kind, why):
     return _fn
 
 
+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})
+
+
 # ---------- 分派入口 ----------
 
 def audit(content_kind, payload=None, ctx=None):
@@ -278,3 +348,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

@@ -0,0 +1,217 @@
+# -*- coding: utf-8 -*-
+"""信息差驱动的自主探索闭环（提案 → 验证 → 回写）。
+
+定位（待办 2「信息差驱动的自动化/自主化」的最小实现）：
+  灵枢已有全部零件——d2 信号在反思日志持续产生（mdcg.reflect L1097），
+  盲区聚类按 states 聚合（metacognition.blindspots），盲区→路线假设→五态
+  终判→gap_hint 回写齐备（predict.learn_blindspots）——**缺口只在触发器**：
+  信号在记录，无人在听。本模块把四段焊成一条自动链：
+
+      信号（reflection: d2 加速度 + BLINDSPOT/DEFER 计数）
+        → 提案（proposals：信息差评分排序，证据随提案留痕）
+        → 验证（predict.learn_blindspots 五态终判：unknowable / no_anchor /
+                unresolved / carried / resolved——诚实优先，绝不编造）
+        → 回写（apply=True 时 carried/unresolved 落 contextual 的 gap_hint，
+                节点 id 由盲区键派生 ⇒ 幂等）
+
+  资格纪律：提案由**条件证据**（信息差信号）授予，不由相似度授予；
+  score 只做排序不做资格——score<=0（无任何信号）即不提案。
+  回写边界：gap_hint 是「待补线索」非事实断言（predict._write_gap 同源）。
+  opt-in：explore 只被显式调用（或 mdcos insight act="explore"）触发，
+  默认链路零行为变更。
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+
+from . import 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
+
+EXPLORE_LOG = "_explore.jsonl"
+
+# P-T-40 信息增益门槛（#6/#37 投影）：Value = ΔD·σ(Gain)——
+#   score（ΔD 代理）是**定价器**（排序），σ(Gain) 是**筛选器**（资格）。
+#   期望/实现分离（智能论 2.9.3）：proposals 端的 σ 由**上一轮 explore 的
+#   实现值**（outcomes 留痕）推导——期望值用于决策，实现值用于确认。
+GAIN_WINDOW = 2        # 连续 GAIN_WINDOW 次终态无变化 → 视为无增益
+GAIN_COOLDOWN = 3600.0 # 冷却秒数：过期后 σ 回 1.0（给探索机会，不永久冻结）
+_GAIN_STUCK = ("carried", "unresolved", "unknowable", "no_anchor")
+
+
+def _explore_log_path(cg):
+    return os.path.join(getattr(cg, "root", "."), EXPLORE_LOG)
+
+
+def gain_gate(cg, bid: str, now: float | None = None,
+              window: int = GAIN_WINDOW, cooldown: float = GAIN_COOLDOWN) -> dict:
+    """信息增益门槛（P-T-40 第四保护投影，纯读无副作用）。
+
+    读上一轮 explore 的**实现值**（_explore.jsonl 的 outcomes 留痕）裁决
+    该盲区是否值得再探：
+      无历史 → σ=1.0, gain=None（首探放行：Gain 是筛选器，无证据不否决）
+      连续 `window` 次终态 ∈ 停滞集且仍在 `cooldown` 内 → σ=0, gain=0
+        （**DEFER_EXHAUSTED**：探索无增益，冷却——不编造重复探索的价值）
+      其余（有 resolved 变化 / 证据不足 / 冷却已过）→ σ=1.0, gain=1
+    `now` 可注入以便测试冷却过期。
+    """
+    now = time.time() if now is None else float(now)
+    terminals, last_t = [], 0.0
+    try:
+        with open(_explore_log_path(cg), encoding="utf-8") as f:
+            for line in f:
+                if not line.strip():
+                    continue
+                try:
+                    r = json.loads(line)
+                except ValueError:
+                    continue
+                oc = r.get("outcomes") or {}
+                if bid in oc:
+                    terminals.append(str(oc[bid]))
+                    last_t = max(last_t, float(r.get("t") or 0.0))
+    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)):
+        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)))}
+    return {"sigma": 1.0, "gain": 1, "last_t": round(last_t, 3),
+            "reason": "有增益证据或冷却已过"}
+
+
+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。
+    无信号的查询不产生提案（不编造探索价值）。
+
+    `enforce_gain`（默认 True）：σ(Gain) 资格筛选（#37 价值链——score 是
+    定价器，Gain 是筛选器）。被门槛拦下的提案不静默丢弃，落入 `deferred`
+    （reason 留痕可审计）。bypass 场景走 explore(bypass_gain=True)。
+    """
+    recs = metacognition._reflections(cg)[-int(window):]
+    agg = {}
+    for r in recs:
+        q = str(r.get("query") or "").strip()
+        if not q:
+            continue
+        k = metacognition._key(q)
+        a = agg.setdefault(k, {"query": q, "d2_sum": 0.0, "d2_abs": 0.0,
+                               "blindspot": 0, "defer": 0, "samples": 0,
+                               "last_t": 0.0})
+        d2 = r.get("d2")
+        if isinstance(d2, (int, float)):
+            a["d2_sum"] = round(a["d2_sum"] + float(d2), 6)
+            a["d2_abs"] = round(a["d2_abs"] + abs(float(d2)), 6)
+        st = r.get("states") or {}
+        try:
+            a["blindspot"] += int(st.get("BLINDSPOT") or 0)
+            a["defer"] += int(st.get("DEFER") or 0)
+        except (TypeError, ValueError):
+            pass
+        a["samples"] += 1
+        a["last_t"] = max(a["last_t"], float(r.get("t") or 0.0))
+
+    out, deferred = [], []
+    now = time.time()
+    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["reason"] = ("信息差信号：Σ|d2|=%s（Σd2=%s）+ BLINDSPOT×%d + DEFER×%d"
+                       "（近 %d 次反思）"
+                       % (a["d2_abs"], a["d2_sum"], a["blindspot"],
+                          a["defer"], a["samples"]))
+        if enforce_gain:                   # P-T-40 增益门槛：资格由实现值裁决
+            gate = gain_gate(cg, metacognition._key(a["query"]), now=now)
+            a["gain_gate"] = gate
+            if gate["sigma"] <= 0:
+                a["status"] = "deferred_exhausted"
+                deferred.append(a)
+                continue
+        out.append(a)
+    out.sort(key=lambda x: (-x["score"], -x["last_t"]))
+    return {"ok": True, "proposals": out[:max(1, int(limit))],
+            "n_signals": len(agg), "deferred": deferred,
+            "value_chain": ("Value=ΔD·σ(Gain)：score 定价排序（ΔD 代理），"
+                            "σ(Gain) 资格筛选（实现值=outcomes 留痕）")}
+
+
+def explore(cg, apply: bool = False, limit: int = 3, window: int = 200,
+            actor: str = "autonomy", bypass_gain: bool = False) -> dict:
+    """最小探索闭环：提案 → 逐盲区五态验证 →（apply）回写待补线索。
+
+    每个提案交给 predict.learn_blindspots（blindspot_id 用盲区键口径，
+    与 find_blindspot 的 cluster 匹配同构）；终态与回写结果原样汇总，
+    并在 _explore.jsonl 留痕（提案级证据 + 触发者 + outcomes 实现值，
+    可审计可复放——outcomes 是下轮 gain_gate 的裁决输入）。
+
+    P-T-40 递归四保护投影（#6）：
+      ①深度：单轮验证，不递归展开（explore 不嵌套调用 explore）；
+      ②循环：本轮内同一 blindspot_id 只验证一次（seen 去重）；
+      ③增益：proposals 端 σ(Gain) 门槛（DEFER_EXHAUSTED 冷却）；
+      ④预算：`limit` 即本轮探索预算；
+        `bypass_gain=True` = 2.9.3.1 非任务探索的**显式预算豁免**
+        （绕过增益筛选照常探索，留痕 bypass_gain 字段可审计）。
+    """
+    pr = proposals(cg, window=window, limit=limit, enforce_gain=not bypass_gain)
+    steps, outcomes, seen = [], {}, set()
+    for p in pr["proposals"]:
+        bid = metacognition._key(p["query"])
+        if bid in seen:                    # ②循环保护：本轮防重复
+            steps.append({"proposal": p, "blindspot_id": bid,
+                          "terminal": "skipped",
+                          "hint": "循环保护：本轮已验证（P-T-40②）"})
+            continue
+        seen.add(bid)
+        try:
+            res = predict.learn_blindspots(cg, blindspot_id=bid, apply=apply,
+                                           actor=actor)
+            one = (res.get("steps") or [{}])[0]
+            step = {"blindspot_id": bid,
+                    "terminal": one.get("terminal"),
+                    "routes": one.get("routes"),
+                    "written": one.get("written"),
+                    "hint": one.get("hint", "")}
+        except Exception as exc:               # noqa: BLE001
+            step = {"blindspot_id": bid, "terminal": "error",
+                    "error": "%s: %s" % (type(exc).__name__, exc)}
+        outcomes[bid] = step["terminal"]       # ③实现值落痕 → 下轮裁决输入
+        steps.append({"proposal": p, **step})
+    rec = {"type": "explore", "t": time.time(), "actor": actor,
+           "apply": bool(apply), "n_proposals": len(steps),
+           "bids": [s["blindspot_id"] for s in steps],
+           "outcomes": outcomes,
+           "bypass_gain": bool(bypass_gain),
+           "gain_deferred": [(d.get("query"), d.get("gain_gate", {}).get("reason"))
+                             for d in (pr.get("deferred") or [])]}
+    try:
+        append_jsonl(_explore_log_path(cg), rec)
+    except OSError:
+        pass
+    return {"ok": True, "action": "explore", "apply": bool(apply),
+            "proposals": pr["proposals"], "steps": steps,
+            "n_signals": pr["n_signals"], "deferred": pr.get("deferred") or [],
+            "note": ("提案=信息差信号排序（score 定价）+ σ(Gain) 门槛（实现值"
+                     "裁决资格）；终态五态由 learn_blindspots 诚实判定；"
+                     "apply=True 仅落地 carried/unresolved 的 gap_hint 待补"
+                     "线索（幂等）；P-T-40 四保护=单轮深度/本轮循环去重/"
+                     "增益冷却/预算 limit（bypass_gain 显式豁免可审计）")}

package/md_cg/backfill.py

@@ -546,14 +546,35 @@ def history(x, limit=100, action=None, batch=None) -> dict:
 
 # ---- 能力标签注入（关键词启发式） ----------------------------------------
 
+# 候选匹配不得吃进两类「自产词」，否则候选再生、plan 永不收敛：
+#   ① `fm.tags`：`cap:<op>` 是**注入结果**，回流后 `cap:route` 自匹配关键词
+#      "route"、`cap:self_state` 自匹配 "self_state"…… 已注入节点会重新成为候选；
+#   ② `# 验证方式：` 模板行：它是 CCG 五要素的必备行，展开后**几乎全库**命中
+#      「验证」，`cap:verify` 遂从能力判断退化为正文模板的副产品
+#      （evolution 账本实测：预演命中 1630/1813）。
+_CAP_TEMPLATE_LINES = ("验证方式",)
+
+
+def _cap_body(content: str) -> str:
+    """正文（供关键词匹配）——剔除 CCG 模板行，防模板词污染候选。"""
+    keep = []
+    for line in (content or "").splitlines():
+        head = line.strip().lstrip("#").strip()
+        head = head.split("：", 1)[0].split(":", 1)[0].strip()
+        if head in _CAP_TEMPLATE_LINES:
+            continue
+        keep.append(line)
+    return "\n".join(keep)
+
+
 def _cap_text(e, fm, content) -> str:
-    parts = [_as_text(fm.get("title")), e.get("id") or "",
-             " ".join(str(t) for t in (fm.get("tags") or []))]
+    """候选匹配文本：节点标识 + CCG 字段 + 正文（**不含 `fm.tags`**）。"""
+    parts = [_as_text(fm.get("title")), e.get("id") or ""]
     for f in ("功能名", "生效条件", "子功能"):
         v = _ccg_field(content, f)
         if v:
             parts.append(v)
-    parts.append((content or "")[:300])
+    parts.append(_cap_body(content)[:300])
     return " ".join(parts).lower()