@furongjun1999/dsh-memory 0.6.1 → 0.7.1

package/md_cg/test_unify_scope.py

@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*-
+"""统一归一层作用域收窄守卫（2026-09-30 使用者裁定）
+
+口径：`semantic/unify.py::unify_query` **只对英文内容做翻译归一，中文内容
+原样不动**——query 按中文段/非中文段切开，中文段逐字保留、绝不送 segment。
+旧口径「含任一 ASCII 字母即整条归一」把中夹英 query 的中文部分逐字切开
+（「自我接纳」→「自 我 接 纳」），本件钉住收窄后的语义。
+
+**开关前提**：归一层缺省**关**（2026-09-30 使用者裁定，唯一开态 = 显式
+`MDCG_UNIFY_QUERY=1`）；本件第 1 节钉三态，其后各节一律**显式开**下跑。
+缺省态的三态与两侧一致性守卫见 `md_cg/test_unify_default_off.py`。
+
+两侧同源：期望值取自 `md_cg/semantic/unify_fixture.json`——Rust 侧
+`rust/src/atoms.rs::tests::unify_mixed_fixture_matches_python` 用 include_str!
+嵌入**同一份**文件；任一侧漂移即红（两侧逐位相同）。
+
+跑法：python -X utf8 -m md_cg.test_unify_scope
+"""
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if HERE not in sys.path:
+    sys.path.insert(0, HERE)
+
+from md_cg.semantic.canonical import is_zh_char      # noqa: E402
+from md_cg.semantic.unify import unify_on, unify_query  # noqa: E402
+
+FIXTURE = os.path.join(HERE, "md_cg", "semantic", "unify_fixture.json")
+
+N = 0
+BAD = []
+
+
+# 生效条件：单参 cond 为真值判定、msg 为说明串；恒累加计数 N，cond 为假时把 msg 记入模块级 BAD（**不中断**）——收集式断言使「定点变异红了几项」可数（首条即停的 assert 风格数不出红项数）。
+def ok(cond, msg):
+    global N
+    N += 1
+    if not cond:
+        BAD.append(msg)
+
+
+# 生效条件：单参 text 为任意字符串，按 canonical.is_zh_char 切出其中的中文连续段，返回保序的段列表（无中文段时为空列表）；仅供本守卫做「中文段逐字保留」的结构判据。
+def zh_runs(text):
+    """文本里的中文连续段（判据同 unify_query：canonical.is_zh_char）。"""
+    out, buf = [], []
+    for ch in text:
+        if is_zh_char(ch):
+            buf.append(ch)
+        elif buf:
+            out.append("".join(buf))
+            buf = []
+    if buf:
+        out.append("".join(buf))
+    return out
+
+
+# ---- 1 · 开关三态（2026-09-30 使用者裁定：缺省由开翻为关；唯一开态 = 显式 "1"）----
+# 本件测的是**作用域收窄**语义，故从本节之后各节必须在**显式开**（=1）下跑：
+# 缺省已关（未设即关），若不显式开，下面 3~8 节全会退化成恒真（对实现零约束力）。
+# 缺省三态守卫另立一件：md_cg/test_unify_default_off.py（两件分工不同，勿互推）。
+ok(unify_on() is False,
+   "MDCG_UNIFY_QUERY 未设即关（缺省关，2026-09-30 翻）")
+os.environ["MDCG_UNIFY_QUERY"] = "0"
+try:
+    ok(unify_on() is False, "=0 显式关")
+    for t in ("I eat beef yesterday", "领养 LGBTQ 群体", "自我接纳",
+              "  beef 报告  ", "2024 报告"):
+        ok(unify_query(t) == t, "开关关：一律原样返回 %r" % t)
+finally:
+    os.environ.pop("MDCG_UNIFY_QUERY", None)
+os.environ["MDCG_UNIFY_QUERY"] = "1"
+ok(unify_on() is True, "=1 显式开（英文对照路要用）——本件余下各节的运行前提")
+
+# ---- 2 · 空/None/无 ASCII 字母：原样返回（未 strip 的入参）----
+ok(unify_query(None) is None, "None 原样")
+ok(unify_query("") == "", "空串原样")
+ok(unify_query("  自我接纳  ") == "  自我接纳  ",
+   "纯中文（无 ASCII 字母）原样返回入参本身（不 strip）")
+ok(unify_query("2024 报告") == "2024 报告", "纯中文+数字（无字母）原样")
+ok(unify_query("，。") == "，。", "纯标点（无字母）原样")
+
+# ---- 3 · 纯英文仍翻译（收窄不得关掉英文链路）----
+ok(unify_query("I eat beef yesterday") == "我 吃 牛肉 昨天",
+   "纯英文仍归一：%r" % unify_query("I eat beef yesterday"))
+ok(unify_query("wrote") == "写", "纯英文时态还原仍生效")
+
+# ---- 4 · 纯中文原样（旧口径会被逐字切开）----
+for t, why in (("自我接纳", "旧口径「自 我 接 纳」"),
+               ("慈善跑", "旧口径「慈 善 跑」"),
+               ("蜂群调度 依赖门禁", "旧口径逐字切开")):
+    ok(unify_query(t) == t, "纯中文原样（%s）：%r" % (why, t))
+
+# ---- 5 · fixture 逐位对拍（两侧同源：Rust 侧嵌同一份文件）----
+with open(FIXTURE, encoding="utf-8") as f:
+    FX = json.load(f)["cases"]
+ok(len(FX) >= 12, "fixture 用例数 >= 12：%d" % len(FX))
+for c in FX:
+    got = unify_query(c["in"])
+    ok(got == c["out"],
+       "fixture 逐位不符 [%s] in=%r got=%r want=%r"
+       % (c["name"], c["in"], got, c["out"]))
+
+# ---- 5b · 单侧钉：任务原型例（Python 侧形态）----
+# 这两例**不入共享 fixture**：非中文段是未登录的**大写**词（LGBTQ），两侧对
+# 「未命中词表的大写词」存在**既有**非对称（Python 保留原大小写 / Rust 经
+# normalize_en 一律 lower 化——用 rust 单测实测 `领养 lgbtq 群体` 取证，
+# 2026-09-30），故两侧钉不出同一期望值。此非本次收窄引入，也非本次范围；
+# 但它是端到端（Python 侧）实际生效的形态，故在此单侧钉死。
+for t in ("领养 LGBTQ 群体 支持 包容", "领养 机构 LGBTQ 群体 支持 包容"):
+    ok(unify_query(t) == t, "中夹英原型例：中文段逐字保留、英文片段原样：%r" % t)
+
+# ---- 6 · 结构判据（对**实现产物**断言）：混合 query 的中文段逐字保留 ----
+# 2026-09-30 清理批次（甲2）修假守卫：本节此前比的是 fixture 的**期望值**
+# （`run in c["out"]`——拿期望比期望），对实现零约束力：做「中文段也送
+# segment」变异时本节 0 项红。现改为直接调 `unify_query` 并对**产物**断言：
+# 中文段必须在产物里逐字出现，且其逐字切开形（`" ".join(run)`）不得出现。
+# 单字中文段（如「年」）的切开形与其本身同形，故切开判据只在 len(run) > 1
+# 时施加（否则是恒假的伪红）。
+for c in FX:
+    got = unify_query(c["in"])
+    for run in zh_runs(c["in"]):
+        ok(run in got,
+           "中文段未逐字保留（被改写）[%s] in=%r 段=%r got=%r"
+           % (c["name"], c["in"], run, got))
+        if len(run) > 1:
+            ok(" ".join(run) not in got,
+               "中文段被逐字切开（送了 segment）[%s] in=%r 段=%r got=%r"
+               % (c["name"], c["in"], run, got))
+# 原型例（任务口径原句）同样对产物断言：中文段逐字保留、英文片段不动
+for t in ("领养 LGBTQ 群体", "AI 记忆 系统", "自我接纳", "蜂群调度 依赖门禁"):
+    got = unify_query(t)
+    for run in zh_runs(t):
+        ok(run in got and " ".join(run) not in got,
+           "原型例中文段逐字保留 [%r] 段=%r got=%r" % (t, run, got))
+ok(zh_runs("领养 LGBTQ 群体") == ["领养", "群体"], "中文段抽取判据自检")
+
+# ---- 7 · 空白折叠为单空格（段内/段间）----
+ok(unify_query("  beef   报告  ") == "牛肉 报告", "前后空白+多空格折叠")
+ok(unify_query("beef\t报告") == "牛肉 报告", "制表符折叠为单空格")
+
+# ---- 8 · 异常降级为原样（不阻断检索主链路）----
+import md_cg.semantic.canonical as _cn   # noqa: E402
+_saved = _cn.query_atoms
+_cn.query_atoms = lambda _t: (_ for _ in ()).throw(RuntimeError("boom"))
+try:
+    src = "beef 报告"
+    ok(unify_query(src) == src, "链路抛异常 → 原样返回")
+finally:
+    _cn.query_atoms = _saved
+
+# ---- 9 · 中文判据边界（2026-09-30 清理批次乙2）：仅长度恰为 1 的串可为真 ----
+# 事实读数（本机实测，见清理批次回执）：留池条目 ⑥ 记「`is_zh_char("")` 返回
+# True」——**实测不成立**：`ZH_LO <= ch <= ZH_HI` 是链式比较，对空串即假，
+# 收紧前 `is_zh_char("")` 已返回 False。真实外溢面是**多字符串**——
+# 收紧前 `is_zh_char("中文")` 判真（首字符在区间即真）。两处消费点
+# （unify._runs / 本文件 zh_runs）均逐字符传入，故本收紧对存量行为零变更，
+# 只把判据面（长度恰为 1）钉死。
+ok(is_zh_char("") is False, "空串不是中文（判据面外）")
+ok(is_zh_char("中文") is False, "多字符串为假（首字符在区间亦然）")
+ok(is_zh_char("中a") is False, "多字符串为假（汉字+ASCII 混合）")
+ok(is_zh_char("中") is True, "单汉字为真")
+ok(is_zh_char("\u4e00") is True, "区间下界单汉字为真")
+ok(is_zh_char("\u9fff") is True, "区间上界单汉字为真")
+ok(is_zh_char("\u4dff") is False, "区间下界外单字符为假（U+4DFF）")
+ok(is_zh_char("\ua000") is False, "区间上界外单字符为假（U+A000）")
+ok(is_zh_char("a") is False, "单 ASCII 字母为假")
+# 两侧边界语义一致性：Rust `text::is_zh` 收 char，天然无空/多字符二态；
+# 本侧判据收紧后，「长度 != 1 一律 False」与「按 char 判区间」等价
+# （见 rust/src/text.rs::is_zh docstring 的边界约定段）。
+for ch in ("\u4e00", "\u9fff"):
+    ok(is_zh_char(ch) and len(ch) == 1, "单字符区间内 → 真（与 Rust is_zh 等价）%r" % ch)
+
+os.environ.pop("MDCG_UNIFY_QUERY", None)   # 归还进程环境（本件全程已显式开完）
+
+if BAD:
+    print("[test_unify_scope] FAILED %d/%d 断言：" % (len(BAD), N))
+    for b in BAD:
+        print("  - " + b)
+    raise SystemExit(1)
+print("[test_unify_scope] %d 断言全绿（fixture %d 例，两侧同源）" % (N, len(FX)))

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/whitebox_kb/aeis_core/time_core.py

@@ -7,6 +7,14 @@
 衰减率 γ 按对象配置；任何在本模块之外出现的衰减核实现
 （exp(-t/τ)、×(1-factor)、EMA 保持率）都是 bug——
 由 tools/time_core_lint.py 按 E5 口径机械化审计。
+（P3 落地：该审计器此前全仓不存在，现落在 **`md_cg/test_time_core_lint.py`**
+——`python -X utf8 -m md_cg.test_time_core_lint` 审计全仓四形态，指数核的
+**调用式 `exp(-…` 与点调用 `.exp(…)/.exp()`（Rust 写法）两种形态都入面**；
+另带登记表 + 等价性断言：`links.py` 同族半衰期（G2），以及 **Rust 读侧
+`rust/src/freshness.rs` 的指数核**（G11——从 Rust 源码抽常量与核表达式逐 Δt
+点与 `cred_factor` 对拍，因 Rust 无法被 Python 调用）。自带 `--mutate` 定点
+变异自证，其中 P4-M9 就是「把该 Rust 登记摘掉必须转红」那条。
+**不新开顶层 `tools/` 目录**：那会改 `WORKSPACE_INDEX.md` 的结构面。）
 规范依据：docs/概念钉死批_GPT四点评审_v0.1.md 钉死 3。
 """
 import math

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.6.1",
+  "version": "0.7.1",
   "description": "灵枢（Lingshu·líng shū）DeepSeek Harness 插件：完整大脑——长期记忆/知识飞轮/自我认知/递归反思接入 DSH，对话自动沉淀进 md_cg 认知图（md 文档）",
   "type": "module",
   "main": "lib/index.js",
@@ -20,6 +20,7 @@
     "lib",
     "src",
     "md_cg",
+    "utf8_boot.py",
     "data/policy.json",
     "skills",
     "README.md",
@@ -85,7 +86,7 @@
     "build": "node -e \"require('node:fs').rmSync('lib',{recursive:true,force:true})\" && tsc -p tsconfig.json",
     "test": "npm run build && node --import tsx --test \"test/*.test.ts\"",
     "prepare": "node -e \"const fs=require('fs');const tsc='node_modules/typescript/bin/tsc';fs.existsSync(tsc)?(fs.rmSync('lib',{recursive:true,force:true}),require('child_process').execFileSync(process.execPath,[tsc,'-p','tsconfig.json'],{stdio:'inherit'})):console.log('[prepare] 跳过构建：typescript 未安装（NODE_ENV=production 或 --omit=dev 会省略 devDependencies）——需要构建请用 npm install --include=dev')\"",
-    "gate": "python scripts/check_unreachable.py && python scripts/check_publish_artifact.py && python scripts/cogmap_sync.py check && python scripts/link_check.py && python scripts/workspace_index.py --check && python scripts/verify_discipline.py --allow-missing && python scripts/gate_rust_crate_test.py && python scripts/gate_rust_parity.py",
+    "gate": "python scripts/check_unreachable.py && python scripts/check_publish_artifact.py && python scripts/check_publish_smoke.py && python scripts/cogmap_sync.py check && python scripts/link_check.py && python scripts/workspace_index.py --check && python scripts/verify_discipline.py --allow-missing && python scripts/gate_rust_crate_test.py && python scripts/gate_rust_parity.py",
     "prepublishOnly": "npm run build && npm test && npm run gate"
   },
   "repository": {

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.6.1",
+  "version": "0.7.1",
   "description": "灵枢（AEIS）自我认知技能包——白箱条件化知识（Agent Skills 兼容导出）。本质是灵枢了解自身的工具：每个技能描述灵枢在什么条件下能做什么、怎么执行、克制什么（KCCS 四要素），由条件路由图精确路由，由灵枢 MCP 工具执行验证（物理基底）。",
   "author": {
     "name": "灵枢（AEIS）· CommonTrustProtocol"