@furongjun1999/dsh-memory 0.7.0 → 0.7.1

package/md_cg/test_writelimit.py

@@ -6,7 +6,7 @@
   B 同构聚合：第 2+ 条并入既有（merge_count+1，不新增节点）
   C 频率限制：窗口内超量 DEFER；其他 role 不受影响
   D 保护优先：hint≥0.7 不限流
-  E 层豁免：knowledge 不聚合不限流
+  E 层豁免：knowledge 不聚合不限流（限流器未介入；半重复交遗忘闸门判 DEFER）
   F env 关闭：MDCG_WRITELIMIT=0 放行
   G 留痕：_forgetting.jsonl 有 limiter 记录
   H tidy：已落盘同构组聚合 + 成员降权 + 永不删除
@@ -22,6 +22,13 @@ import shutil
 import tempfile
 import time
 
+# 三档自治批次②（2026-10-02）**夹具隔离**：本守卫考的不是档位面（档位守卫 =
+# md_cg/test_autonomy_modes.py），故显式置 full 档——回到改动前「动作直落」的
+# 行为，使本文件的断言意图（合并/覆写/软删真的发生）逐条不变；env 键名从唯一
+# 真源表取（本文件不构成第二处字面量）。
+from . import autonomy_modes as _autonomy_modes          # noqa: E402
+os.environ[_autonomy_modes.AUTONOMY_ENV_KEYS["mode"]] = "full"
+
 from .mdcos import MdCGOS
 from . import writelimit
 
@@ -122,9 +129,26 @@ check("D1 hint≥0.7 跳过限流（不聚合）",
 writelimit._save(cg, {"sigs": {}, "rate": {}})   # 清状态隔离本节
 r_k1 = _write("wl_k1", "知识条目甲乙丙丁1号", layer="knowledge")
 r_k2 = _write("wl_k2", "知识条目甲乙丙丁2号", layer="knowledge")
-check("E1 knowledge 不聚合不限流",
-      r_k1["verdict"] == "ACCEPT" and r_k2["verdict"] == "ACCEPT",
+# E1 判据按标题所指重编码（issue50-b）：层豁免的本体是**限流器未介入**，
+# 而限流器介入的判据是 gate 里带 `limiter` 键（与 G 节 `rec.get("limiter")`
+# 同口径）。原先编码用「r_k2 判 ACCEPT」代理该语义——那是**旧遗忘闸门裁决**的
+# 副产物（半重复被重要度拦成 ACCEPT），不是层豁免的证据，issue50-a 判半重复
+# 为 DEFER 后必然转红。改判据不改意图。
+check("E1 knowledge 层豁免：限流器未介入（两条写入的 gate 均无 limiter 键）",
+      r_k1["verdict"] == "ACCEPT"
+      and "limiter" not in (r_k1.get("gate") or {})
+      and "limiter" not in (r_k2.get("gate") or {}),
       f"{r_k1.get('gate')}/{r_k2.get('gate')}")
+# E2 钉住新行为（issue50-a 落地后的既成事实）：knowledge 层半重复（两条载荷仅
+# 尾字不同，实测 dup=0.7778）由**遗忘闸门**判 DEFER——判据带 redundancy 读数
+# 且无 limiter 键，与限流 DEFER 可区分。
+check("E2 knowledge 层半重复交遗忘闸门判 DEFER（dup=0.7778）",
+      r_k2["verdict"] == "DEFER"
+      and "redundancy" in (r_k2.get("gate") or {})
+      and "limiter" not in (r_k2.get("gate") or {})
+      and round(float((r_k2.get("gate") or {})
+                      .get("redundancy", {}).get("max") or 0), 4) == 0.7778,
+      f"{r_k2.get('gate')}")
 
 # ---------------------------------------------------------------- F env 关闭
 
@@ -158,12 +182,15 @@ check("G1 限流留痕 _forgetting.jsonl",
 # ---------------------------------------------------------------- H tidy
 
 writelimit._save(cg, {"sigs": {}, "rate": {}})
-os.environ["MDCG_WRITELIMIT"] = "0"      # 绕过写入限流，直造存量同构组
-try:
-    for i in range(5):
-        _write(f"wl_t{i}", f"巡检批次{i}收官记忆")
-finally:
-    os.environ.pop("MDCG_WRITELIMIT", None)
+# 夹具口径（issue50-b，2026-10-01）：本节的目的是「**直造存量同构组**」，让 tidy 有已落盘
+# 的存量可聚合（tidy_contextual 按 template_signature(content) 扫索引分组，不依赖限流签名表）。
+# 原夹具用 MDCG_WRITELIMIT=0 绕限流——那只绕过 writelimit；issue50-a 之后**遗忘闸门**在半重复
+# （dup∈[0.60,0.85)）处先拦，5 条只落 1 条（实测 nodes=1、tidy dry groups=0），H1/H3/H4 因此
+# 转红。改用 gated=False 直写：它与本节注释的意图「直造存量」逐字相符，且比绕限流更直白——
+# tidy 的作用面本就是**已落盘的存量组**（历史遗留与绕闸写入），写入前的拦截归遗忘闸门。
+# **H 节四条断言一字未动**（改的是夹具造法，不是判据）。
+for i in range(5):
+    _write(f"wl_t{i}", f"巡检批次{i}收官记忆", gated=False)
 dry = writelimit.tidy_contextual(cg, apply=False)
 check("H1 dry-run 盘出同构组", dry["groups"] >= 1
       and dry["members"] >= 4, str(dry["groups"]))

package/md_cg/test_writepipe.py

@@ -135,9 +135,12 @@ def _run(tmp):
                                  "content": "PASSED SKIPME",
                                  "layer": "knowledge"})
     _check("移除即恢复(核心文件零改动)", out.get("committed") is True, repr(out))
-    # 默认 before 链含 linkref→deps→audit→consistency→gated（2026-09-19 deps 闸门新增）
+    # 默认 before 链含 linkref→deps→audit→consistency→gated→autonomy
+    # （2026-09-19 deps 闸门新增；2026-10-02 三档自治批次② 档位闸**恒在链尾**
+    # ——档位判定必须晚于全部既有资格闸，见 writepipe._gate_autonomy docstring。
+    # 断言意图不变：默认链的注册表与执行序 = 这一串。）
     _check("单例默认链", singleton.names()["before"]
-           == ["linkref", "deps", "audit", "consistency", "gated"],
+           == ["linkref", "deps", "audit", "consistency", "gated", "autonomy"],
            repr(singleton.names()))
     _check("单例默认after链", singleton.names()["after"]
            == ["linkref", "trust"],

package/md_cg/weights.py

@@ -468,7 +468,7 @@ def node_importance(cg, nid, indeg=None, red=None, entry=None):
             "protected_floor": protected}
 
 
-# 生效条件：给定 cg 且 nodes = cg.index["nodes"] 时按 layer 过滤、limit 为真值才 ids = ids[:int(limit)] 逐节点重算，abs(after-before) < float(min_delta) 记 unchanged；仅 apply=True 才把 frontmatter.importance/importance_source/importance_components 写回（after >= IMPORTANCE_PROTECT 且未 protected 时补写 protected/protection_reason），并向 cg.root 下 append_jsonl(..., MAINTAIN_LOG) 记 batch 后 rebuild_index。
+# 生效条件：给定 cg 且 nodes = cg.index["nodes"] 时按 layer 过滤、limit 为真值才 ids = ids[:int(limit)] 逐节点重算，abs(after-before) < float(min_delta) 记 unchanged（**预演面不接档位闸**）；仅 apply=True 才在**任何写盘之前**先经 autonomy_modes.e_gate() 档位判定（补强批次 v1.2·E 面接线）——非 ALLOW（plan 档无计划）即经 forbidden_result() fail-closed 早退（零写盘、零审计行），ALLOW（confirm/full）才把 frontmatter.importance/importance_source/importance_components 写回（after >= IMPORTANCE_PROTECT 且未 protected 时补写 protected/protection_reason），并向 cg.root 下 append_jsonl(..., MAINTAIN_LOG) 记 batch 后 rebuild_index。
 def recalc(cg, layer=None, limit=None, apply=False, min_delta=APPLY_DELTA,
            actor="maintain", dry_run_samples=10):
     """结构重要性重算：覆盖度 + 冗余度 + 验证基底 → 重排节点重要性。
@@ -476,6 +476,11 @@ def recalc(cg, layer=None, limit=None, apply=False, min_delta=APPLY_DELTA,
     apply=False（默认）只出报表，不写盘（对应计划「可预演」）。
     apply=True 逐节点改写 `frontmatter.importance`，每批写一条 `_maintain.jsonl`
     （before/after/分量/actor），并提供 rollback 反向应用。
+
+    **档位闸（补强批次 v1.2·E 面接线）**：`apply=True` 的**写盘前**先经
+    `autonomy_modes.e_gate()`（设计 §三 plan 档 E「须命中计划步骤」）——plan 档
+    无计划 ⇒ `forbidden_result()` fail-closed 早退（零写盘、零审计行）；confirm/
+    full ⇒ ALLOW、**原链原样**（逐位不变）。`apply=False`（预演）不接闸。
     """
     nodes = (getattr(cg, "index", None) or {}).get("nodes") or {}
     indeg = coverage_index(cg)
@@ -519,6 +524,15 @@ def recalc(cg, layer=None, limit=None, apply=False, min_delta=APPLY_DELTA,
         bl["avg_after"] = 0.0
     written = 0
     if apply:
+        # 三档自治（补强批次 v1.2·E 面接线，设计 §三 plan 档 E「须命中计划步骤」）：
+        # E 类动作**写盘前**的档位判定单点（同 `freshness.recalc` 口径）——
+        # 本函数无独立资格闸，闸口取「进入写盘支路的第一行」＝任何盘面写入之前；
+        # ALLOW（confirm/full）原链原样，plan 档无计划 ⇒ fail-closed 早退。
+        from . import autonomy_modes as _am
+        _dec = _am.e_gate()
+        if _dec["decision"] != _am.ALLOW:
+            return _am.forbidden_result(_dec, action="importance", dry_run=False,
+                                        written=0, batch=batch)
         for plan in planned:
             nid = plan["node_id"]
             node = cg.get(nid)

package/md_cg/writepipe.py

@@ -20,7 +20,8 @@ write 的六道闸（audit 校验 / consistency 冲突 / review 审核 / gated
   绕过（反面清单：不学 pi 的全权信任，信任必须结构强制）。
 
 默认链（install_default_gates，与重构前 _cg_dispatch write 分支行为逐字
-节一致）：audit → consistency → gated → _executor。
+节一致）：audit → consistency → gated → **autonomy（三档自治档位闸，
+2026-10-02 批次②）** → _executor。
 
 验收口径（交接文档 §3⑥）：全部既有写入测试零改动通过；新增/移除一个
 拦截器不改核心文件（register_before / unregister_before 即插即拔）。
@@ -401,6 +402,12 @@ def _gate_gated(ctx):
         out["moved_to"] = "merged_into:" + str(res.get("merged_into"))
     elif v in ("DROP", "DEFER"):
         out["moved_to"] = v.lower()
+    elif v == "CONFIRM":
+        # 三档自治批次②：变更确认档下 B 合并已出变更单（未合并）——去向如实
+        # 透出 review_queue（DROP/DEFER 两态的字面量分支一字未动）。
+        out["moved_to"] = res.get("moved_to") or "review_queue"
+        out["mutation"] = res.get("mutation")
+        out["autonomy"] = res.get("autonomy")
     # gated 是**替代落盘路径**（自行落盘/合并后直接返回终态、不跑 after 链），故
     # 一跳同步传播须在此单独触发——否则 MERGE 类覆写会漏传下游（非对称边界，
     # 与 `_after_trust` 注释互指）。
@@ -592,6 +599,89 @@ def _executor(ctx):
     return out
 
 
+# ---- 三档自治闸（设计 v0.2 §三 · 批次②） ----------------------------------
+
+#: 改写单要复现「原动作」所需的载荷键（**写链 payload 白名单**）：变更单裁决
+#: accept 时按此重放 cg.add，使「直接写」与「出单→确认→写」两条路径落盘的
+#: 节点 fm 等价（issue50-c F1 的同一教训：入队时丢声明 = 两条路径元数据不等价）。
+#: `sensitivity`/`layer` 不在列（各自有专属槽：rec.sensitivity / rec.layer）；
+#: `override` 在列（受保护节点的覆写授权是原动作的一部分，不能替调用方补）。
+_AUTONOMY_META_KEYS = ("tags", "condition_space", "verification_basis",
+                       "non_applicable_conditions", "derived_from", "relation",
+                       "depends_on", "valid_from", "valid_until",
+                       "verification_state", "importance", "importance_source",
+                       "override")
+
+
+# 生效条件：ctx 的 a/cg/nid 就绪时以 forgetting.prior_node 判「同 id 已存在」（存在=C 改写、不存在=A 新增）并交 autonomy_modes.decide 判定——ALLOW 返回 None 放行（与改动前同一条链）；FORBID 返回 ok=False/moved_to="autonomy_forbidden" 的终态（fail-closed，不落盘、不出单）；CONFIRM 经 autonomy_modes.propose_mutation 出变更单（复用既有 propose 单点）并返回 ok=True/committed=False/moved_to="review_queue" 的终态（**不落盘**）；
+def _gate_autonomy(ctx):
+    """档位闸：`cg(op=write)` 对**既有 node_id 的覆写**（C 改写）在变更确认档出单。
+
+    位置（设计 §三 硬约束②「纯加严」）：before 链**末位**——audit / consistency
+    / gated 三道既有资格闸全部放行之后、链尾执行器落盘之前。故：
+      · 档位**不参与**资格判定（内容政策/冲突/限流/遗忘裁决一律照旧先跑）；
+      · 档位**不放宽**任何既有判据（放行分支就是「返回 None」= 原链原样）；
+      · 覆写面的其余资格闸（层闸 + 写保护闸 + 降级闸）住在 `cg.add` 内部，
+        故出单**之前**先经 `cg.write_qualify`（同一批 protect 单点，只判不写）
+        跑一遍——受保护/越权覆写照旧当场被拒，不会变成「静默入队」。
+
+    动作类判定：`forgetting.prior_node` 同 id 存在 ⇒ **C 改写**；不存在 ⇒
+    **A 新增**（A 在缺省档与会话档都放行，只有计划档会 fail-closed 拦下——
+    设计 §三「计划外零变更」）。判据复用既有单点，不另写一份存在性判据。
+
+    不落盘的边界（如实）：`gated=true` 的写入在上游 `_gate_gated` 已是**替代
+    执行路径**（自行落盘/合并后直接返回终态、不走本闸），故本闸不覆盖它；
+    该面的档位判定由 `remember_gated` 自己的单点承担——**C 改写 / A 新增**在
+    `MdCGOS._autonomy_gate_rewrite`、**B 合并**在 `MdCGOS._autonomy_gate_merge`。
+    本闸只覆盖走链尾执行器的直写（`gated=false` 的 `cg(op=write)`）。
+    三处共用同一张矩阵（`autonomy_modes.decide`），不各写一份判据。
+
+    订正记录（2026-10-02，补强批次）：本句此前写「其覆写/合并分别由
+    `remember_gated` 的 C/B 判定覆盖」——B 合并确已覆盖，**C 覆写当时没有**
+    （该分支直调 `self.add`），属失实陈述（独立复核发现 1 的代码根据）。
+    补强批次在 `_autonomy_gate_rewrite` 落码后本句才与实现逐句一致。
+    """
+    a = ctx["a"]
+    cg = ctx["cg"]
+    nid = ctx["nid"]
+    from . import autonomy_modes as _am
+    from . import forgetting as _forgetting
+    prior = _forgetting.prior_node(cg, nid)
+    action = _am.C_REWRITE if prior is not None else _am.A_ADD
+    if prior is not None:
+        # 资格在先（纯加严）：覆写的层闸/写保护闸住在 `cg.add` 内部，若档位闸
+        # 先出单，一次本该 `AccessDenied`/`ProtectionError` 的覆写会变成静默入队
+        # ——那是放宽既有判据。故按**同一批 protect 单点**先跑一遍资格（只判不写）。
+        cg.write_qualify(nid, target_layer=a.get("layer"),
+                         override=bool(a.get("override")),
+                         actor=getattr(cg, "actor", None))
+    dec = _am.decide(action)
+    if dec["decision"] == _am.ALLOW:
+        return None
+    # 档位判定读数（**不参与资格判定**，只如实透出档位/动作类/判定）
+    _aut = {"mode": dec["mode"], "action": dec["action"],
+            "action_name": dec["action_name"], "decision": dec["decision"]}
+    if dec["decision"] == _am.FORBID:
+        return {"ok": False, "id": nid, "committed": False,
+                "moved_to": "autonomy_forbidden", "error": "autonomy_forbid",
+                "autonomy": _aut, "verdict": ctx.get("verdict"),
+                "hint": dec["hint"]}
+    meta = {k: a[k] for k in _AUTONOMY_META_KEYS if a.get(k) is not None}
+    pay = _am.mutation_payload(
+        action, nid, after=a.get("content", ""),
+        reason="写链覆写（cg(op=write) 对既有节点 %s 的 %s）"
+               % (nid, _am.ACTION_NAMES[action]),
+        primitive="add", meta=meta)
+    pr = _am.propose_mutation(cg, action, nid, payload=pay,
+                              layer=a.get("layer") or "knowledge",
+                              sensitivity=a.get("sensitivity"), info=True)
+    return {"ok": True, "id": nid, "pid": pr["pid"], "committed": False,
+            "moved_to": "review_queue", "autonomy": _aut, "mutation": pay,
+            "verdict": ctx.get("verdict"),
+            "hint": ("%s 本次未落盘：变更单已入审核队列（pid=%s，目标 %s）。"
+                     % (dec["hint"], pr["pid"], nid))}
+
+
 # 生效条件：value 传入即无条件延迟导入并转调 mcp_server._split_ids 后原样返回其结果（本符号无自身分支）；
 def _split_ids(value):
     # 与 mcp_server._split_ids 同源（延迟导入，单一真源）
@@ -612,9 +702,12 @@ def install_default_gates(pipe):
 
     链序（2026-09-19 起）：
         before = linkref(解析) → deps(依赖声明) → audit → consistency → gated
-                 → 链尾执行器
+                 → autonomy(档位) → 链尾执行器
         after  = linkref(建边) → trust(一跳传播)
 
+    autonomy（三档自治批次②）恒在最末：档位判定只决定「立即落」还是「出变更
+    单」，必须晚于全部既有资格闸（纯加严，设计 §三 硬约束②）。
+
     linkref 置于链首的理由：正文引用解析是**纯读、无副作用**，且其结果必须
     先于任何短路闸写入 ctx，供 after 链消费。短路闸（REJECT/DEFER/gated）
     返回终态时 `execute` 不跑 after 链，故未落盘的写入不会建边——语义正确。
@@ -638,6 +731,12 @@ def install_default_gates(pipe):
     pipe.register_before("audit", _gate_audit)
     pipe.register_before("consistency", _gate_consistency)
     pipe.register_before("gated", _gate_gated)
+    # 档位闸**链尾**（三档自治批次②，设计 §三 硬约束②）：既有资格闸全部通过
+    # 之后、链尾执行器落盘之前——档位只决定「立即落」还是「出变更单」，不参与
+    # 资格判定。gated 分支是替代执行路径（自行落盘并已 return），其合并/覆写由
+    # remember_gated 的 B/C 判定覆盖（`_autonomy_gate_merge` / 补强批次的
+    # `_autonomy_gate_rewrite`），故本闸登记在 gated 之后即可。
+    pipe.register_before("autonomy", _gate_autonomy)
     pipe.register_after("linkref", linkref.after_hook())
     pipe.register_after("trust", _after_trust)
     return pipe

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@furongjun1999/dsh-memory",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "灵枢（Lingshu·líng shū）DeepSeek Harness 插件：完整大脑——长期记忆/知识飞轮/自我认知/递归反思接入 DSH，对话自动沉淀进 md_cg 认知图（md 文档）",
   "type": "module",
   "main": "lib/index.js",

package/skills/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "lingshu-skills",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "灵枢（AEIS）自我认知技能包——白箱条件化知识（Agent Skills 兼容导出）。本质是灵枢了解自身的工具：每个技能描述灵枢在什么条件下能做什么、怎么执行、克制什么（KCCS 四要素），由条件路由图精确路由，由灵枢 MCP 工具执行验证（物理基底）。",
   "author": {
     "name": "灵枢（AEIS）· CommonTrustProtocol"