@furongjun1999/dsh-memory 0.7.3 → 0.7.5

package/lib/lib/mdcg_client.d.ts

@@ -19,6 +19,8 @@
  *   外部裁决回填  → MdcgClient.verify()     → MCP cg(op=verify)
  *   最近记忆时间线 → MdcgClient.timeline()  → MCP stg(op=timeline)
  *   近期事件窗口  → MdcgClient.recent()     → MCP cg(op=recent)
+ *   窗口追加事件  → MdcgClient.recentAdd()  → MCP cg(op=recent, action=add)
+ *   会话续接包    → MdcgClient.sessionRecall() → MCP cg(op=session, action=recall)
  *   身份读取      → MdcgClient.identity()   → MCP cg(op=identity)
  *   白箱能力验证  → MdcgClient.whitebox()   → MCP cg(op=whitebox)
  *   服务信息      → MdcgClient.serviceInfo()→ MCP cg(op=info)
@@ -182,6 +184,41 @@ export declare class MdcgClient {
     verify(nodeId: string, evidence: string, verdict: string): Promise<unknown>;
     /** 最近记忆。 */
     recent(limit?: number): Promise<unknown>;
+    /** 追加一条**近期事件窗口**记录（`cg(op=recent, action=add)` →
+     *  `md_cg` 的 `remember_event(role, text, tags, meta, window)`）。
+     *
+     *  这是「滑动窗口」写侧：事件落 `_recent.jsonl`（**运行态面**），按窗口滚动
+     *  淘汰（服务端缺省 200 条，`mdcg.py:91 DEFAULT_RECENT_WINDOW`）——它**不是
+     *  知识节点**：不占 knowledge 层、不进检索正排，与 `remember()` 的知识面沉淀
+     *  是两条独立的轨道（见 src/hooks.ts 文件头的 contextWindow 头注）。
+     *
+     *  ⚠️ **不注入 as_unit**（与 `write()` 同款理由的反面）：本调用不写任何层的
+     *  节点（服务端 `remember_event` 不做层白名单校验），收窄单元无收益且可能压低
+     *  事件密级（缺省 internal）；`meta.session` 由调用方显式给出（沿本文件
+     *  `remember()` 的 sessionTag 口径）。
+     *
+     *  ⚠️ 服务端对 `meta` 做 `setdefault`（tenant/session/harness/unit，见
+     *  `mdcos.py:5057 remember_event`）：调用方已写的键**不被覆盖**。 */
+    recentAdd(role: string, text: string, meta?: Record<string, unknown>, tags?: string[]): Promise<unknown>;
+    /** **会话续接包**（`cg(op=session, action=recall)` → `md_cg` 的
+     *  `session_recall`）：一次取回 notes / goals / tasks / **recent 事件窗口** /
+     *  unresolved / self_state，按 `budget_tokens` 整包裁剪（服务端
+     *  `mdcos.py:3351-3362`：交替丢 recent / notes 尾部）。
+     *
+     *  本插件消费其中的 `recent` 段——滑动窗口的**注入面**（见 src/hooks.ts）。
+     *  `recent_limit` 语义 = 近期事件**条数**（非「轮数」）；服务端读取时会按
+     *  `max(1, recent_limit or 10)` 归一（`mdcos.py:3309`）。
+     *
+     *  ⚠️ 两条服务端事实（决定注入侧的可达性，勿据本方法名臆测）：
+     *   ① `recent` 段取 `recent_events(limit=recent_limit)` —— **不按 session
+     *      过滤**（近期事件是运行态滚动窗口，会话归属只写在每条事件的 meta 里）；
+     *   ② budget 是**整包**预算：库内 notes/tasks/self_state 占位越多，同样
+     *      budget 下 recent 段被裁得越短（实测：空库 + 10 条窗口条目，
+     *      budget_tokens=600 → recent 8 条；1200 → 10 条）。
+     *
+     *  只读调用，不注入 as_unit（同其它读路径：读无副作用，收窄只会压低 owner
+     *  的 private 读能力）。 */
+    sessionRecall(session: string, recentLimit: number, budgetTokens: number): Promise<unknown>;
     /** 最近记忆**时间线**（AEIS `timeline` 的对应物）：`stg(op=timeline)` →
      *  `{count, limit, items:[{id, layer, start, end, preview}]}`，按时间倒序。
      *

package/lib/lib/mdcg_client.js

@@ -19,6 +19,8 @@
  *   外部裁决回填  → MdcgClient.verify()     → MCP cg(op=verify)
  *   最近记忆时间线 → MdcgClient.timeline()  → MCP stg(op=timeline)
  *   近期事件窗口  → MdcgClient.recent()     → MCP cg(op=recent)
+ *   窗口追加事件  → MdcgClient.recentAdd()  → MCP cg(op=recent, action=add)
+ *   会话续接包    → MdcgClient.sessionRecall() → MCP cg(op=session, action=recall)
  *   身份读取      → MdcgClient.identity()   → MCP cg(op=identity)
  *   白箱能力验证  → MdcgClient.whitebox()   → MCP cg(op=whitebox)
  *   服务信息      → MdcgClient.serviceInfo()→ MCP cg(op=info)
@@ -215,6 +217,48 @@ export class MdcgClient {
     recent(limit = 20) {
         return this.cg({ op: 'recent', limit });
     }
+    /** 追加一条**近期事件窗口**记录（`cg(op=recent, action=add)` →
+     *  `md_cg` 的 `remember_event(role, text, tags, meta, window)`）。
+     *
+     *  这是「滑动窗口」写侧：事件落 `_recent.jsonl`（**运行态面**），按窗口滚动
+     *  淘汰（服务端缺省 200 条，`mdcg.py:91 DEFAULT_RECENT_WINDOW`）——它**不是
+     *  知识节点**：不占 knowledge 层、不进检索正排，与 `remember()` 的知识面沉淀
+     *  是两条独立的轨道（见 src/hooks.ts 文件头的 contextWindow 头注）。
+     *
+     *  ⚠️ **不注入 as_unit**（与 `write()` 同款理由的反面）：本调用不写任何层的
+     *  节点（服务端 `remember_event` 不做层白名单校验），收窄单元无收益且可能压低
+     *  事件密级（缺省 internal）；`meta.session` 由调用方显式给出（沿本文件
+     *  `remember()` 的 sessionTag 口径）。
+     *
+     *  ⚠️ 服务端对 `meta` 做 `setdefault`（tenant/session/harness/unit，见
+     *  `mdcos.py:5057 remember_event`）：调用方已写的键**不被覆盖**。 */
+    recentAdd(role, text, meta = {}, tags = []) {
+        return this.cg({ op: 'recent', action: 'add', role, text, meta, tags });
+    }
+    /** **会话续接包**（`cg(op=session, action=recall)` → `md_cg` 的
+     *  `session_recall`）：一次取回 notes / goals / tasks / **recent 事件窗口** /
+     *  unresolved / self_state，按 `budget_tokens` 整包裁剪（服务端
+     *  `mdcos.py:3351-3362`：交替丢 recent / notes 尾部）。
+     *
+     *  本插件消费其中的 `recent` 段——滑动窗口的**注入面**（见 src/hooks.ts）。
+     *  `recent_limit` 语义 = 近期事件**条数**（非「轮数」）；服务端读取时会按
+     *  `max(1, recent_limit or 10)` 归一（`mdcos.py:3309`）。
+     *
+     *  ⚠️ 两条服务端事实（决定注入侧的可达性，勿据本方法名臆测）：
+     *   ① `recent` 段取 `recent_events(limit=recent_limit)` —— **不按 session
+     *      过滤**（近期事件是运行态滚动窗口，会话归属只写在每条事件的 meta 里）；
+     *   ② budget 是**整包**预算：库内 notes/tasks/self_state 占位越多，同样
+     *      budget 下 recent 段被裁得越短（实测：空库 + 10 条窗口条目，
+     *      budget_tokens=600 → recent 8 条；1200 → 10 条）。
+     *
+     *  只读调用，不注入 as_unit（同其它读路径：读无副作用，收窄只会压低 owner
+     *  的 private 读能力）。 */
+    sessionRecall(session, recentLimit, budgetTokens) {
+        return this.cg({
+            op: 'session', action: 'recall',
+            session, recent_limit: recentLimit, budget_tokens: budgetTokens,
+        });
+    }
     /** 最近记忆**时间线**（AEIS `timeline` 的对应物）：`stg(op=timeline)` →
      *  `{count, limit, items:[{id, layer, start, end, preview}]}`，按时间倒序。
      *

package/lib/lib/session_state.d.ts

@@ -0,0 +1,56 @@
+/**
+ * session_state.ts —— 插件侧「运行期会话状态」单点（观测 → 写归因注入）
+ *
+ * 为什么有这个模块（B 治本批，2026-10-06）
+ * ----------------------------------------
+ * DSH 单进程多会话：宿主的会话标识只经 `session/event` 到达插件。此前它只被
+ * 用在 hooks 面（自动记忆的 remember / read 带 extra.session）；**agent 直调
+ * 工具面**（src/tools.ts 的 execute → bridge.callTool）转发时**不带会话**——
+ * 而部署侧 `MDCG_SESSION` env 一旦取消/为空，`md_cg/mcp_server.py` 的
+ * `_declared_session`（:3823-3850）就以**请求声明**为归因来源
+ * （优先级：env > 请求声明 > 进程身份），不传即落回进程身份——md_cg 的
+ * `Principal.__init__` 会为假值 session 生成**进程级随机** `sess_<hex>`
+ * （md_cg/security.py:117）：归属在审计上既读不出是谁、跨进程也对不上，
+ * 是静默的归属丢失。
+ *
+ * 本模块把「观测会话」与「写归因注入」收成**单点**：
+ *   · hooks 面：每收到 session/event 就 `noteSession(sid)`——调用点仍在 H1
+ *     子代理闸**之后**（子代理会话不得污染会话状态的位置不变量保持）；
+ *   · 工具面：写归因调用注入 `currentSession() || UNASSIGNED_SESSION`
+ *     （判据矩阵见 `attributeSession`，只注入写面；读面一律不注入）。
+ *
+ * 模块级状态（`lastSession`）是**进程级**的：同一进程内多个会话共享它，
+ * 「最近一次观测」即当前活动会话——与 hooks 面的既有口径一致（见
+ * test/session-attribution.test.ts ④「取值每步稳定」）。
+ */
+/** 会话归属未知时的**显式占位**（H2③，2026-09-30；原定义在 src/hooks.ts，
+ *  B 治本批迁入本单点——注释要点保真搬迁）。
+ *
+ *  ⚠️ 不可退回「不传 session 键」：md_cg 的 `Principal.__init__` 在 session 为假值时
+ *  生成**进程级随机** `sess_<hex>`（md_cg/security.py:117）——插件不传，等于让一个
+ *  进程内所有「宿主未给标识」的会话共用一个**不可辨认**的随机桶：归属在审计上既
+ *  读不出是谁、跨进程也对不上，是静默的归属丢失。
+ *  本常量把这一态写成**显式值**：跨进程一致、可辨认、可审计，且不是伪造的宿主
+ *  会话 id（非 DSH 形态，服务端 `_normalize_session` 原样采用、不会被改写成别的桶）。
+ *  要读这个桶：`stg(op=timeline, session="unassigned")`。 */
+export declare const UNASSIGNED_SESSION = "unassigned";
+/** 记录一次会话观测（H2③ 观测面单点）。
+ *
+ *  trim 后非空才写入——空串/纯空白**不覆盖**旧值（否则「宿主给了一次空标识」
+ *  会把已观测到的真会话抹掉，后续注入退化为 unassigned）。 */
+export declare function noteSession(sid: string): void;
+/** 当前运行期会话标识（空串 = 未观测到；调用方按 `|| UNASSIGNED_SESSION` 兜底）。 */
+export declare function currentSession(): string;
+/** 把**运行期会话**注入**写归因调用**（args 的 session 键不可用时才注入）。
+ *
+ *  注入条件：`session` 键缺失 / 非 string 类型 / trim 后空串 ⇒ 注入
+ *  （`null`/`''`/空白一律视为「未声明」——服务端 `_declared_session` 对假值
+ *  同样解析为无归属声明，原样转发只会落回进程级随机 sess_* 兜底桶）；
+ *  显式非空声明一律**不覆盖**（调用方自报优先——插件不替调用方改归属）。
+ *
+ *  注入值：`currentSession() || UNASSIGNED_SESSION`（未观测到会话时用
+ *  'unassigned' 显式占位——与 hooks 面 H2③ 同口径）。
+ *
+ *  命中且需注入 → 返回**新对象** `{ ...args, session: v }`（绝不 mutate 输入）；
+ *  否则**原样返回**（同一引用）——未命中的调用零开销、零可观察差异。 */
+export declare function attributeSession(toolName: string, args: Record<string, unknown>): Record<string, unknown>;

package/lib/lib/session_state.js

@@ -0,0 +1,124 @@
+/**
+ * session_state.ts —— 插件侧「运行期会话状态」单点（观测 → 写归因注入）
+ *
+ * 为什么有这个模块（B 治本批，2026-10-06）
+ * ----------------------------------------
+ * DSH 单进程多会话：宿主的会话标识只经 `session/event` 到达插件。此前它只被
+ * 用在 hooks 面（自动记忆的 remember / read 带 extra.session）；**agent 直调
+ * 工具面**（src/tools.ts 的 execute → bridge.callTool）转发时**不带会话**——
+ * 而部署侧 `MDCG_SESSION` env 一旦取消/为空，`md_cg/mcp_server.py` 的
+ * `_declared_session`（:3823-3850）就以**请求声明**为归因来源
+ * （优先级：env > 请求声明 > 进程身份），不传即落回进程身份——md_cg 的
+ * `Principal.__init__` 会为假值 session 生成**进程级随机** `sess_<hex>`
+ * （md_cg/security.py:117）：归属在审计上既读不出是谁、跨进程也对不上，
+ * 是静默的归属丢失。
+ *
+ * 本模块把「观测会话」与「写归因注入」收成**单点**：
+ *   · hooks 面：每收到 session/event 就 `noteSession(sid)`——调用点仍在 H1
+ *     子代理闸**之后**（子代理会话不得污染会话状态的位置不变量保持）；
+ *   · 工具面：写归因调用注入 `currentSession() || UNASSIGNED_SESSION`
+ *     （判据矩阵见 `attributeSession`，只注入写面；读面一律不注入）。
+ *
+ * 模块级状态（`lastSession`）是**进程级**的：同一进程内多个会话共享它，
+ * 「最近一次观测」即当前活动会话——与 hooks 面的既有口径一致（见
+ * test/session-attribution.test.ts ④「取值每步稳定」）。
+ */
+/** 会话归属未知时的**显式占位**（H2③，2026-09-30；原定义在 src/hooks.ts，
+ *  B 治本批迁入本单点——注释要点保真搬迁）。
+ *
+ *  ⚠️ 不可退回「不传 session 键」：md_cg 的 `Principal.__init__` 在 session 为假值时
+ *  生成**进程级随机** `sess_<hex>`（md_cg/security.py:117）——插件不传，等于让一个
+ *  进程内所有「宿主未给标识」的会话共用一个**不可辨认**的随机桶：归属在审计上既
+ *  读不出是谁、跨进程也对不上，是静默的归属丢失。
+ *  本常量把这一态写成**显式值**：跨进程一致、可辨认、可审计，且不是伪造的宿主
+ *  会话 id（非 DSH 形态，服务端 `_normalize_session` 原样采用、不会被改写成别的桶）。
+ *  要读这个桶：`stg(op=timeline, session="unassigned")`。 */
+export const UNASSIGNED_SESSION = 'unassigned';
+/** 最近一次观测到的宿主会话标识（空串 = 未观测到会话）。
+ *
+ *  ⚠️ 本状态是**模块级（进程级）单点**：hooks 面观测写入（src/hooks.ts 的
+ *  session/event），工具面读它做写归因注入（src/tools.ts 的转发面）——两处必须
+ *  同源，否则注入的会话与写入的归属对不上（B 治本批的目的即在此）。
+ *
+ *  「本实例是否观测过」的**实例级门不在本模块**，在 src/hooks.ts 的
+ *  installMemoryHooks 内（局部 `observedSession`）：即「本实例观测到会话之后」
+ *  才用本单点值回落召回过滤。这是**经 owner 裁定的契约字面偏离（dwfq-7b3a555e-1）**
+ *  ——契约建议的形态是 hooks 侧字面 `|| currentSession()`，但字面形态与硬边界
+ *  「test/session-attribution.test.ts 逐字未动且全绿」互斥（该守卫 ② 以
+ *  「新建 harness = 未观测」为前提，字面回落会读成前一实例的 sess_B）。保留
+ *  实例门的两条理由：
+ *    ① 「新实例 = 干净状态」是原闭包变量 `lastSession` 的**有意属性**（新装的钩子
+ *       在观测到会话前，自动召回不加过滤）——实例隔离语义在测试面被真实保留；
+ *    ② 与既有冻结守卫 ② 相容（守卫逐字未动且全绿是本批硬边界）。
+ *  真机单实例下两者**逐位等价**：唯一差异窗口是「本实例未观测 ∧ 模块单点非空」，
+ *  而模块值只由本实例的 hooks 观测写入，单实例下该窗口不可达；HMR 重载场景下新
+ *  实例回落 '' 而非上一会话值，属更保守的防御行为（已由 owner 裁定接受）。 */
+let lastSession = '';
+/** 记录一次会话观测（H2③ 观测面单点）。
+ *
+ *  trim 后非空才写入——空串/纯空白**不覆盖**旧值（否则「宿主给了一次空标识」
+ *  会把已观测到的真会话抹掉，后续注入退化为 unassigned）。 */
+export function noteSession(sid) {
+    const s = sid.trim();
+    if (s)
+        lastSession = s;
+}
+/** 当前运行期会话标识（空串 = 未观测到；调用方按 `|| UNASSIGNED_SESSION` 兜底）。 */
+export function currentSession() {
+    return lastSession;
+}
+/** 写归因面判据：本次调用是否属于「要注入运行期会话」的写归因调用。
+ *
+ *  **恰两条命中路径**（不得放宽、不得收窄出契约外）：
+ *    ① `mdcg_remember` —— md_cg 细粒度写入口（插件侧自动记忆/落图的写通道）；
+ *    ② `cg` 且 `op === 'write'` —— 认知图基元的带审核写路径。
+ *
+ *  为什么**只**这两个面（判据出处：md_cg/mcp_server.py）：
+ *    · **读面一律不注入**——`mdcg_recall` / `mdcg_search` / `mdcg_get` / `stg`
+ *      以及 `cg` 的其它 op，其 `session` 是**视图过滤**：服务端 schema 描述原文
+ *      「会话归属过滤（frontmatter.session；…缺省不过滤）」
+ *      （md_cg/mcp_server.py:218-219 / :251-252 / :908-912 / :1074-1077）。
+ *      注入会把文档化的「缺省跨会话」翻转成「本会话视图」——那是功能收窄，
+ *      不是本批目标（读面要跨会话视图请显式 `stg(op=timeline, session="*")`）。
+ *    · **op 特化语义不动**——`cg` 的 `sustain`/`session` 等 op 的 `session` 是
+ *      特化语义（resume/note 的**目标会话**），注入即污染其目标参数。
+ *    · 归因与授权正交（issue #35 定稿）：`call_tool` 的请求级 session **只做
+ *      归因**（写入归属/`_attribution` 取它），**不**改 `principal.session`
+ *      （md_cg/mcp_server.py:3261-3264）——绑定档（private/secret）的读授权
+ *      锚定连接级身份，调用方自报的会话不构成看他人 private 的授权。
+ *      绑定档可见性判定 `MdCGSecure._readable`（md_cg/mdcos.py:5009-5053）
+ *      的会话绑定分支恒用 `nsess == self.principal.session`（:5051-5052），
+ *      can_admin（设计者）豁免（:5045）——故本注入对绑定档无回归。
+ *
+ *  ⚠️ 禁止把本判据放宽成「所有带 session 参数的工具」：那会把上面两类语义
+ *  （读面视图过滤 / op 特化目标）一并改写，属越权改契约。
+ */
+function isWriteAttributionCall(toolName, args) {
+    if (toolName === 'mdcg_remember')
+        return true;
+    return toolName === 'cg' && args['op'] === 'write';
+}
+/** 请求是否已显式声明会话（string 且 trim 后非空 → 保留调用方声明，绝不覆盖）。 */
+function hasDeclaredSession(args) {
+    const v = args['session'];
+    return typeof v === 'string' && v.trim() !== '';
+}
+/** 把**运行期会话**注入**写归因调用**（args 的 session 键不可用时才注入）。
+ *
+ *  注入条件：`session` 键缺失 / 非 string 类型 / trim 后空串 ⇒ 注入
+ *  （`null`/`''`/空白一律视为「未声明」——服务端 `_declared_session` 对假值
+ *  同样解析为无归属声明，原样转发只会落回进程级随机 sess_* 兜底桶）；
+ *  显式非空声明一律**不覆盖**（调用方自报优先——插件不替调用方改归属）。
+ *
+ *  注入值：`currentSession() || UNASSIGNED_SESSION`（未观测到会话时用
+ *  'unassigned' 显式占位——与 hooks 面 H2③ 同口径）。
+ *
+ *  命中且需注入 → 返回**新对象** `{ ...args, session: v }`（绝不 mutate 输入）；
+ *  否则**原样返回**（同一引用）——未命中的调用零开销、零可观察差异。 */
+export function attributeSession(toolName, args) {
+    if (!isWriteAttributionCall(toolName, args))
+        return args;
+    if (hasDeclaredSession(args))
+        return args;
+    return { ...args, session: currentSession() || UNASSIGNED_SESSION };
+}

package/lib/tools.js

@@ -5,6 +5,10 @@
  * 动态拉取意味着灵枢库升级新增工具后，DSH 侧零改动即可获得新能力。
  */
 import { defineTool } from '@deepseek-ai/dsh-tools';
+// B 治本批（2026-10-06）：写归因注入单点（运行期会话 → 写归因调用）。
+// 运行时导入写 `.js`（本仓口径：type-only 才写 `.ts`，tsconfig 未开
+// allowImportingTsExtensions —— 值导入写 `.ts` 会 TS5097 编译失败）。
+import { attributeSession } from './lib/session_state.js';
 /** 默认暴露的核心工具集合：**记忆面已基元化**，只注册 `cg` / `stg` 两个认知基元。
  *
  * 三层拆分 S4 收敛后，插件工具面真源是 `md_cg.mcp_server`（不再是 pip aeis）；
@@ -173,7 +177,14 @@ export async function registerLingshuTools(ctx, bridge, opts) {
                 async execute(args, exec) {
                     if (exec.signal.aborted)
                         throw new Error(`灵枢 ${tool.name} 已取消`);
-                    const result = await bridge.callTool(tool.name, args, exec.signal);
+                    // B 治本批（2026-10-06）：agent 直调工具的转发面把**运行期会话**注入
+                    // **写归因调用**——env（MDCG_SESSION）取消后，请求声明即归因唯一来源
+                    // （md_cg/mcp_server.py 的 _declared_session：env > 请求声明 > 进程身份）。
+                    // 判据单点在 lib/session_state.ts 的 attributeSession：只注入
+                    // mdcg_remember 与 cg(op=write) 两个写面；读面（视图过滤）/ op 特化语义
+                    // 一律不动。命中且未显式声明时返回新对象，否则原样透传。
+                    const forwarded = attributeSession(tool.name, args);
+                    const result = await bridge.callTool(tool.name, forwarded, exec.signal);
                     if (exec.signal.aborted)
                         throw new Error(`灵枢 ${tool.name} 已取消`);
                     if (result.isError) {

package/md_cg/audit.py

@@ -456,11 +456,17 @@ def _verify_code(payload, ctx):
         # 被测命令只要输出非 gbk 字节，读取线程就抛 UnicodeDecodeError →
         # p.stdout/p.stderr 可能为空 → 下一行的失败证据丢失，
         # 「实测失败」会退化成一句没有依据的 REJECT（对齐 whitebox.py 的写法）。
+        # stdin=subprocess.DEVNULL（issue #63 同批加固）：不指定 stdin 时子进程
+        # 继承父进程 stdin（常驻宿主下是 JSON-RPC 活管道），读 stdin 的测试
+        # 命令会悬挂到 timeout 才被 kill——形态对齐 `md_cg/run_tests.py:105`。
         p = subprocess.run(argv, cwd=ctx.get("cwd"), capture_output=True,
                            text=True, encoding="utf-8", errors="replace",
-                           shell=False,
+                           shell=False, stdin=subprocess.DEVNULL,
                            timeout=int(os.environ.get("MDCG_CODE_TEST_TIMEOUT", "60")))
     except (OSError, subprocess.SubprocessError) as exc:
+        # TimeoutExpired（SubprocessError 子类）也走这里：DEFER + 文案带异常
+        # 名与原文（如 "TimeoutExpired: Command '…' timed out after 60 seconds"）
+        # ——超时**不吞**（issue #63）。
         return _verdict(DEFER, "code", f"测试无法执行：{type(exc).__name__}: {exc}")
     if p.returncode == 0:
         return _verdict(ACCEPT, "code", f"实测通过：{cmd}")

package/md_cg/bench_governance.py

@@ -315,9 +315,12 @@ def run(root=None, keep=False):
 
 def _git_head():
     try:
+        # timeout=10 既有；stdin=subprocess.DEVNULL 为 issue #63 同批加固——
+        # 不指定 stdin 时子进程继承父进程 stdin（常驻宿主下是 JSON-RPC 活管道）。
         out = subprocess.run(["git", "rev-parse", "--short", "HEAD"],
                              capture_output=True, text=True, encoding="utf-8",
-                             errors="replace", shell=False, timeout=10)
+                             errors="replace", shell=False, timeout=10,
+                             stdin=subprocess.DEVNULL)
         return (out.stdout or "").strip() or "unknown"
     except Exception:                                     # noqa: BLE001
         return "unknown"

package/md_cg/bench_locomo_zh.py

@@ -303,6 +303,9 @@ ROW_RE = re.compile(
     r"([\d.]+)%\s+([\d.]+)%\s+([\d.]+)\s*$", re.M)
 GATE_RE = re.compile(r"拒答率：([\d.]+)%")
 LINE_RE = re.compile(r"拒答线（正例 hit@1 题 Top-1 分 p10）：([\d.]+)")
+#: 单臂评测子进程的超时（秒）——issue #63 同批加固：评测跑批比 git 长，按
+#: 「一臂为分钟级」给 1800s（30min）为安全上界；超时即 kill（不再是无限等待）。
+_EVAL_TIMEOUT_S = 1800
 
 
 # 生效条件：RUST_BIN 经 os.path.exists 为假时抛 SystemExit；否则以 argv 列表 [RUST_BIN, "--dataset", "lc", "--tag", name, "--lib", lib, "--qfile", qfile]（extra 为真值时追加其元素）执行 subprocess.run，返回码非 0 或 stdout 未匹配 ROW_RE 时抛 SystemExit，成功时返回 (got, neg, line)，其中 GATE_RE/LINE_RE 未命中时对应值为 None。
@@ -320,8 +323,15 @@ def run_one(name, lib, qfile, extra=None):
     if extra:
         argv += list(extra)
     env = dict(os.environ, PYTHONUTF8="1")
-    p = subprocess.run(argv, capture_output=True, text=True,
-                       encoding="utf-8", errors="replace", env=env, cwd=HERE)
+    try:
+        # timeout + stdin=DEVNULL（issue #63 同批加固）：评测跑批有界化，
+        # 且不继承父进程 stdin（常驻宿主下是 JSON-RPC 活管道）。
+        p = subprocess.run(argv, capture_output=True, text=True,
+                           encoding="utf-8", errors="replace", env=env, cwd=HERE,
+                           timeout=_EVAL_TIMEOUT_S,
+                           stdin=subprocess.DEVNULL)
+    except subprocess.TimeoutExpired:
+        raise SystemExit(f"[失败] {name}：评测超时（>{_EVAL_TIMEOUT_S}s）已被 kill")
     if p.returncode != 0:
         raise SystemExit(f"[失败] {name}：{(p.stderr or '')[-900:]}")
     got = {}

package/md_cg/bench_zh_mad.py

@@ -481,6 +481,9 @@ ROW_RE = re.compile(
     r"^\s*(precise|temporal|interference|reference)\s+(\d+)\s+"
     r"([\d.]+)%\s+([\d.]+)%\s+([\d.]+)\s*$", re.M)
 GROUPS = ["precise", "temporal", "interference", "reference"]
+#: 单臂评测子进程的超时（秒）——issue #63 同批加固：评测跑批比 git 长，按
+#: 「一臂为分钟级」给 1800s（30min）为安全上界；超时即 kill（不再是无限等待）。
+_EVAL_TIMEOUT_S = 1800
 
 
 # 生效条件：os.path.exists(RUST_BIN) 为真时以 argv=[RUST_BIN,"--dataset","mad","--tag",name,"--lib",lib]（extra 为真值时追加 list(extra)）执行 subprocess，返回码非 0 或 ROW_RE 在 stdout 未匹配到任何组时 raise SystemExit，否则返回 {组:(n,hit@1,hit@5,MRR)}。
@@ -498,8 +501,15 @@ def run_one(name, lib, extra=None):
     if extra:
         argv += list(extra)
     env = dict(os.environ, PYTHONUTF8="1")
-    p = subprocess.run(argv, capture_output=True, text=True,
-                       encoding="utf-8", errors="replace", env=env, cwd=HERE)
+    try:
+        # timeout + stdin=DEVNULL（issue #63 同批加固）：评测跑批有界化，
+        # 且不继承父进程 stdin（常驻宿主下是 JSON-RPC 活管道）。
+        p = subprocess.run(argv, capture_output=True, text=True,
+                           encoding="utf-8", errors="replace", env=env, cwd=HERE,
+                           timeout=_EVAL_TIMEOUT_S,
+                           stdin=subprocess.DEVNULL)
+    except subprocess.TimeoutExpired:
+        raise SystemExit(f"[失败] {name}：评测超时（>{_EVAL_TIMEOUT_S}s）已被 kill")
     if p.returncode != 0:
         raise SystemExit(f"[失败] {name}：{(p.stderr or '')[-900:]}")
     got = {}

package/md_cg/interop.py

@@ -47,6 +47,11 @@ _FORBIDDEN_RES = [
 ]
 _FORBIDDEN_KEYS = {"prompt", "content", "spec", "api_key", "base", "model",
                    "system_prompt", "user_prompt", "content_head"}
+#: git add/commit 子进程的超时（秒）——issue #63 同批加固：本机 git 为秒级
+#: 操作，120s 为安全上界；超时即 kill。**stdin=subprocess.DEVNULL 同加**：
+#: 不指定 stdin 时子进程继承父进程 stdin（常驻宿主下是 JSON-RPC 活管道），
+#: 读 stdin 的子进程会悬挂（先例形态 `md_cg/run_tests.py:105`）。
+_GIT_TIMEOUT_S = 120
 
 
 class InteropSanityError(ValueError):
@@ -323,15 +328,26 @@ def write_verdict_to_repo(verdict: dict, repo: str = HERE,
     out = {"ok": True, "path": fp}
     if do_commit:
         import subprocess
-        r1 = subprocess.run(["git", "add", os.path.relpath(fp, repo)],
-                            cwd=repo, capture_output=True, text=True,
-                            encoding="utf-8", errors="replace")
-        r2 = subprocess.run(
-            ["git", "commit", "-q", "-m",
-             f"interop(verifier): iter={it} verdict={verdict.get('verdict')} "
-             f"passed={verdict.get('passed')} failed={verdict.get('failed')}"],
-            cwd=repo, capture_output=True, text=True,
-            encoding="utf-8", errors="replace")
+        try:
+            r1 = subprocess.run(["git", "add", os.path.relpath(fp, repo)],
+                                cwd=repo, capture_output=True, text=True,
+                                encoding="utf-8", errors="replace",
+                                timeout=_GIT_TIMEOUT_S,
+                                stdin=subprocess.DEVNULL)
+            r2 = subprocess.run(
+                ["git", "commit", "-q", "-m",
+                 f"interop(verifier): iter={it} verdict={verdict.get('verdict')} "
+                 f"passed={verdict.get('passed')} failed={verdict.get('failed')}"],
+                cwd=repo, capture_output=True, text=True,
+                encoding="utf-8", errors="replace",
+                timeout=_GIT_TIMEOUT_S, stdin=subprocess.DEVNULL)
+        except subprocess.TimeoutExpired:
+            # 超时**不吞**：如实记进既有错误面（与 rc≠0 同一条 commit_err），
+            # 不假装提交成功（issue #63）。
+            out["committed"] = False
+            out["commit_err"] = ("git 超时（%ss）已被 kill：%s" %
+                                 (_GIT_TIMEOUT_S, out_dir))
+            return out
         out["committed"] = r2.returncode == 0
         if r2.returncode != 0:
             out["commit_err"] = (r2.stderr or r1.stderr)[:200]

package/md_cg/lifecycle.py

@@ -103,6 +103,44 @@ def state_of(fm) -> str:
     return s if s in STATES else "active"
 
 
+# 生效条件：入参 e 为索引条目（或同形 frontmatter 副本）时返回 state_of(e) == "archived" 的布尔结果；缺 STATE_FIELD 或取值不在 STATES 时 state_of 回落 "active" ⇒ 返回 False。
+def is_archived(e) -> bool:
+    """默认检索剔除面＝本函数（判据单点）。
+
+    `archived` 的语义（模块 docstring :42）是「不再参与**默认检索**」——本函数是该
+    宣称的**唯一判据**，全部消费点共同引用（判据单点，多个消费点）：
+
+      · cg 检索面：`MdCGOS._candidates`（mdcos.py）——`MdCGSecure._candidates` 经
+        `super()` 覆盖叠加读可见性，故全部**检索类** cg 读 op（search / search_rrf /
+        recall / route…）都经它；
+      · stg 扫描面：`stg._scan_one`（stg.py，`_scan` 的逐条实现单点）——timeline /
+        anchors / consistency 三 op 的候选面同点覆盖（`relation` 面是显式 id 直读，
+        `state_chain` 走 append-only 台账，两者不经扫描面）；
+      · 会话续接注入面：`MdCGOS.session_recall`（mdcos.py）的四个取数段——会话要点
+        `_session_notes`、活跃目标 `goals`、任务台账 `tasks`、未解问题 `unresolved`
+        （`goals`/`tasks` 经 `_retired_by_id` 按 id 回查索引后交本判据）。该 op 是
+        「装配续接包注入上下文/回给调用方」的注入面，与检索面同属「退役即不再默认
+        回出」；它自持取数面（不经 `_candidates`），故单点接线（独立复核 2026-10-06
+        两轮实测：接线前 archived 要点摘要、未解问题正文、**活跃目标与任务卡**均经
+        该 op 照旧回出；`recent` 段是事件窗口、`self_state` 是只读快照卡，不含节点
+        条目，不涉退役）。
+
+    **fail-open**（缺键/非法值 → active）：存量节点不回填也照常参与检索
+    （存量零迁移、不误剔）；「不误剔」的另一半是**只剔 archived**——
+    converged / demoted 是**降权轴**，仍参与默认检索。
+
+    不适用条件（**不**消费本函数，故 archived 期间照常可达）：显式 id 直读
+    （`cg.get`）、审计面（`op=audit`）、工程台账的**显式管理查询面**
+    （`cg(op=goal, action=list)` / `cg(op=task, action=list)`；注意与消费面之别——
+    会话续接注入包内的对应段已按上表剔除，两者不冲突）、负记忆层
+    （rejected / unresolved 的覆盖标记面）、统计面（health / whoami / conformance）
+    ——「退役不删除、可显式恢复」的承诺要求它们在 archived 期间照常可达。
+    边界（已知未覆盖面，另立裁定）：基类 `MdCG.search`、`chain.adjacency` 拓扑面、
+    `subgraph.children_index/parents_index` 结构面、rust 检索内核。
+    """
+    return state_of(e) == "archived"
+
+
 # 生效条件：按 _RANK.get(dst, 0) > _RANK.get(src, 0) 判定，src 或 dst 不在 _RANK 键中时该侧按 0 参与比较。
 def is_downgrade(src: str, dst: str) -> bool:
     """是否向「更低」的状态迁移（active < converged < demoted < archived）。"""