@furongjun1999/dsh-memory 0.4.5 → 0.4.7

package/md_cg/semantic/zh_en_atoms.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""灵枢 · 原子级中英序列化器
+
+语义原子（中文）→ 标准英文原子序列
+不是翻译，是原子的一对一映射。每个中文原子有唯一英文原子对应。
+
+用法：
+    from zh_en_atoms import serialize
+    result = serialize("我昨天吃牛肉")
+    # → "i yester day eat cow meat"
+
+    result = serialize("灵枢记忆库")
+    # → "soul hub memory store"
+"""
+import re
+
+ZH_EN = {}
+
+def M(zh, en):
+    ZH_EN[zh] = en
+
+# ---- 代词 ----
+for zh, en in [("我","i"),("你","you"),("他","he"),("她","she"),("我们","we"),("他们","they")]:
+    M(zh, en)
+
+# ---- 动作（基形，无时态）----
+for zh, en in [("吃","eat"),("喝","drink"),("看","see"),("听","hear"),("读","read"),
+               ("写","write"),("走","walk"),("跑","run"),("飞","fly"),("来","come"),
+               ("去","go"),("买","buy"),("卖","sell"),("说","speak"),("想","think"),
+               ("开","open"),("关","close"),("睡","sleep"),("爱","love"),("做","do"),
+               ("学","study"),("教","teach"),("用","use"),("找","find"),("给","give")]:
+    M(zh, en)
+
+# ---- 时间（复合→原子序列）----
+M("昨天", "yester day"); M("今天", "to day"); M("明天", "next day"); M("现在", "now")
+for zh, en in [("年","year"),("月","month"),("日","day"),("天","day"),("周","week"),
+               ("时","hour"),("分","minute"),("秒","second"),
+               ("春","spring"),("夏","summer"),("秋","autumn"),("冬","winter"),
+               ("早","morning"),("晚","evening"),("夜","night")]:
+    M(zh, en)
+
+# ---- 数 ----
+for zh, en in [("一","one"),("二","two"),("三","three"),("四","four"),("五","five"),
+               ("六","six"),("七","seven"),("八","eight"),("九","nine"),("十","ten"),
+               ("百","hundred"),("千","thousand"),("零","zero")]:
+    M(zh, en)
+
+# ---- 自然 ----
+for zh, en in [("牛","cow"),("猪","pig"),("羊","sheep"),("鸡","chicken"),("鸭","duck"),
+               ("马","horse"),("狗","dog"),("猫","cat"),("鱼","fish"),("鸟","bird"),
+               ("肉","meat"),("奶","milk"),("蛋","egg"),("水","water"),("火","fire"),
+               ("山","mountain"),("海","sea"),("河","river"),("树","tree"),("花","flower"),
+               ("光","light"),("电","electric"),("风","wind"),("雨","rain"),("雪","snow"),
+               ("星","star"),("石","stone"),("云","cloud"),("土","soil"),("金","metal")]:
+    M(zh, en)
+
+# ---- 身体 ----
+for zh, en in [("头","head"),("手","hand"),("脚","foot"),("眼","eye"),("口","mouth"),
+               ("耳","ear"),("鼻","nose"),("心","heart"),("血","blood"),("骨","bone"),("皮","skin")]:
+    M(zh, en)
+
+# ---- 亲属 ----
+for zh, en in [("父","father"),("母","mother"),("兄","elder_brother"),("弟","younger_brother"),
+               ("姐","elder_sister"),("妹","younger_sister"),("儿","son"),("女","daughter")]:
+    M(zh, en)
+
+# ---- 器物 ----
+for zh, en in [("车","vehicle"),("船","boat"),("机","machine"),("刀","knife"),("笔","pen"),
+               ("书","book"),("门","door"),("窗","window"),("桥","bridge"),("路","road"),
+               ("池","cell")]:
+    M(zh, en)
+
+# ---- 形容词 ----
+for zh, en in [("大","big"),("小","small"),("高","high"),("低","low"),("新","new"),("旧","old"),
+               ("好","good"),("坏","bad"),("长","long"),("短","short"),("快","fast"),("慢","slow"),
+               ("热","hot"),("冷","cold"),("多","many"),("少","few"),("重","heavy"),("轻","light"),
+               ("深","deep"),("真","true")]:
+    M(zh, en)
+
+# ---- 抽象 ----
+for zh, en in [("知识","knowledge"),("工作","work"),("纪律","discipline"),("记忆","memory"),
+               ("认知","cognition"),("力","force"),("气","gas"),("道","way"),("理","principle"),
+               ("文","text"),("化","transform"),("话","speech"),("影","shadow"),("音","sound"),
+               ("名","name"),("国","country"),("家","home"),("城","city"),("民","people"),
+               ("字","word"),("灵","soul"),("枢","hub"),("数","number"),("物","thing"),
+               ("地","earth"),("人","person"),("脑","brain"),("视","view"),("脏","organ"),
+               ("汽","gas"),("魂","soul")]:
+    M(zh, en)
+
+# ---- 复合词（→ 原子序列）----
+for zh, en in [("电脑","electric brain"),("电话","electric speech"),("电视","electric view"),
+               ("电影","electric shadow"),("电池","electric cell"),("火车","fire vehicle"),
+               ("汽车","gas vehicle"),("飞机","fly machine"),("手机","hand machine"),
+               ("牛肉","cow meat"),("猪肉","pig meat"),("羊肉","sheep meat"),
+               ("鸡肉","chicken meat"),("牛奶","cow milk"),("鸡蛋","chicken egg"),
+               ("火山","fire mountain"),("海水","sea water"),("月光","moon light"),
+               ("雪山","snow mountain"),("知识图谱","knowledge graph map"),
+               ("认知图","cognition graph"),("工作纪律","work discipline"),
+               ("记忆库","memory store"),("灵枢","soul hub"),
+               ("数学","number study"),("化学","transform study"),
+               ("物理学","thing principle study"),("生物学","living thing study"),
+               ("地理学","earth principle study"),("热力学","heat force study")]:
+    M(zh, en)
+
+# ---- 贪心最长匹配 ----
+_sorted = sorted(ZH_EN.keys(), key=len, reverse=True)
+
+def segment(text):
+    """贪心最长匹配：文本 → 原子列表"""
+    result = []
+    pos = 0
+    while pos < len(text):
+        matched = False
+        for key in _sorted:
+            if text.startswith(key, pos):
+                result.append(key)
+                pos += len(key)
+                matched = True
+                break
+        if not matched:
+            result.append(text[pos])
+            pos += 1
+    return result
+
+
+def serialize(text):
+    """中文文本 → 标准英文原子序列"""
+    return " ".join(ZH_EN.get(a, "[" + a + "]") for a in segment(text))
+
+
+if __name__ == "__main__":
+    import sys
+    q = " ".join(sys.argv[1:]) if len(sys.argv) > 1 else "灵枢记忆库"
+    print("中文:", q)
+    print("标准英文:", serialize(q))

package/md_cg/sustain.py

@@ -39,6 +39,14 @@
    报为 `provenance_dangling`（severity=info、**无自动修复**）——关系事实的去留由人
    处置，不给「自动删边」这种会篡改历史的动作。
 
+⑥ 对端挂了谁来救？—— **互维闭环（P-T-110 最小投影 · #30）**
+   两个灵枢互为维生系统：`mutual_watch` 读对端心跳 → 失联则**幂等拉起**
+   （pid 探活防误判 + 冷却防风暴）→ **验戳新鲜闭合**：拉起后必须轮询到
+   对端戳变新才算救活，否则如实报 `mutual_peer_unresponsive`——这正是
+   mutual-sustain-loop v1.1 §7 的 W4 部署教训（「拉起后应验证对端戳新鲜度，
+   当时缺该校验」）的机制化：不假装成功。`mutual_status` 做双亡检测：
+   自己也失联时互维本身不可信 → 显式上报外部告警语义，绝不静默。
+
 零第三方依赖。
 """
 from __future__ import annotations
@@ -60,6 +68,7 @@ DEFAULT_BEAT_INTERVAL = 600.0     # 心跳间隔 10min（对齐 mutual-sustain-l
 DEFAULT_HEAL_INTERVAL = 300.0     # 自愈巡检 5min
 DEFAULT_SCRUB_INTERVAL = 3600.0   # 记忆自净（抽查/去污染/校准）1h
 DEFAULT_EVOLVE_INTERVAL = 7200.0  # 演化巡检（固化/重要性候选盘点）2h；只读
+DEFAULT_TIDY_INTERVAL = 21600.0   # 整理巡检（contextual 同构组聚合）6h
 DEFAULT_WARN_FACTOR = 2.5         # 2.5× 心跳间隔 → 警告
 DEFAULT_DEAD_FACTOR = 3.5         # 3.5× → 失联
 DEFAULT_WORKING_FACTOR = 2.0      # 任务执行中阈值 ×2
@@ -154,6 +163,155 @@ def peers(d: str = None):
     return out
 
 
+# --------------------------------------------------------------------------
+# 互维闭环（P-T-110 最小投影 · #30）
+# --------------------------------------------------------------------------
+
+DEFAULT_RESTART_COOLDOWN = 300.0   # 同一对端两次拉起的最小间隔（防风暴）
+DEFAULT_FRESH_TIMEOUT = 60.0       # 拉起后等待对端戳变新鲜的窗口
+
+
+def pid_alive(pid) -> bool:
+    """进程探活（零第三方依赖）：Windows=OpenProcess+WaitForSingleObject；
+    posix=os.kill(pid,0)。pid 无效 / 已退出 / 权限外 → False（诚实）。"""
+    try:
+        pid = int(pid)
+    except (TypeError, ValueError):
+        return False
+    if pid <= 0:
+        return False
+    if os.name == "nt":
+        import ctypes
+        SYNCHRONIZE = 0x00100000
+        WAIT_TIMEOUT = 0x00000102
+        k32 = ctypes.windll.kernel32
+        h = k32.OpenProcess(SYNCHRONIZE, False, pid)
+        if not h:
+            return False
+        try:
+            return k32.WaitForSingleObject(h, 0) == WAIT_TIMEOUT
+        finally:
+            k32.CloseHandle(h)
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False
+
+
+def _default_spawner(cmd):
+    """分离式拉起：argv 列表、不经 shell、输出弃置（Windows 完全脱离父控制台）。"""
+    import subprocess
+    kw = {}
+    if os.name == "nt":
+        kw["creationflags"] = (0x00000008 | 0x00000200)  # DETACHED|NEW_GROUP
+    return subprocess.Popen(cmd, stdout=subprocess.DEVNULL,
+                            stderr=subprocess.DEVNULL, **kw)
+
+
+def _last_mutual_restart(root: str, peer: str) -> float:
+    """_sustain.jsonl 里该对端最近一次互维拉起时间（无 → 0.0，审计即状态）。"""
+    last = 0.0
+    try:
+        with open(os.path.join(root, SUSTAIN_LOG), encoding="utf-8") as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                except ValueError:
+                    continue
+                if (r.get("op") == "mutual" and r.get("action") == "restart"
+                        and str(r.get("detail") or "").startswith(str(peer))):
+                    last = max(last, float(r.get("t") or 0.0))
+    except OSError:
+        pass
+    return last
+
+
+def mutual_watch(cg, peer: str, *, restart_cmd=None, d: str = None,
+                 interval: float = DEFAULT_BEAT_INTERVAL,
+                 restart_cooldown: float = DEFAULT_RESTART_COOLDOWN,
+                 fresh_timeout: float = DEFAULT_FRESH_TIMEOUT, poll: float = 0.5,
+                 spawner=None) -> dict:
+    """互维守护（单侧一次检查）：读对端心跳 → 失联则幂等拉起 → 验戳闭合。
+
+    判定序（P-T-110 语义，全链路审计进 _sustain.jsonl）：
+      ok/warning        → 不动作；
+      dead/absent：
+        ① 误判防护：戳里 pid 仍存活 → `alive_but_stale`（长任务未标
+           task_running？）——**不拉起**，不杀活进程；
+        ② 冷却：距上次拉起 < restart_cooldown → `restart_cooldown`；
+        ③ 无 restart_cmd → `dead_unhandled`（ok=False，诚实上报没手段，
+           不假装能救）；
+        ④ 拉起（spawner 或分离式 Popen）→ **验戳新鲜闭合**（W4 补丁）：
+           轮询对端戳 ts 超过拉起前值才算 `recovered=True`；超时 →
+           `recovered=False` + `mutual_peer_unresponsive`——对端拉起后
+           互维未激活（v1.1 §7 的 W4 场景）会被显式暴露，不假装成功。
+    """
+    rec = read_stamp(peer, d)
+    state = (judge(rec["age"], interval=interval,
+                   task_running=bool(rec.get("task_running")))
+             if rec else "absent")
+    out = {"ok": True, "peer": peer, "state": state, "t": time.time(),
+           "action": "none", "recovered": None}
+    if state in ("ok", "warning"):
+        return out
+    if rec and pid_alive(rec.get("pid")):
+        out.update(action="alive_but_stale",
+                   note="对端进程存活但戳陈旧（长任务未标 task_running？）——不拉起")
+        _audit(cg.root, "mutual", "alive_but_stale", peer)
+        return out
+    last = _last_mutual_restart(cg.root, peer)
+    if last and (time.time() - last) < restart_cooldown:
+        out.update(action="restart_cooldown",
+                   note="距上次拉起 %.1fs，冷却中" % (time.time() - last))
+        return out
+    if not restart_cmd:
+        out.update(ok=False, action="dead_unhandled",
+                   note="对端失联且未提供 restart_cmd——诚实上报，不假装能救")
+        _audit(cg.root, "mutual", "dead_unhandled", peer)
+        return out
+    before_ts = float((rec or {}).get("ts") or 0.0)
+    spawn = spawner or _default_spawner
+    try:
+        spawn(restart_cmd)
+    except Exception as e:                                 # noqa: BLE001
+        out.update(ok=False, action="restart_error",
+                   error="%s: %s" % (type(e).__name__, e))
+        _audit(cg.root, "mutual", "restart_error", peer)
+        return out
+    deadline = time.time() + fresh_timeout
+    while time.time() < deadline:
+        r2 = read_stamp(peer, d)
+        if r2 and float(r2.get("ts") or 0.0) > before_ts:
+            out.update(action="restarted", recovered=True, fresh_ts=r2.get("ts"))
+            _audit(cg.root, "mutual", "restart", peer)
+            return out
+        time.sleep(poll)
+    out.update(ok=False, action="restarted", recovered=False,
+               note=("拉起命令已执行但对端戳未更新（互维未激活？）——"
+                     "mutual_peer_unresponsive，不假装成功"))
+    _audit(cg.root, "mutual", "restart_unverified", peer)
+    return out
+
+
+def mutual_status(cg, peer: str, *, d: str = None, name: str = "md_cg",
+                  interval: float = DEFAULT_BEAT_INTERVAL) -> dict:
+    """互维状态 + 双亡检测：自己也失联时互维不可信 → 显式外部告警语义。"""
+    mine, theirs = read_stamp(name, d), read_stamp(peer, d)
+    my_state = (judge(mine["age"], interval=interval,
+                      task_running=bool(mine.get("task_running")))
+                if mine else "absent")
+    peer_state = (judge(theirs["age"], interval=interval,
+                        task_running=bool(theirs.get("task_running")))
+                  if theirs else "absent")
+    dead = ("dead", "absent")
+    both_dead = my_state in dead and peer_state in dead
+    return {"ok": not both_dead, "self": my_state, "peer": peer_state,
+            "both_dead": both_dead,
+            "note": ("双向同时失联：互维本身已不可信，须外部告警（P-T-110 风险表）"
+                     if both_dead else "互维链路可用")}
+
+
 # --------------------------------------------------------------------------
 # 诊断（只读）
 # --------------------------------------------------------------------------
@@ -612,7 +770,9 @@ class SustainLoop:
                  scrub_interval: float = DEFAULT_SCRUB_INTERVAL,
                  auto_scrub: bool = False,
                  evolve_interval: float = DEFAULT_EVOLVE_INTERVAL,
-                 auto_evolve: bool = False):
+                 auto_evolve: bool = False,
+                 tidy_interval: float = DEFAULT_TIDY_INTERVAL,
+                 auto_tidy: bool = False):
         self.cg = cg
         self.name = name
         self.beat_interval = float(beat_interval)
@@ -624,6 +784,8 @@ class SustainLoop:
         self.auto_scrub = bool(auto_scrub)
         self.evolve_interval = float(evolve_interval)
         self.auto_evolve = bool(auto_evolve)
+        self.tidy_interval = float(tidy_interval)
+        self.auto_tidy = bool(auto_tidy)
         self.task_running = False
         self.beats = 0
         self.last_beat = None
@@ -633,6 +795,8 @@ class SustainLoop:
         self.scrubs = []
         self.last_evolve = None
         self.evolves = []
+        self.last_tidy = None
+        self.tidys = []
         self._started_at = None
         self._th = None
         self._stop = threading.Event()
@@ -677,6 +841,7 @@ class SustainLoop:
         next_heal = time.time() + self.heal_interval
         next_scrub = time.time() + self.scrub_interval
         next_evolve = time.time() + self.evolve_interval
+        next_tidy = time.time() + self.tidy_interval
         while not self._stop.is_set():
             now = time.time()
             if now >= next_beat:
@@ -703,8 +868,33 @@ class SustainLoop:
                 except Exception:
                     pass                       # 演化巡检失败不中断常驻
                 next_evolve = now + self.evolve_interval
+            if now >= next_tidy:
+                try:
+                    self._tick_tidy()
+                except Exception:
+                    pass                       # 整理巡检失败不中断常驻
+                next_tidy = now + self.tidy_interval
             self._stop.wait(_POLL)
 
+    def _tick_tidy(self):
+        """整理巡检（contextual 流水治理·读侧）：同构组聚合 + 成员降权。
+
+        确定性动作、永不删节点；`auto_tidy=False`（默认）只盘点不落盘。
+        治理对象：单日批次流水（「批次247收官记忆」×163 那类同模板写入）
+        —— 写入侧限流（writelimit.check）拦增量，本巡检收敛存量。
+        """
+        from . import writelimit
+        r = writelimit.tidy_contextual(self.cg, apply=self.auto_tidy,
+                                       actor="sustain_tidy")
+        rec = {"t": r["t"], "scanned": r["scanned"], "groups": r["groups"],
+               "members": r["members"],
+               "applied_count": r.get("applied_count", 0),
+               "auto_tidy": self.auto_tidy}
+        self.last_tidy = rec
+        with self._lock:
+            self.tidys.append(rec)
+            self.tidys = self.tidys[-20:]
+
     def _tick_evolve(self):
         """演化巡检（G7）：盘点固化/重要性候选 —— 让「有能力」变成「有驱动」。
 
@@ -788,6 +978,8 @@ class SustainLoop:
                 "auto_evolve": self.auto_evolve,
                 "last_evolve": self.last_evolve,
                 "evolves": self.evolves[-5:],
+                "last_tidy": self.last_tidy,
+                "tidys": self.tidys[-5:],
                 "peers": peers(self.d),
                 "sessions": self.ledger.summary()}
 

package/md_cg/test_autonomy.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+"""信息差驱动自主探索闭环（autonomy.explore）验证。
+
+断言面：
+  ① 无信号诚实：空反思日志 → 零提案、零步骤（不编造探索价值）
+  ② 信号聚合排序：|d2| 加速度 + BLINDSPOT/DEFER 计数 → 高信息差排前，
+     提案携带证据明细
+  ③ 全链路：提案 → learn_blindspots 五态终判 → 留痕 _explore.jsonl
+  ④ 幂等：重复 explore 终态一致、gap 回写不重复（gap_<sha1(bid)> 幂等）
+
+运行：python -m md_cg.test_autonomy
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+
+from . import autonomy
+from .fsutil import append_jsonl
+from .mdcos import MdCGOS
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+def _sig(cg, t, query, d2, states):
+    append_jsonl(cg.reflection_log,
+                 {"t": t, "query": query, "d_prev": 1.0, "d_curr": 1.0,
+                  "d_delta": 0.0, "d2": d2, "states": states,
+                  "n_results": 3, "feedback": None})
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_autonomy_")
+    try:
+        root = os.path.join(tmp, "root")
+        os.makedirs(root, exist_ok=True)
+        cg = MdCGOS(root)
+
+        # ---------- ① 无信号诚实 ----------
+        pr = autonomy.proposals(cg)
+        ok(pr["ok"] and not pr["proposals"] and pr["n_signals"] == 0,
+           "①空反思日志 → 零提案（不编造探索价值）")
+        ex = autonomy.explore(cg)
+        ok(ex["ok"] and not ex["steps"],
+           "①b空信号 explore → 零步骤、ok=True")
+
+        # ---------- ② 信号聚合排序 ----------
+        _sig(cg, 1.0, "反应堆冷却方案", 0.9, {"BLINDSPOT": 2})
+        _sig(cg, 2.0, "反应堆冷却方案", 0.7, {"BLINDSPOT": 1})
+        _sig(cg, 3.0, "周末菜单", 0.05, {})
+        pr = autonomy.proposals(cg, limit=3)
+        ps = pr["proposals"]
+        ok(pr["n_signals"] == 2 and len(ps) == 2,
+           "②两查询聚类（同 query 归一）、n_signals=2")
+        ok(ps[0]["query"] == "反应堆冷却方案" and ps[0]["score"] > ps[1]["score"],
+           "②b高信息差排前（Σ|d2|=1.6 + BLINDSPOT×3 ＞ 0.05）")
+        ok("d2" in ps[0]["reason"] and "BLINDSPOT" in ps[0]["reason"],
+           "②c提案携带证据明细（可审计）")
+
+        # ---------- ③ 全链路：提案 → 五态终判 → 留痕 ----------
+        cg.add("k1", "# 功能名：反应堆冷却知识\n"
+                     "# 生效条件：问反应堆冷却方案\n"
+                     "# 子功能：知识片段\n"
+                     "# 执行：陈述知识\n"
+                     "# 验证方式：test\n"
+                     "# 不适用条件：无\n"
+                     "反应堆冷却方案概述。\n",
+               layer="knowledge", verification_basis="test")
+        ex = autonomy.explore(cg, apply=True, actor="test")
+        st0 = ex["steps"][0] if ex["steps"] else {}
+        ok(bool(ex["steps"]) and st0.get("terminal") in
+           ("unknowable", "no_anchor", "unresolved", "carried", "resolved"),
+           f"③提案进入五态终判（terminal={st0.get('terminal')}，"
+           f"routes={st0.get('routes')}）")
+        if st0.get("terminal") in ("carried", "unresolved"):
+            ok(bool(st0.get("written")),
+               f"③b carried/unresolved 已回写 gap_hint（{st0.get('written')}）")
+        else:
+            ok(True, f"③b终态={st0.get('terminal')}：按诚实原则无需回写"
+                     "（resolved=已有可判定终点；no_anchor=先补锚点）")
+        ok(os.path.exists(autonomy._explore_log_path(cg)),
+           "③c探索留痕 _explore.jsonl 落盘")
+
+        # ---------- ④ 幂等 ----------
+        ex2 = autonomy.explore(cg, apply=True, actor="test")
+        st2 = ex2["steps"][0] if ex2["steps"] else {}
+        ok(st2.get("terminal") == st0.get("terminal"),
+           "④重复 explore 终态一致（判定确定性）")
+        if st0.get("terminal") in ("carried", "unresolved"):
+            ok(not st2.get("written"),
+               "④b gap 回写幂等（第二次 written=None，节点已存在）")
+        else:
+            ok(True, "④b本终态无回写动作，幂等性由判定确定性保证")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print(f"\nautonomy: {PASS} passed, {FAIL} failed")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    raise SystemExit(1 if FAIL else 0)
+
+
+if __name__ == "__main__":
+    main()