@furongjun1999/dsh-memory 0.4.5 → 0.4.6

package/md_cg/protocol/md_cg_gate.proto

@@ -0,0 +1,33 @@
+// md_cg 判定层 · 可协议化闸门 v0.1
+// 来源：forgetting.py assess() 七步阶梯 · protect.py is_protected()/is_immutable()
+// 语言契约（实测，见 out/probe*.proto）：
+//   · 且/或/非 静默恒假 → 复合条件一律用嵌套 若（等效 AND）
+//   · ≥ 闭区间用「若 X 小于 t，则 <不满足>，否则 <满足>」保真
+//   · 裸赋值会被静默丢弃 → 赋值全包在 若 分支内，第 1 步顺带初始化 裁决
+//   · 变量名禁用数字后缀
+//   · 输入符号必须全部显式传入：未传=未声明（抛 NameError），而非默认为 0
+//   · check 的 statements 计数在 3 层嵌套上坍缩为 1（forgetting 单段 8 条也报 1 条），
+//     但编译指令数与运行终态均正确 —— 该计数不可用作正确性判据
+// 输入（Python 侧数值化）：重要度 冗余 新信息 来源内定 层保护 显式保护 显式不可变 自我状态
+// 输出：裁决 1=ACCEPT 2=MERGE 3=DROP 4=DEFER；保护 1/0；不可覆盖 1/0
+// 阈值：0.70 0.85 0.60 0.30 0.15（forgetting.py / protect.py 常量）
+// 语句 1-7 = 遗忘闸门（顺序即语义）；8-10 = 不可遗忘；11-14 = 不可覆盖（9=未命中哨兵）
+
+问曰：此条记忆当写否，既有自我认知可改否？
+答曰：依 forgetting 七步阶梯与 protect 三层保护裁决。
+术曰：
+1。若 重要度 小于 0.7，则 裁决 = 0，否则 裁决 = 1；
+2。若 裁决 等于 0，则 若 来源内定 大于 0.5，则 若 冗余 小于 0.6，则 裁决 = 0，否则 裁决 = 3；
+3。若 裁决 等于 0，则 若 冗余 小于 0.85，则 裁决 = 0，否则 裁决 = 2；
+4。若 裁决 等于 0，则 若 重要度 小于 0.3，则 若 冗余 小于 0.6，则 裁决 = 0，否则 裁决 = 4；
+5。若 裁决 等于 0，则 若 重要度 小于 0.3，则 裁决 = 0，否则 裁决 = 1；
+6。若 裁决 等于 0，则 若 新信息 小于 0.15，则 裁决 = 0，否则 裁决 = 1；
+7。若 裁决 等于 0，则 裁决 = 4；
+8。若 层保护 大于 0.5，则 保护 = 1，否则 保护 = 9；
+9。若 保护 等于 9，则 若 显式保护 大于 0.5，则 保护 = 1；
+10。若 保护 等于 9，则 若 重要度 小于 0.7，则 保护 = 0，否则 保护 = 1；
+11。若 自我状态 大于 0.5，则 不可覆盖 = 0，否则 不可覆盖 = 9；
+12。若 不可覆盖 等于 9，则 若 层保护 大于 0.5，则 不可覆盖 = 1；
+13。若 不可覆盖 等于 9，则 若 显式不可变 大于 0.5，则 不可覆盖 = 1；
+14。若 不可覆盖 等于 9，则 不可覆盖 = 0；
+15。止。

package/md_cg/security.py

@@ -1,235 +1,250 @@
-# -*- coding: utf-8 -*-
-"""md_cg · 进程/权限模型（记忆 OS #2）
-
-关键动机：**灵枢是开源仓库，而记忆很大一部分是私有内容**。因此权限模型必须
-支持「公开知识」与「私有记忆」的物理与逻辑隔离：
-
-  ① 物理隔离：租户（tenant）各自一个根目录。public 租户的根可落在开源仓库内，
-     private 租户的根必须落在仓库外（如 ~/.mdcg/private/）。
-  ② 逻辑隔离：每个节点带 sensitivity（public < internal < private < secret）；
-     每个调用方（Principal）带 clearance，只能读写 ≤ clearance 的节点。
-  ③ 硬规则：secret 节点对 clearance < secret 的调用方**写入即拒**（对齐 noema
-     「secret 候选自动拒绝」）；写入高于自身 clearance 的敏感度 → 拒绝。
-
-零第三方依赖。
-"""
-from __future__ import annotations
-
-import json
-import os
-import time
-import uuid
-
-SENSITIVITY_ORDER = ("public", "internal", "private", "secret")
-DEFAULT_SENSITIVITY = "internal"
-
-
-class AccessDenied(Exception):
-    """权限拒绝（读/写/管理）。"""
-
-
-def _rank(level: str) -> int:
-    try:
-        return SENSITIVITY_ORDER.index(level)
-    except ValueError:
-        raise AccessDenied(f"未知敏感度/密级：{level}") from None
-
-
-class Principal:
-    """调用方身份（一次会话一个）。
-
-    tenant        —— 租户（决定根目录）
-    actor         —— 调用者标识（写入审计）
-    clearance     —— 最高可读/可写敏感度
-    can_write     —— 是否允许写
-    can_admin     —— 是否允许管理操作（forget/restore/review_decide）
-    session       —— 会话 id（进程/会话模型：每次连接一个）
-
-    令牌扩展（由 `tokens.verify_token` 填充；直接构造时为 None = 不限制）：
-    role          —— 角色（designer/reflection/verifier/recorder/output/sustain/guest）
-    token_id      —— 令牌 id（可追溯到签发记录）
-    parent        —— 派生来源令牌 id（权职分离的委派链）
-    expires_at    —— 过期时间戳（None = 不过期）
-    layers_allow  —— 可写层白名单（None = 不限制；"*" = 全部）
-    ops_allow     —— 可执行 op 白名单（同上）
-    auth_mode     —— direct（直接构造）/ token / legacy_env / anonymous
-
-    版本层扩展（蜂群互联层0，由 `theory.check` 填充）：
-    theory_ok      —— 版本声明是否合法；False 时**全部写/管理操作被拒**（只读降级）
-    theory_version —— 当前声明的协议版本（审计与 whoami 用）
-    """
-
-    def __init__(self, tenant: str = "default", actor: str = "system",
-                 clearance: str = DEFAULT_SENSITIVITY, can_write: bool = True,
-                 can_admin: bool = False, session: str = None,
-                 role: str = None, token_id: str = None, parent: str = None,
-                 expires_at: float = None, layers_allow=None, ops_allow=None,
-                 auth_mode: str = "direct", theory_ok: bool = True,
-                 theory_version: str = None):
-        _rank(clearance)                      # 校验
-        self.tenant = tenant
-        self.actor = actor
-        self.clearance = clearance
-        self.can_write = can_write
-        self.can_admin = can_admin
-        self.session = session or ("sess_" + uuid.uuid4().hex[:12])
-        self.role = (role or "system")
-        self.token_id = token_id
-        self.parent = parent
-        self.expires_at = float(expires_at) if expires_at else None
-        self.layers_allow = None if layers_allow is None else tuple(layers_allow)
-        self.ops_allow = None if ops_allow is None else tuple(ops_allow)
-        self.auth_mode = auth_mode
-        self.theory_ok = bool(theory_ok)
-        self.theory_version = theory_version
-
-    # ---------- 基础判定 ----------
-
-    def allows(self, sensitivity: str) -> bool:
-        """clearance 是否覆盖该敏感度（可读/可写）。"""
-        return _rank(sensitivity) <= _rank(self.clearance)
-
-    def expired(self) -> bool:
-        return self.expires_at is not None and time.time() > self.expires_at
-
-    @staticmethod
-    def _in_scope(allow, name: str) -> bool:
-        if allow is None:                     # 未声明 = 不限制（兼容直接构造）
-            return True
-        return "*" in allow or name in allow
-
-    def allows_layer(self, layer: str) -> bool:
-        return self._in_scope(self.layers_allow, layer or "knowledge")
-
-    def allows_op(self, op: str) -> bool:
-        return self._in_scope(self.ops_allow, (op or "").strip().lower())
-
-    # ---------- 强制校验（越权即 AccessDenied） ----------
-
-    def _require_live(self):
-        if self.expired():
-            raise AccessDenied(f"actor={self.actor} 令牌已过期")
-
-    def require_op(self, op: str):
-        self._require_live()
-        if not self.allows_op(op):
-            raise AccessDenied(
-                f"角色 {self.role} 无权执行 op={op}（作用域 "
-                f"{list(self.ops_allow) if self.ops_allow is not None else '不限'}）")
-
-    def require_write(self, sensitivity: str):
-        self._require_live()
-        if not self.theory_ok:
-            raise AccessDenied(
-                "版本层校验未通过（theory_ok=False）：全部写操作被拒，"
-                "仅保留 theory 修复入口")
-        if not self.can_write:
-            raise AccessDenied(f"actor={self.actor} 无写权限")
-        if not self.allows(sensitivity):
-            raise AccessDenied(
-                f"写入敏感度 {sensitivity} 超出 clearance {self.clearance}")
-
-    def require_layer_write(self, layer: str, sensitivity: str):
-        """写层校验：密级 + 层白名单双闸门（核心私有内容不可越权修改）。"""
-        self.require_write(sensitivity)
-        layer = layer or "knowledge"
-        if not self.allows_layer(layer):
-            raise AccessDenied(
-                f"角色 {self.role} 无权写入 {layer} 层"
-                f"（可写层 {list(self.layers_allow) if self.layers_allow is not None else '不限'}）")
-
-    def require_admin(self, op: str):
-        self._require_live()
-        if not self.theory_ok:
-            raise AccessDenied(
-                f"版本层校验未通过（theory_ok=False）：管理操作 {op} 被拒")
-        if not self.can_admin:
-            raise AccessDenied(f"actor={self.actor} 无管理权限（{op}）")
-
-    def as_dict(self):
-        return {"tenant": self.tenant, "actor": self.actor,
-                "clearance": self.clearance, "can_write": self.can_write,
-                "can_admin": self.can_admin, "session": self.session,
-                "role": self.role, "token_id": self.token_id,
-                "parent": self.parent, "auth_mode": self.auth_mode,
-                "expires_at": self.expires_at,
-                "theory_ok": self.theory_ok,
-                "theory_version": self.theory_version,
-                "layers_allow": (None if self.layers_allow is None
-                                 else list(self.layers_allow)),
-                "ops_allow": (None if self.ops_allow is None
-                              else list(self.ops_allow))}
-
-    def __repr__(self):
-        return (f"Principal(tenant={self.tenant!r}, actor={self.actor!r}, "
-                f"role={self.role!r}, clearance={self.clearance!r}, "
-                f"write={self.can_write}, admin={self.can_admin})")
-
-
-class TenantRegistry:
-    """租户注册表：tenant → {root, clearance_cap, description}。
-
-    默认位置：<registry_dir>/_tenants.json（默认 ~/.mdcg/）。
-    设计意图：私有租户的 root 指向仓库外目录，开源仓库里只放 public 租户的根。
-    """
-
-    def __init__(self, path: str = None):
-        if path is None:
-            path = os.path.join(os.path.expanduser("~"), ".mdcg", "_tenants.json")
-        self.path = path
-        self.data = self._load()
-
-    def _load(self):
-        if os.path.exists(self.path):
-            try:
-                with open(self.path, encoding="utf-8") as f:
-                    d = json.load(f)
-                if isinstance(d, dict):
-                    return d
-            except (ValueError, OSError):
-                pass
-        return {"schema": 1, "tenants": {}}
-
-    def _save(self):
-        os.makedirs(os.path.dirname(self.path) or ".", exist_ok=True)
-        tmp = self.path + ".tmp"
-        with open(tmp, "w", encoding="utf-8") as f:
-            json.dump(self.data, f, ensure_ascii=False, indent=1)
-        os.replace(tmp, self.path)
-
-    def register(self, tenant: str, root: str, clearance_cap: str = DEFAULT_SENSITIVITY,
-                 description: str = ""):
-        _rank(clearance_cap)
-        self.data["tenants"][tenant] = {
-            "root": os.path.abspath(root),
-            "clearance_cap": clearance_cap,
-            "description": description,
-            "registered_at": time.time(),
-        }
-        self._save()
-        return self.data["tenants"][tenant]
-
-    def get(self, tenant: str):
-        return self.data["tenants"].get(tenant)
-
-    def root_of(self, tenant: str):
-        t = self.get(tenant)
-        return t["root"] if t else None
-
-    def cap_of(self, tenant: str):
-        t = self.get(tenant)
-        return t["clearance_cap"] if t else DEFAULT_SENSITIVITY
-
-    def all(self):
-        return dict(self.data["tenants"])
-
-    def principal_for(self, tenant: str, actor: str = None, clearance: str = None,
-                      can_write: bool = True, can_admin: bool = False,
-                      session: str = None) -> Principal:
-        """按租户上限夹紧 clearance（调用方不能超过租户上限）。"""
-        cap = self.cap_of(tenant)
-        want = clearance or cap
-        if _rank(want) > _rank(cap):
-            want = cap
-        return Principal(tenant=tenant, actor=actor or tenant, clearance=want,
-                         can_write=can_write, can_admin=can_admin, session=session)
+# -*- coding: utf-8 -*-
+"""md_cg · 进程/权限模型（记忆 OS #2）
+
+关键动机：**灵枢是开源仓库，而记忆很大一部分是私有内容**。因此权限模型必须
+支持「公开知识」与「私有记忆」的物理与逻辑隔离：
+
+  ① 物理隔离：租户（tenant）各自一个根目录。public 租户的根可落在开源仓库内，
+     private 租户的根必须落在仓库外（如 ~/.mdcg/private/）。
+  ② 逻辑隔离：每个节点带 sensitivity（public < internal < private < secret）；
+     每个调用方（Principal）带 clearance，只能读写 ≤ clearance 的节点。
+  ③ 硬规则：secret 节点对 clearance < secret 的调用方**写入即拒**（对齐 noema
+     「secret 候选自动拒绝」）；写入高于自身 clearance 的敏感度 → 拒绝。
+
+零第三方依赖。
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+import uuid
+
+SENSITIVITY_ORDER = ("public", "internal", "private", "secret")
+DEFAULT_SENSITIVITY = "internal"
+
+
+class AccessDenied(Exception):
+    """权限拒绝（读/写/管理）。"""
+
+
+def _rank(level: str) -> int:
+    try:
+        return SENSITIVITY_ORDER.index(level)
+    except ValueError:
+        raise AccessDenied(f"未知敏感度/密级：{level}") from None
+
+
+class Principal:
+    """调用方身份（一次会话一个）。
+
+    tenant        —— 租户（决定根目录）
+    actor         —— 调用者标识（写入审计）
+    clearance     —— 最高可读/可写敏感度
+    can_write     —— 是否允许写
+    can_admin     —— 是否允许管理操作（forget/restore/review_decide）
+    session       —— 会话 id（进程/会话模型：每次连接一个）
+    harness       —— 承载端标识（dsh/zcode/codebuddy…；仅归因，不参与授权）
+    unit          —— 单元分工（record/reflect/verify/output/sustain；仅归因）
+                     注：MCP 请求级参数 `as_unit` 会经 `tokens.narrowed_principal`
+                     产出一次性 Principal——其 role/layers/ops 取自该单元 spec、unit
+                     记为执行单元。那是**单次调用的临时身份**，不改变本字段的归因
+                     定位（见 `mcp_server.call_tool`）。
+
+    令牌扩展（由 `tokens.verify_token` 填充；直接构造时为 None = 不限制）：
+    role          —— 角色（designer/reflection/verifier/recorder/output/sustain/guest）
+    token_id      —— 令牌 id（可追溯到签发记录）
+    parent        —— 派生来源令牌 id（权职分离的委派链）
+    expires_at    —— 过期时间戳（None = 不过期）
+    layers_allow  —— 可写层白名单（None = 不限制；"*" = 全部）
+    ops_allow     —— 可执行 op 白名单（同上）
+    auth_mode     —— direct（直接构造）/ token / legacy_env / anonymous
+
+    版本层扩展（蜂群互联层0，由 `theory.check` 填充）：
+    theory_ok      —— 版本声明是否合法；False 时**全部写/管理操作被拒**（只读降级）
+    theory_version —— 当前声明的协议版本（审计与 whoami 用）
+    """
+
+    def __init__(self, tenant: str = "default", actor: str = "system",
+                 clearance: str = DEFAULT_SENSITIVITY, can_write: bool = True,
+                 can_admin: bool = False, session: str = None,
+                 harness: str = None, unit: str = None,
+                 role: str = None, token_id: str = None, parent: str = None,
+                 expires_at: float = None, layers_allow=None, ops_allow=None,
+                 auth_mode: str = "direct", theory_ok: bool = True,
+                 theory_version: str = None):
+        _rank(clearance)                      # 校验
+        self.tenant = tenant
+        self.actor = actor
+        self.clearance = clearance
+        self.can_write = can_write
+        self.can_admin = can_admin
+        self.session = session or ("sess_" + uuid.uuid4().hex[:12])
+        # 归因维度（嵌套身份）：只入审计（_audit/_recent），不参与权限判定。
+        # 权限域仍由令牌记录决定（tokens.ROLE_SPECS），与 harness/unit 无关。
+        # 受控例外：MCP 请求级 `as_unit` 收窄（tokens.narrowed_principal）产出的是
+        # 一次性 Principal，其 role/allow 取自单元 spec——**只做减法**（与 owner
+        # 求交 + 管理权恒 False），故不构成本字段「参与授权」的先例。
+        self.harness = harness
+        self.unit = unit
+        self.role = (role or "system")
+        self.token_id = token_id
+        self.parent = parent
+        self.expires_at = float(expires_at) if expires_at else None
+        self.layers_allow = None if layers_allow is None else tuple(layers_allow)
+        self.ops_allow = None if ops_allow is None else tuple(ops_allow)
+        self.auth_mode = auth_mode
+        self.theory_ok = bool(theory_ok)
+        self.theory_version = theory_version
+
+    # ---------- 基础判定 ----------
+
+    def allows(self, sensitivity: str) -> bool:
+        """clearance 是否覆盖该敏感度（可读/可写）。"""
+        return _rank(sensitivity) <= _rank(self.clearance)
+
+    def expired(self) -> bool:
+        return self.expires_at is not None and time.time() > self.expires_at
+
+    @staticmethod
+    def _in_scope(allow, name: str) -> bool:
+        if allow is None:                     # 未声明 = 不限制（兼容直接构造）
+            return True
+        return "*" in allow or name in allow
+
+    def allows_layer(self, layer: str) -> bool:
+        return self._in_scope(self.layers_allow, layer or "knowledge")
+
+    def allows_op(self, op: str) -> bool:
+        return self._in_scope(self.ops_allow, (op or "").strip().lower())
+
+    # ---------- 强制校验（越权即 AccessDenied） ----------
+
+    def _require_live(self):
+        if self.expired():
+            raise AccessDenied(f"actor={self.actor} 令牌已过期")
+
+    def require_op(self, op: str):
+        self._require_live()
+        if not self.allows_op(op):
+            raise AccessDenied(
+                f"角色 {self.role} 无权执行 op={op}（作用域 "
+                f"{list(self.ops_allow) if self.ops_allow is not None else '不限'}）")
+
+    def require_write(self, sensitivity: str):
+        self._require_live()
+        if not self.theory_ok:
+            raise AccessDenied(
+                "版本层校验未通过（theory_ok=False）：全部写操作被拒，"
+                "仅保留 theory 修复入口")
+        if not self.can_write:
+            raise AccessDenied(f"actor={self.actor} 无写权限")
+        if not self.allows(sensitivity):
+            raise AccessDenied(
+                f"写入敏感度 {sensitivity} 超出 clearance {self.clearance}")
+
+    def require_layer_write(self, layer: str, sensitivity: str):
+        """写层校验：密级 + 层白名单双闸门（核心私有内容不可越权修改）。"""
+        self.require_write(sensitivity)
+        layer = layer or "knowledge"
+        if not self.allows_layer(layer):
+            raise AccessDenied(
+                f"角色 {self.role} 无权写入 {layer} 层"
+                f"（可写层 {list(self.layers_allow) if self.layers_allow is not None else '不限'}）")
+
+    def require_admin(self, op: str):
+        self._require_live()
+        if not self.theory_ok:
+            raise AccessDenied(
+                f"版本层校验未通过（theory_ok=False）：管理操作 {op} 被拒")
+        if not self.can_admin:
+            raise AccessDenied(f"actor={self.actor} 无管理权限（{op}）")
+
+    def as_dict(self):
+        return {"tenant": self.tenant, "actor": self.actor,
+                "clearance": self.clearance, "can_write": self.can_write,
+                "can_admin": self.can_admin, "session": self.session,
+                "harness": self.harness, "unit": self.unit,
+                "role": self.role, "token_id": self.token_id,
+                "parent": self.parent, "auth_mode": self.auth_mode,
+                "expires_at": self.expires_at,
+                "theory_ok": self.theory_ok,
+                "theory_version": self.theory_version,
+                "layers_allow": (None if self.layers_allow is None
+                                 else list(self.layers_allow)),
+                "ops_allow": (None if self.ops_allow is None
+                              else list(self.ops_allow))}
+
+    def __repr__(self):
+        return (f"Principal(tenant={self.tenant!r}, actor={self.actor!r}, "
+                f"role={self.role!r}, clearance={self.clearance!r}, "
+                f"write={self.can_write}, admin={self.can_admin})")
+
+
+class TenantRegistry:
+    """租户注册表：tenant → {root, clearance_cap, description}。
+
+    默认位置：<registry_dir>/_tenants.json（默认 ~/.mdcg/）。
+    设计意图：私有租户的 root 指向仓库外目录，开源仓库里只放 public 租户的根。
+    """
+
+    def __init__(self, path: str = None):
+        if path is None:
+            path = os.path.join(os.path.expanduser("~"), ".mdcg", "_tenants.json")
+        self.path = path
+        self.data = self._load()
+
+    def _load(self):
+        if os.path.exists(self.path):
+            try:
+                with open(self.path, encoding="utf-8") as f:
+                    d = json.load(f)
+                if isinstance(d, dict):
+                    return d
+            except (ValueError, OSError):
+                pass
+        return {"schema": 1, "tenants": {}}
+
+    def _save(self):
+        os.makedirs(os.path.dirname(self.path) or ".", exist_ok=True)
+        tmp = self.path + ".tmp"
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(self.data, f, ensure_ascii=False, indent=1)
+        os.replace(tmp, self.path)
+
+    def register(self, tenant: str, root: str, clearance_cap: str = DEFAULT_SENSITIVITY,
+                 description: str = ""):
+        _rank(clearance_cap)
+        self.data["tenants"][tenant] = {
+            "root": os.path.abspath(root),
+            "clearance_cap": clearance_cap,
+            "description": description,
+            "registered_at": time.time(),
+        }
+        self._save()
+        return self.data["tenants"][tenant]
+
+    def get(self, tenant: str):
+        return self.data["tenants"].get(tenant)
+
+    def root_of(self, tenant: str):
+        t = self.get(tenant)
+        return t["root"] if t else None
+
+    def cap_of(self, tenant: str):
+        t = self.get(tenant)
+        return t["clearance_cap"] if t else DEFAULT_SENSITIVITY
+
+    def all(self):
+        return dict(self.data["tenants"])
+
+    def principal_for(self, tenant: str, actor: str = None, clearance: str = None,
+                      can_write: bool = True, can_admin: bool = False,
+                      session: str = None) -> Principal:
+        """按租户上限夹紧 clearance（调用方不能超过租户上限）。"""
+        cap = self.cap_of(tenant)
+        want = clearance or cap
+        if _rank(want) > _rank(cap):
+            want = cap
+        return Principal(tenant=tenant, actor=actor or tenant, clearance=want,
+                         can_write=can_write, can_admin=can_admin, session=session)

package/md_cg/self_state.py

@@ -378,13 +378,14 @@ def _render(state):
 
 def refresh(cg, subject=DEFAULT_SUBJECT, window=RECENT_WINDOW, importance=None,
             important_refs=None, dimensions=None, links=None,
-            actor="self_state", force=False, strict=False):
+            actor="self_state", force=False, strict=False, session=None):
     """刷新自我状态卡（幂等）：聚合八项 → 写卡 + 版本链留痕。
 
     dimensions: {"task": "...", "person": "...", "session": "...",
                  "time": "...", "trust": "..."}（值可为列表）
     links:      指向具体详情节点的边（认知图连接，而非内容复制）
     strict:     版本链断裂时是否拒绝写入（默认修复并记录 chain_repaired）
+    session:    会话归因（嵌套身份）：并入 session 维度，不覆盖显式声明值
     """
     raw = snapshot(cg, subject)
     tail = _last_log(cg, subject=subject)
@@ -401,8 +402,17 @@ def refresh(cg, subject=DEFAULT_SUBJECT, window=RECENT_WINDOW, importance=None,
                "important_refs": tail.get("important_refs"),
                "state_links": tail.get("state_links"),
                "identity_ref": tail.get("identity_ref")}
+    # 会话归因：把本会话并入 session 维度（不覆盖调用方显式声明的维度值）。
+    dims_in = dict(dimensions or {})
+    if session:
+        vals = dims_in.get("session") or []
+        vals = list(vals) if isinstance(vals, (list, tuple, set)) else [vals]
+        vals = [str(v) for v in vals if str(v).strip()]
+        if str(session) not in vals:
+            vals.append(str(session))
+        dims_in["session"] = vals
     state = _derive(cg, subject, window=window, importance=importance,
-                    important_refs=important_refs, dimensions=dimensions,
+                    important_refs=important_refs, dimensions=dims_in,
                     links=links, old=old)
     card_v = int((old or {}).get("state_version") or 0)
     log_v = int(tail.get("version") or 0) if tail else 0
@@ -782,13 +792,39 @@ def bootstrap(cg, subject=DEFAULT_SUBJECT, window=RECENT_WINDOW,
             "loaded_at": time.time()}
 
 
-def summary(cg, subject=DEFAULT_SUBJECT):
-    """一句话自我状态（供 health / 面板）。"""
+def _with_session_slice(cg, out, st, session):
+    """给 summary 结果补「本会话切片」（薄卡 + 富索引，不改单例语义）。
+
+    · session_registered —— 本会话是否已登记在该状态卡的 session 维度上；
+    · session_refs       —— 该维度反查到的详情节点指针（不搬运内容）。
+    """
+    if not session:
+        return out
+    s = str(session)
+    out["session"] = s
+    dims = (st or {}).get("dimensions") or {}
+    out["session_registered"] = bool(s in (dims.get("session") or []))
+    try:
+        res = index(cg, "session", s, limit=20)
+        out["session_refs"] = {"count": res.get("count", 0),
+                               "items": res.get("items", [])}
+    except Exception:                          # noqa: BLE001
+        out["session_refs"] = {"count": 0, "items": [], "degraded": True}
+    return out
+
+
+def summary(cg, subject=DEFAULT_SUBJECT, session=None):
+    """一句话自我状态（供 health / 面板）。
+
+    session：会话归因切片。**不改变单例卡语义**——只回报「本会话是否已登记在
+    该卡的 session 维度上」以及该维度反查到的详情节点指针（薄卡 + 富索引）。
+    """
     st = snapshot(cg, subject)
     if not st:
-        return {"ok": False, "subject": subject, "note": "无状态卡"}
+        return _with_session_slice(cg, {"ok": False, "subject": subject,
+                                        "note": "无状态卡"}, st, session)
     ig, tt = st.get("information_gap") or {}, st.get("trust") or {}
-    return {"ok": True, "subject": subject,
+    out = {"ok": True, "subject": subject,
             "version": st.get("state_version"),
             "updated_at": st.get("updated_at"),
             "d_current": ig.get("d_current"), "d2": ig.get("d2"),
@@ -804,6 +840,7 @@ def summary(cg, subject=DEFAULT_SUBJECT):
                      f"情感={st.get('affect')} "
                      f"短期={((st.get('short_term') or {}).get('n'))}条 "
                      f"v{st.get('state_version')}")}
+    return _with_session_slice(cg, out, st, session)
 
 
 def catalog():