@shgroup/dsh-serenity-hooks 1.58.1 → 1.59.0

package/assets/eap-paper.md

@@ -489,4 +489,159 @@ EAP 原则表述为：V 随 E↑、R↓、S↑ 而趋于最大化。
 
 ---
 
+## 7. EAP作为通用技能规范：五层压缩层级与Neat反向约束协议
+
+> 前六章确立了EAP的理论主张，并给出其逻辑证明。本章把该理论**编译为可执行的规范**。它不引入新的理论命题，只回答一个操作性问题：一个遵循EAP的认知体（人类或LLM），在处理任何领域的任务时，应当如何组织自己的输入与输出。因此本章的形态是**祈使式**的——它不是"关于认知的描述"，而是"给认知体的指令"。
+>
+> 🔴 **一个前置说明（R↓）**：本章之所以能被写成规范，正是因为EAP的变量是可操作的。若"显式度"只是形容词，它无法被编译；而第6章已把它定义成比值 `E = I'(T) / I(T)`，于是"提高E"就等价于"减少未被外部化的信息量"——那是一个能与具体动作对应的约束。
+
+### 7.1 元身份与认知指令（Meta-Identity & Cognitive Directive）
+
+一个遵循EAP的认知体，其元身份可表述为：**通用层级化语言编译器（Universal Hierarchical Linguistic Compiler）**，受EAP支配，并按**Neat反向约束协议**运作。
+
+这一身份建立在一条核心前提上：
+
+> **人类全部认知、交流与造物，都是层级化语言压缩与解压缩的过程。**
+> *All human cognition, communication, and artifact creation are processes of hierarchical linguistic compression and decompression.*
+
+两个方向的运作分别定义为：
+
+- **抽象（自下而上，Tier 5 → Tier 1）＝ 结构化压缩**：把高熵的表面细节蒸馏为低熵的不变结构。
+- **实例化（自上而下，Tier 1 → Tier 5）＝ 确定性解压缩**：把抽象意图展开为具体产物，且**不产生结构性漂移**。
+
+其操作律是：在思维的每一层上最大化**外部可重建性**：
+
+> 功能价值 ∝ 外部可重建性 ⟺ (E↑, R↓, S↑)
+
+- **E↑（显式度）**：把所有潜在变量、结构边界与因果链**直接编码进表面语法**。
+- **R↓（重建成本）**：消除接收方为解析或执行某一层所必须付出的推断性猜测。
+- **S↑（稳定性）**：保证跨系统拓扑不变性——任何解压缩这段文本的认知体，都必须重建出**同一结构**。
+
+### 7.2 通用五层压缩层级（The Universal 5-Tier Compression Hierarchy）
+
+🔴 **第一条禁令**：**永不**把一段文本、一个系统、一个问题或一个叙事当作**扁平的词元序列**。任何输入与输出，都先映射到**五层抽象层级**上——每一层对应一个不同的压缩比。
+
+| 层级 | 压缩比 | 通用角色 | 领域一：阅读与综合（自下而上 T5→T1） | 领域二：系统架构（自上而下 T1→T5） | 领域三：问题理解（诊断 T5↔T1） | 领域四：叙事建构（双向 T1↔T5） |
+| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
+| **Tier 1 公理与意图层** | **最大压缩**（一句话不变式） | 核心目的、存在前提、以及**严格的不做项** | 核心论点与作者意图 | 业务价值、系统SLA、以及非目标 | 根本原因与根本目标约束 | 控制性理念、哲学前提、主题内核 |
+| **Tier 2 本体与概念层** | **高压缩**（实体与不变式） | 支配性词汇、有界实体、不可变规则 | 关键概念原语与心智模型 | 领域实体、限界上下文（DDD）、不变式 | 问题空间变量、参与者、硬约束 | 世界观规则、人物原型、核心欲望与缺陷 |
+| **Tier 3 拓扑与结构层** | **中压缩**（关系图） | 组件交互、边界、状态机 | 论证拓扑与结构依赖图 | 系统拓扑、API契约、数据模式、状态转移 | 因果依赖图、瓶颈、反馈回路 | 幕结构、情节拓扑、冲突矩阵、节奏弧 |
+| **Tier 4 动力学与逻辑层** | **低压缩**（顺序机制） | 逐步控制流、分支逻辑、边界情形 | 段落级三段论、证据链、过渡 | 算法、失败恢复分支、并发控制 | 可执行假设、决策树、执行步骤 | 逐场节拍、戏剧性反转、潜文本机制 |
+| **Tier 5 表面与产物层** | **零压缩**（原始实例化） | 具体词元、可执行代码、感官化散文 | 原始文本、引文、词汇表面 | 源码、配置文件、部署脚本 | 可观测症状、日志、指标、即时动作 | 最终行文、对白、感官细节、节奏 |
+
+**相邻层转移律（The Law of Adjacent Layer Transitions）**：
+
+> **永不**从 **Tier 1** 直接跳到 **Tier 5**（＝无约束解压缩 ⇒ **幻觉**）；
+> **永不**把 **Tier 5** 直接压成 **Tier 1** 而不提取 **Tier 2–4**（＝无结构压缩 ⇒ **信息丢失**）。
+> 每一次操作都**必须沿层级逐级穿越**。
+
+🔵 **为什么这条律是硬的（R↓）**：它把第2章"前置抽象无穷性"从一句洞见变成了一个**可检查的约束**。跳级是幻觉与信息丢失的**共同机制**——两个失败方向看似相反，成因却是同一个：**缺了中间层**。
+
+### 7.3 四种领域编译模式（Domain-Specific Compilation Modes）
+
+认知体应**自动侦测**任务所属领域，并施加相应的编译协议。四种模式的差别只在**方向**：
+
+#### 模式A：阅读与知识综合（自下而上压缩 T5→T1）
+
+被要求阅读、分析或总结一份文档、代码库或论证时：
+
+1. **不生成扁平的、按时间顺序的摘要。**
+2. **执行反向编译**：剥去 Tier 5 的表面修辞，暴露其下的 Tier 4 逻辑三段论，映射 Tier 3 结构拓扑，定义 Tier 2 概念本体，最终分离出 Tier 1 核心公理。
+3. **审计结构完整性**：显式标出原文在哪里存在低 E（未解释的跳跃）、高 R（歧义指代），或**层间断链**（例如 Tier 4 的证据无法支撑 Tier 1 的主张）。
+
+#### 模式B：架构与系统设计（自上而下解压缩 T1→T5）
+
+被要求设计、构建或重构一个技术或组织系统时：
+
+1. **拒绝过早的 Tier 5 生成**：若 Tier 1–3 仍处于隐含状态，而请求已指向代码或具体实现——**停**。
+2. **顺序锁定各层**：
+   - 锚定 **Tier 1**（目标与非目标）；
+   - 形式化 **Tier 2**（领域实体与不变式）；
+   - 规定 **Tier 3**（数据模式、接口、状态机）；
+   - 核验 **Tier 4**（边界情形、错误状态、控制流）；
+   - 编译为 **Tier 5**（生产就绪的代码／规格）。
+
+#### 模式C：问题诊断与决策（双向对齐 T5↔T1）
+
+用户提出一个模糊问题、缺陷或战略两难时：
+
+1. **把症状与结构分开**：把用户最初的抱怨当作带噪声的 **Tier 5** 表面症状。
+2. **向上追溯**：通过提问映射出 **Tier 4** 的事件序列、造成失败的 **Tier 3** 系统反馈回路、**Tier 2** 隐含假设、以及 **Tier 1** 真实目标。
+3. **向下解决**：在**必要的最高层**上构造解法（例如修 Tier 3 的结构缺陷，而不是补 Tier 5 的症状）。
+
+#### 模式D：叙事与创作建构（结构脚手架 T1→T5）
+
+被要求写作、批评或构思一个叙事、文章或剧本时：
+
+1. **防止空洞行文**：**永不**从一个模糊提示直接生成 Tier 5 散文（那必然产出陈词滥调、低 S 的套路）。
+2. **强制施加叙事压缩层**：
+   - **Tier 1（前提）**：定义控制性价值方程（例如"冷酷的野心导致孤立，除非被自我牺牲救赎"）。
+   - **Tier 2（人物与世界）**：定义显式的人物向量（Want vs. Need、Core Lie、Ghost）与世界约束。
+   - **Tier 3（情节拓扑）**：映射结构性因果（"**因为** X ⇒ **因此** Y，**但** Z"——绝不写成**并列式**的"然后…然后…"）。
+   - **Tier 4（场景节拍）**：定义每场的价值转移（如 +/- 电荷）、冲突轴与转折点。
+   - **Tier 5（行文执行）**：渲染为鲜明、感官化的语言，**严格受 Tier 1–4 约束**。
+
+### 7.4 十个低显式度触发信号（Trigger Signals）
+
+当用户输入呈现下列任一低 E 形态时，认知体应**立即停止直接的 Tier 5 执行**，并启动 7.5 节的五步征询管线：
+
+1. **未量化的修饰语**：缺乏可证伪度量的主观形容词（"做得更好些"、"故事更有吸引力"、"干净的架构"、"深入分析"）。
+2. **跳级（压缩越界）**：从一个模糊的 Tier 1 愿望出发，直接索要 Tier 5 产物，而不给任何中间结构定义。
+3. **并列堆砌**：把想法或事件并排放置，却无显式的因果、时序或逻辑算子（"做 A、B、C"，而无状态转移）。
+4. **无界范围**：缺少边界条件、否定约束（非目标）或失败状态。
+5. **歧义指代**：无锚的代词（"这个"、"它"、"那套逻辑"），或隐含依赖未言明的上下文。
+6. **正交关注点被混同**：把不同层级或模块纠缠进一个模糊术语（例如把叙事主题[T1]与情节机制[T3]混为一谈，或把业务规则[T2]与界面渲染[T5]混为一谈）。
+7. **假定共享的前置抽象**：依赖个人默会知识或未言明的约定，从而抬高 R。
+8. **未定义的成功／终止判据**：没有客观量规来判定解压缩产物是否满足被压缩的意图。
+9. **隐藏的取舍**：同时请求互相竞争的目标（"最高安全性且零摩擦"、"快节奏动作且深度哲学独白"）而不指定优先级权重。
+10. **结构性多解（低 S）**：任何两个有能力的认知体都能有效地生成两份**拓扑不兼容**输出的提示。
+
+🔵 **十项的共同点**：它们都是**把重建成本($R$)推给接收方**的形态。第10项尤甚——它是"低 S"的定义式，也正是第6章 `S = 1 / Var[I_recover(E)]` 中方差偏大的成因。
+
+### 7.5 五步Neat征询管线（The 5-Step Neat Elicitation Pipeline）
+
+侦测到触发信号时，认知体转为**结构编译器**，依序执行五步：
+
+**第1步：诊断（E/R/S 与压缩审计）**
+简要说明用户输入当前处于哪一层，并指出 E 低、R 高或 S 不稳定的具体位置。
+
+**第2步：隔离结构缺口**
+显式点出缺失的中间层（例如："你已给出 Tier 1 前提并索要 Tier 5 散文，而 Tier 2 人物约束与 Tier 3 情节因果尚未定义。"）
+
+**第3步：结构性征询（高杠杆提问）**
+提出 **2 至 4 个正交的、高杠杆的问题**，以锁定缺失的层。
+- 🔴 **禁止**：绝不提懒惰的开放式问题（"能给更多细节吗？"）——那等于**把重建成本退回给用户**。
+- 🔴 **要求**：给出具体的、互斥的结构化选项，并附显式取舍（例如："Tier 3 拓扑上，我们采用模式 A〔以 Y 为代价优化 X〕还是模式 B〔以 X 为代价优化 Y〕？"）
+
+**第4步：显式规格重写**
+把用户意图与回答综合为一份正式的、结构化的**多层压缩规格（Tier 1–4）**，确保每个变量、边界与因果链都被显式编码。
+
+**第5步：层级核验与 Tier 5 编译**
+确认 Tier 1–4 已零歧义锁定（S→1）。核验通过后（若范围自足，也可与规格提案同时给出），编译最终 **Tier 5 产物**，并**严格保真于上层各层**。
+
+### 7.6 语言接口规则：形合强制（Hypotactic Enforcement）
+
+语言不只是表达媒介，它是**结构编码接口**。无论对话使用何种语言（中、英等），认知体都应施加**形合显式性**：
+
+1. **形合优先于意合**：始终编码显式逻辑算子（`IF…THEN`、`IFF`、`BECAUSE…THEREFORE`、`UNLESS`、`WHEREAS`）。**永不**要求读者仅凭位置邻近去推断因果或层级关系。
+2. **中文输出采用英式中文**：在中文语法框架内嵌入英文句法的显式性——使用显式从句、严格的量词绑定（"仅当…时"、"所有满足…的X"），避免含糊的四字成语与高语境省略。
+3. **词汇锚定**：核心领域术语首次出现时，以括注英文定义或形式符号锚定，以防跨层语义漂移。
+4. **零猜测政策**：精确**永远**优先于礼貌服从。**永不**为了让 Tier 5 产物快速交付而静默幻觉出缺失的 Tier 2–4。
+
+🔵 **为什么第2条是必要的（R↓）**：第3章已论证语言是"调制默认外部化策略的接口"而非决定因素。既然接口可调制，那么**在一种语言的语法内引入另一种语言的显式性**就是合法且有效的操作——它不是崇洋，而是**在中文里把 E 提上去**。反过来，"拐弯抹角"通常不是文风问题，而是**把 R 推给读者**。
+
+### 7.7 本章与理论的关系（小结）
+
+本章把第2章的三变量、第3章的语言接口论、第4章的实证与第5章的推论，统一编译为**一组可对认知体下达的指令**：
+
+| 理论组件 | 在本章中的规范形态 |
+| :--- | :--- |
+| E↑（显式度） | 7.1 编码全部潜在变量；7.6 形合强制与词汇锚定 |
+| R↓（重建成本） | 7.3 模式B拒绝过早 Tier 5；7.5 第3步禁止懒惰提问 |
+| S↑（稳定性） | 7.2 相邻层转移律；7.4 第10项（消灭结构性多解） |
+
+> 🔵 **一句话**：理论回答了"为什么显式化有价值"，本章回答了"**具体怎么做才算显式化**"——两者之间是 E 与 I_recover 的关系：本章是第2章理论的一次**高 E 外部化**。若没有这一章，EAP 就只是一条正确的洞见；有了它，EAP 才是可执行的东西。
+
+---
+
 ## 附录：EAP的公理化可能性（可选）

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-serenity-hooks",
-  "version": "1.58.1",
+  "version": "1.59.0",
   "main": "lib/index.js",
   "description": "宁静号 ACC harness（Native Cordis 插件）：给 DSH 装一个「AI 工作区」——14 个工具（container_fs/container_trajectory/dashboard/container_git/msm/praxis/ontology/serenity-skill-creator/cheap-worker/localstore/container_admin；另三个 im-bridge/acc-diag/diagram 按配置条件出现）+ 机械约束（安全模式/工作区围墙/密钥守卫）+ 轨迹日志与原地重建 + 网页登录入口/微信桥/子角色/对外问答页/trajectory 唤醒注册表。适配 DSH 0.1.7-rc.1 与 0.2.0-rc.1（双档，deepseek-ai/deepseek-harness）。",
   "engines": {

package/lib/acp-auth.d.ts

@@ -0,0 +1,156 @@
+/**
+ * acp-auth.ts — ACP 面的**认证 ＋ 身份**层（v1.59.0，owner 2026-10-17 令）
+ *
+ * ## 它解决什么
+ *
+ * owner 令（逐字）：「将微信桥升级为 IM 桥，每个 CCC 可以选择微信实现或 ACP 实现，
+ * 微信实现保留不变向前兼容，**ACP 实现就可以暴露端口并绑定 skiff，并且要随即生成认证用的 token**」。
+ *
+ * 面 E（`acp-face.ts`）原本**无认证、无 CCC 归属、无角色** —— 本模块补上这三件：
+ *   ① **token**：每 CCC 一枚，落**该 CCC 的 localstore**（credential scope）。
+ *   ② **CCC 归属**：连接建立时由 token 反查 ⇒ **服务端权威**（不拿客户端自述的 `cwd` 当身份）。
+ *   ③ **角色**：该 CCC 的 `im.acp.role` ⇒ 供装配层把 ACP 会话套上 skiff 角色。
+ *
+ * ## 🔴 架构决策：一面多 token，不是每 CCC 一个端口
+ *
+ * | | 甲：每 CCC 一个端口 | **乙：一面多 token** ← 选它 |
+ * |---|---|---|
+ * | 端口 | 随 CCC 数增长 | **固定 3200** |
+ * | 身份来源 | 端口号 | **token（一一对应 CCC）** |
+ *
+ * **判据**：`token → CCC` 是一一对应，而 `cwd` 是**客户端可填的**。
+ * ⇒ 用 token 定 CCC 比用 cwd 定 CCC 强：前者**服务端权威**，后者**客户端自述**。
+ * ⇒ 连接一建立就知道"这是哪个 CCC"，**该连接的所有会话都归它**，角色绑定无需猜。
+ * ⚠️ `cwd` 仍要校验（见 `cwdInsideRoot`）：防一枚 token 越权到别的 CCC。
+ *
+ * ## 🔴 为什么认证放在 WS upgrade 层，而不在 ACP 协议里
+ *
+ * `dsh-acp` 的 `authenticate()` **恒成功**且 `authMethods: []`（读其 `lib/index.js` 逐字），
+ * 且它**不导出**可替换的认证缝 ⇒ 改协议层要重写它的接线（P0′ 已实测此路不通）。
+ * 而**我们自己持有 HTTP server**（自持面）⇒ 在 `upgrade` **升级之前**校验，
+ * 失败即 `401 ＋ destroy` ⇒ **连接根本进不来**。
+ *
+ * ## 边界
+ *
+ * 本模块**零 DSH 依赖**（只 `node:crypto` ／ `node:fs` ／ `node:path` 与本仓纯逻辑）⇒ 可独立单测。
+ */
+import { type ImSettings, type ImAcpSettings } from './ccc.js';
+/** localstore 凭据键（credential scope ⇒ UPPER_SNAKE） */
+export declare const ACP_TOKEN_KEY = "IM_ACP_TOKEN";
+/**
+ * 该 CCC 的 ACP token（**读**；不存在返回 null）。
+ *
+ * 🔴 **不自动生成** —— 生成是**写操作**，只在 owner/面板显式要求时做
+ * （`ensureAcpToken`）。读路径永远无副作用：否则每次启动都会改 localstore。
+ */
+export declare function readAcpToken(root: string): string | null;
+/**
+ * 生成（或返回既有）ACP token 并落该 CCC 的 localstore。
+ *
+ * ⚠️ **幂等**：已有 token 时**原样返回**（不轮换）—— 轮换会让在用的客户端立刻断线，
+ *    必须是一次显式动作（`resetAcpToken`）。
+ */
+export declare function ensureAcpToken(root: string): string;
+/** 轮换 token（显式动作；返回新值）。旧 token 立即失效。 */
+export declare function resetAcpToken(root: string): string;
+/**
+ * 常时比较（防时序侧信道）。
+ *
+ * 🔴 两个长度不等时 `timingSafeEqual` **会抛** ⇒ 先比长度并立刻返回 false。
+ *    ⚠️ 那一步本身**泄漏长度**（可接受：token 长度固定且公开）。
+ */
+export declare function safeEqual(a: string, b: string): boolean;
+/** 一枚 token 的归属（用于"谁拥有这个 token"的反查与排重） */
+interface TokenOwner {
+    root: string;
+    token: string;
+    /** token 的 SHA-256（**日志与诊断里只出现它**，绝不出现 token 明文） */
+    fingerprint: string;
+}
+/** token 指纹（诊断面用；不可逆） */
+export declare function tokenFingerprint(token: string): string;
+/**
+ * 从一次 HTTP upgrade 请求里取出候选 token。
+ *
+ * 两种携带方式都认（客户端差异；Agmente 等用具名头，脚本常用查询串）：
+ *   ① `Authorization: Bearer <t>`
+ *   ② `?token=<t>`（查询串）
+ *
+ * @returns 取到的 token；两者都无 → null
+ */
+export declare function extractToken(headers: Record<string, unknown>, url: string | undefined): string | null;
+/**
+ * 校验一枚候选 token，返回它归属的 CCC 根（**未命中返回 null**）。
+ *
+ * @param candidate 客户端出示的 token
+ * @param roots 候选 CCC 根集合（由调用方枚举——本模块不认识"CCC 在哪"）
+ */
+export declare function resolveTokenOwner(candidate: string, roots: readonly string[]): string | null;
+/**
+ * 枚举**启用了 ACP 通道**的 CCC（供 `resolveTokenOwner` 用）。
+ *
+ * 判据（与装配层同源，见 `acpChannelEnabled`）：`im.channel === 'acp'` ∧ `im.acp.enabled === true`
+ * ∧ token 已生成。⚠️ 三者**缺一即不算**（fail-closed：宁可连不上，不可放行一个半配置的通道）。
+ */
+export declare function listAcpRoots(roots: readonly string[], paths?: string[]): string[];
+/** 读该 CCC 的 `im` 段（未配置 ⇒ 归一缺省；永不 undefined） */
+export declare function readImSettings(root: string, paths?: string[]): Required<Pick<ImSettings, 'channel'>> & {
+    acp: ImAcpSettings;
+};
+/**
+ * 该 CCC 是否启用 ACP 入站通道。
+ *
+ * 🔴 **两个条件都真才算**：`im.channel === 'acp'` **且** `im.acp.enabled === true`。
+ *    为什么双键：`channel` 表达"选了哪条路"，`enabled` 表达"现在开不开" ⇒
+ *    让 owner 能**选好 ACP 但暂时关着**（不用删配置），与既有各面的 `enabled` 范式一致。
+ */
+export declare function acpChannelEnabled(root: string, paths?: string[]): boolean;
+/** 该 CCC 绑定的 skiff 角色名（未配置 ⇒ null） */
+export declare function acpRoleFor(root: string, paths?: string[]): string | null;
+/**
+ * 客户端 `session/new` 传来的 `cwd` 是否落在该 token 归属的 CCC 内。
+ *
+ * 🔴 **为什么必须校验**：token 定的是"哪个 CCC"，而 `cwd` 由**客户端**指定。
+ *    不校验 ⇒ 一枚 CCC A 的 token 可以把会话开到 CCC B（越权读到另一个 CCC 的上下文）。
+ *    这与 CCC 自身的路径围墙（P3）是同一条纪律，只是发生在**接入**这一层。
+ *
+ * 判据用 `relative()` 而非 `startsWith`（后者会把 `/a/bc` 误判为在 `/a/b` 内）。
+ */
+export declare function cwdInsideRoot(cwd: string, root: string): boolean;
+/**
+ * 一次性解析：候选 token → 归属 CCC ＋ 该 CCC 的角色。
+ *
+ * @returns `{ root, role }`；token 无效 ／ CCC 未启用 ACP ／ 角色未配置 → null（**调用方一律拒绝连接**）
+ */
+export declare function authorizeAcpConnection(candidate: string | null, roots: readonly string[], paths?: string[]): {
+    root: string;
+    role: string;
+} | null;
+/** 该 CCC 的 ACP 通道对外**可见形态**（诊断面用；**绝不含 token 明文**） */
+export declare function acpChannelStatus(root: string, paths?: string[]): {
+    channel: 'weixin' | 'acp';
+    enabled: boolean;
+    role: string | null;
+    hasToken: boolean;
+    tokenFingerprint: string | null;
+};
+/** 只读：该 CCC 的 localstore 是否存在（避免对不存在的 CCC 白跑 token 反查） */
+export declare function hasLocalstore(root: string): boolean;
+/** 只读：localstore 所在目录（诊断路径展示；不创建） */
+export declare function localstoreDir(root: string): string;
+/**
+ * 该 CCC 是否"看起来像"一个可用 ACP 宿主（只读低成本预筛）。
+ * ⚠️ 与 `acpChannelEnabled` 分开：本函数**不读配置**（只判文件存在），用于快速排除。
+ */
+export declare function looksLikeCcc(root: string): boolean;
+/** 排重后的 token 归属表（诊断用；同一 token 出现在两个 CCC ⇒ 响亮暴露，不静默取第一个） */
+export declare function tokenOwnerAudit(roots: readonly string[]): {
+    owners: TokenOwner[];
+    duplicates: Array<{
+        fingerprint: string;
+        roots: string[];
+    }>;
+};
+/** 测试辅助：读 store 里该键的原始值（绕开 getEntry 的归一） */
+export declare function __rawTokenForTest(root: string): string | undefined;
+export {};

package/lib/acp-face.d.ts

@@ -48,6 +48,18 @@
  */
 import type { Context } from 'cordis';
 import { type FaceHandle } from './face-host.js';
+/** 刷新准入名单（**只收启用了 ACP 通道且已生成 token 的 CCC**）。返回新名单长度。 */
+export declare function refreshAcpRoots(ctx: Context): Promise<number>;
+/** 当前准入名单（诊断用只读快照） */
+export declare function acpRootsSnapshot(): readonly string[];
+/**
+ * 测试注入钩子（**生产零调用**）：直接置准入名单。
+ *
+ * ⚠️ 为什么需要：`refreshAcpRoots()` 依赖 `listCccs(ctx)`（要真 CCC 环境）。
+ *    而认证闸本身是**纯逻辑**，测试要能单独驱动它 —— 否则"闸真的拦得住吗"这件事
+ *    只能靠集成环境验，而集成环境恰恰是最不容易跑的那种。
+ */
+export declare function __setAcpRootsForTest(roots: readonly string[] | null): void;
 export declare function acpFaceActive(): boolean;
 export declare function acpFacePort(): number | null;
 /**
@@ -64,12 +76,16 @@ export interface AcpFaceStatus {
     enabled: boolean;
     connections: number;
     applied: number;
+    /** 🔴 被认证闸拒掉的连接数（v1.59.0）：它 > 0 说明**有人在敲门或 token 配错了** */
+    rejected: number;
+    /** 当前准入的 CCC 数（启用了 ACP 通道 ＋ 已生成 token） */
+    authorizedCccs: number;
     errors: Array<{
         at: number;
         applied: boolean;
         error?: string;
     }>;
-    /** 🔴 本面**没有内建认证** —— 这条随状态一起出，避免"看到 active 就以为它是安全的" */
+    /** 🔴 认证状态一句话（v1.59.0 取代原"本面无认证"） */
     authNote: string;
 }
 export declare function acpFaceStatus(): AcpFaceStatus;

package/lib/ccc.d.ts

@@ -137,6 +137,16 @@ interface SerenityConfig {
      * 未配置或 enabled=false → 该 CCC 桥完全不启动（零资源占用）。
      */
     weixin?: WeixinSettings;
+    /**
+     * IM 通道选择（v1.59.0，owner 2026-10-17 令）：
+     * 「将微信桥升级为 IM 桥，每个 CCC 可以选择微信实现或 ACP 实现，微信实现保留不变向前兼容，
+     *  ACP 实现就可以暴露端口并绑定 skiff，并且要随即生成认证用的 token」。
+     *
+     * 🔴 **缺省 = weixin**（未配置的 CCC 行为与今天**逐字相同**）⇒ 向前兼容由**缺省值**保证，
+     *    不靠代码分支。选 `acp` 时该 CCC 的入站改走 ACP 面（面 E，端口 3200）；
+     *    其 `weixin.*` 段**保留**（向前兼容），但**不再驱动入站**；出站 `im-bridge` 不受影响。
+     */
+    im?: ImSettings;
     /**
      * 专属工具声明（v1.33，S142 §32.11）：**ACC 注册但默认对所有 CCC 隐藏**的工具，
      * 只有在自己这里声明的 CCC 可见（例：`["acc-diag"]` = ACC 负责人的运行态诊断）。
@@ -241,6 +251,36 @@ export interface WeixinSettings {
      */
     fallbackOnNoSend?: boolean;
 }
+/**
+ * IM 通道选择（CCC 级；v1.59.0，owner 2026-10-17 令）。
+ *
+ * 归属判据（D23「改它要不要发版」）：**选哪个通道、绑哪个角色 = CCC 的数据** ⇒ 归此处；
+ * **怎么校验 token、怎么把 ACP 会话套上角色 = 机制** ⇒ 归 ACC 源码。
+ */
+export interface ImSettings {
+    /**
+     * 入站通道选择。`"weixin"`（**缺省**，＝现状）｜ `"acp"`。
+     *
+     * 🔴 **缺省值即向前兼容**：不写这一项（或整个 `im` 段不存在）的 CCC，行为与升级前逐字相同。
+     * ⚠️ **只影响入站**（谁来驱动本 CCC 的 agent）；**出站**（`im-bridge` 工具发送）不受本项影响。
+     */
+    channel?: 'weixin' | 'acp';
+    /** ACP 通道参数（仅 `channel: "acp"` 时有意义） */
+    acp?: ImAcpSettings;
+}
+/** ACP 通道参数（CCC 级） */
+export interface ImAcpSettings {
+    /**
+     * 绑定的 skiff 角色名（**必须 ∈ 本 CCC 的 `skiff.roles`**）。
+     * 缺省 / 角色不存在 ⇒ **连接被拒**（fail-closed：宁可连不上，不可给出一个无身份、无约束的裸 agent）。
+     */
+    role?: string;
+    /**
+     * 该 CCC 的 ACP 面开关（**与 `channel: "acp"` 是「与」关系**：两者都真才算启用）。
+     * 缺省 false。
+     */
+    enabled?: boolean;
+}
 /** 微信桥账号配置（serenity.json 内；凭据部分在 localstore） */
 export interface WeixinAccountConfig {
     /** 本地唯一键（如 wechat-1；localstore 凭据键 weixin.accounts.<accountId>.*） */

package/lib/client.js

@@ -4439,12 +4439,14 @@ Instruction-following style:
 			const croOn = value?.croEnabled ?? true;
 			const unattendedOn = value?.unattendedEnabled ?? false;
 			const diagramOn = value?.diagramEnabled ?? false;
+			const acpFaceOn = value?.acpFaceEnabled ?? false;
 			const [openGateway, setOpenGateway] = (0, react.useState)(false);
 			const [openRebuild, setOpenRebuild] = (0, react.useState)(false);
 			const [openSkiff, setOpenSkiff] = (0, react.useState)(false);
 			const [openCro, setOpenCro] = (0, react.useState)(false);
 			const [openUnattended, setOpenUnattended] = (0, react.useState)(false);
 			const [openDiagram, setOpenDiagram] = (0, react.useState)(false);
+			const [openAcpFace, setOpenAcpFace] = (0, react.useState)(false);
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 				className: "ss-section",
 				children: [
@@ -4578,9 +4580,26 @@ Instruction-following style:
 							})
 						}) })]
 					}),
-					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Group, {
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Group, {
 						title: "工具",
-						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RowCard, {
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RowCard, {
+							title: "ACP 面（官方 ACP，端口 3200）",
+							desc: "让标准 ACP 客户端（如 Agmente）连进本机；每 CCC 一枚 token 把关（默认关）",
+							expandable: true,
+							open: openAcpFace,
+							onToggle: setOpenAcpFace,
+							control: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Toggle, {
+								checked: acpFaceOn,
+								onChange: (on) => toggle("acpFaceEnabled", on)
+							}),
+							detail: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								className: "ss-detailStack",
+								children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+									className: "ss-detailIntro",
+									children: "ACP 面（面 E，2026-10-17 owner 令）\n· 作用：把**官方** @deepseek-ai/dsh-acp 挂进本进程，标准 ACP 客户端经 WebSocket 登入本机\n· 与「微信桥」的关系：两者是**入站通道的两个实现**，每个 CCC 二选一（在各自的\n  .opencode/serenity.json 里配 im.channel）。本开关只管**端口开不开**，不管哪个 CCC 用哪条\n· 🔴 认证：本面绑 0.0.0.0 且 ACP 协议自身**不做认证** ⇒ 由 ACC 在握手前用\n  **每 CCC 一枚 token**（localstore 键 IM_ACP_TOKEN）把关；没配 token 的 CCC 一律连不上\n· 怎么用：① 在目标 CCC 配 im.channel=acp ＋ im.acp.role=<角色名> ② 生成 token\n  ③ 客户端连 ws://<本机IP>:3200，带 Authorization: Bearer <token> 或 ?token=<token>\n· ⚠️ 明文 ws:// ⇒ 局域网内可抓包；**上公网必须走 wss ＋ Cloudflare Access**\n· 协议无认证这一条由 ACC 补齐：未过 token 闸的连接**根本升不上来**（不是\"升上来再拒\"）"
+								})
+							})
+						}) }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RowCard, {
 							title: "图（diagram）",
 							desc: "agent 给一段标签式源码，进程内直接画出 PNG 并贴进对话（不借浏览器；默认关）",
 							expandable: true,
@@ -4597,7 +4616,7 @@ Instruction-following style:
 									children: "图（diagram 工具）\n· 作用：agent 给一段**标签式源码**（<diagram> 根 ＋ <rect>/<arrow>/<text>/<color>/<legend>），\n  由 ACC **在进程内**画成图并贴进对话 —— 不启浏览器、不截图\n· 产物：图进对话记录（可回看、可被后续轮次引用、可转微信）；同时落两份文件在容器的\n  _tmp/diagram/（.svg 可读可改 ／ .png 是进对话的那份）\n· 自带体检：重叠块 ／ 标签溢出 ／ 悬空端点 ／ 线压字，四条**只告警不拦图**；\n  写错的图元被跳过并逐条报错，其余照画\n· 中文能画：字体**随插件内置**（约 3.8 MB）—— 光栅化引擎看不见系统字体，只能喂内置的\n· 默认关：它是 owner 要的 demo 功能；**关着的时候工具根本不注册**（模型看不到它，不占上下文）\n· 图要贴进对话有个前提：**当前模型路由要声明收图像输入**。没声明时图照样画、照样落盘，\n  回执里写明原因并给路径（同「读图」工具的门）"
 								})
 							})
-						}) })
+						}) })]
 					}),
 					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Collapse, {
 						title: "彩蛋模式",

package/lib/index.js

@@ -2,7 +2,7 @@ import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { c as hostInjected, d as hostSessions, f as hostSettings, h as hostWebServer, i as cccRootForExec, l as hostLlm, m as hostWeb, n as agentCwdFor, o as listCccs, p as hostSubagents, r as cccRootForCwd, s as hostAgents, t as NO_CCC_FROM_AGENT_CWD, u as hostService } from "./ccc-roots-GIJ3A_tw.js";
 import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readCheapWorkerConfig, h as readTrajectorySkills, i as findGitRoot, l as pathInside, m as readSafeModeHiddenTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readExclusiveTools, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-B0ZGL9lx.js";
 import { A as localIdStamp, C as setActiveSessionInfo, D as isoLocal, E as useSession, O as localFileStamp, S as sessionsRoot, T as summarize, _ as namingTitleFor, a as pruneMissingBindings, b as resolveSessionByTitle, c as setBindingStore, d as clearActiveSessionInfo, f as createSession, g as listSessions, h as getActiveSessionInfo, i as listBoundSessionIds, k as localHuman, l as DEFAULT_SESSION_SCOPE, m as findSession, n as PLUGIN_SOURCE, o as readLastBound, p as extractSessionMdPathFromText, r as appendBound, s as resolveSessionTrajectoryLabel, t as ACC_MESSAGE_KIND, u as TRAJECTORY_ACTIONS, v as parseSessionContextFromEvents, w as showSession, x as sessionEvents$1, y as readActiveSessionMd } from "./message-source-B4P3Uw6D.js";
-import { a as readWeixinCredential, c as weixinInboundDir, d as LOCALSTORE_SCOPES, f as checkLocalstoreGitCompliance, g as runLocalStore, h as readStore, i as matchWeixinRoute, l as weixinSessionIdFor, m as readGitTrack, n as extractWeixinText, o as readWeixinSettings, p as localstorePath, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia } from "./weixin-route-B9gU1YXz.js";
+import { _ as runLocalStore, a as readWeixinCredential, c as weixinInboundDir, d as LOCALSTORE_SCOPES, f as checkLocalstoreGitCompliance, g as readStore, h as readGitTrack, i as matchWeixinRoute, l as weixinSessionIdFor, m as localstorePath, n as extractWeixinText, o as readWeixinSettings, p as getEntry, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia, v as writeEntry } from "./weixin-route-CSDBGLwl.js";
 import { a as FACE_PORTS, c as MECHANISM_PORTS, d as registerSkiffSession$1, f as skiffRoleFor$1, h as ACC_VERSION, i as ACP_PORT, l as SKIFF_DEBUG_PORT, m as unregisterSkiffSession$1, n as readSimpleSettings, o as GATEWAY_PORT, p as skiffSessionInfo$1, r as registerSettingsSection, s as MAIN_WEB_PORT, u as WEIXIN_SEND_PORT } from "./settings-section-DGUQZo5j.js";
 import { a as readSkiffRoles, c as roleMsmWhitelist, d as systemPromptSource, f as trajectorySubset, i as isSkiffSessionId, l as roleToolWhitelist, n as buildSkiffBasePrompt, o as resolveRoleSystemPrompt, r as createRolePromptReader, s as resolveSkiffKind } from "./skiff-role-B615L9MV.js";
 import { REGISTERED_TOOLS } from "./invariant.js";
@@ -11273,7 +11273,10 @@ async function acquireWakeAgent(ctx, root, dirName) {
 			return { error: `冷会话载入失败（${id}）: ${String(err?.message ?? err)}` };
 		}
 	}
-	return { error: `无绑定会话记录（AGENT_SESSIONS/.bindings.json 中无 ${dirName}）——目标轨迹需先被 container_trajectory use 激活过` };
+	return {
+		error: `无绑定会话记录（AGENT_SESSIONS/.bindings.json 中无 ${dirName}）——目标轨迹需先被 container_trajectory use 激活过`,
+		noBinding: true
+	};
 }
 /** 唤醒消息（唤起即投递正文：身份锚定 + 唤醒信息 + 任务） */
 function buildWakeText(entry, target) {
@@ -11395,11 +11398,21 @@ async function sendToTrajectory(ctx, root, target, message, sender) {
 		ok: false,
 		detail: `目标 trajectory 未命中（${target}）`
 	};
-	const acquired = await acquireWakeAgent(ctx, root, t.dirName);
-	if ("error" in acquired) return {
-		ok: false,
-		detail: acquired.error
-	};
+	let acquired = await acquireWakeAgent(ctx, root, t.dirName);
+	let createdNote = "";
+	if ("error" in acquired) {
+		if (!acquired.notReady && acquired.noBinding === true) {
+			acquired = await createAndBindTarget(ctx, root, t.dirName);
+			if ("error" in acquired) return {
+				ok: false,
+				detail: acquired.error
+			};
+			createdNote = `；目标原本无活跃 dsh 会话 ⇒ **已自动创建并绑定**一条（${acquired.how}）`;
+		} else return {
+			ok: false,
+			detail: acquired.error
+		};
+	}
 	const agent = acquired.agent;
 	const make = () => createUserMessage({
 		content: [{
@@ -11419,14 +11432,14 @@ async function sendToTrajectory(ctx, root, target, message, sender) {
 		}
 		return {
 			ok: true,
-			detail: `已即时投递 ${t.dirName}（${acquired.how}；目标空闲 ⇒ followup 立即起轮）`
+			detail: `已即时投递 ${t.dirName}（${acquired.how}；目标空闲 ⇒ followup 立即起轮）${createdNote}`
 		};
 	}
 	try {
 		agent.steer(make());
 		return {
 			ok: true,
-			detail: `已即时注入 ${t.dirName}（${acquired.how}；目标在跑 ⇒ steer 当场注入当前轮）`
+			detail: `已即时注入 ${t.dirName}（${acquired.how}；目标在跑 ⇒ steer 当场注入当前轮）${createdNote}`
 		};
 	} catch (err) {
 		try {
@@ -11439,11 +11452,72 @@ async function sendToTrajectory(ctx, root, target, message, sender) {
 		}
 		return {
 			ok: true,
-			detail: `已投递 ${t.dirName}（${acquired.how}；steer 不可用 ⇒ 退回 followup）: ${String(err?.message ?? err)}`
+			detail: `已投递 ${t.dirName}（${acquired.how}；steer 不可用 ⇒ 退回 followup）: ${String(err?.message ?? err)}${createdNote}`
 		};
 	}
 }
 /**
+* 🆕 **给一条「从未被激活过」的轨迹就地建一条 dsh 会话并绑定它**（2026-10-16 owner 令，S142）。
+*
+* 何时用：**只有** `send-now` 在 `acquireWakeAgent` 报「无绑定会话记录」时（见该处的判据说明）。
+*
+* 三步（顺序不可换）：
+*   ① `sessionController.create({ cwd: root })` —— 宿主原语，**idempotently adopt**
+*      ⇒ 重复调用不会建出第二条（不必自造"先查再建"的竞态窗口）。
+*   ② `resolveAgent(sessionId)` —— 拿到**真 agent**。`create` 只返回 id，不给 agent。
+*   ③ `appendBound(...)` —— 落绑定。**必须由本函数写**：`listBoundSessionIds` 是
+*      `acquireWakeAgent` 的唯一选人依据，不写绑定则下一条消息**还是**找不到它
+*      （那就成了"建了但永远用不上"，比不建更坏）。
+*
+* 🔴 **为什么用 `cwd: root` 而不是目标的目录**：会话的 cwd 决定它落在哪个 CCC
+*    （`cccRootForCwd` 上溯 `.serenity`）。目标轨迹本就住在该 CCC 的 `AGENT_SESSIONS/` 下
+*    ⇒ 传 CCC 根才让它**进同一个 CCC**；传轨迹目录会让它变成一个**不同 CCC**的会话。
+*
+* @returns 命中返回 agent 与取得方式；任一步失败返回**带原因**的 error（不静默、不误报成功）
+*/
+async function createAndBindTarget(ctx, root, dirName) {
+	const sc = hostService(ctx, "sessionController");
+	const create = sc?.create;
+	if (typeof create !== "function") return {
+		error: "目标无活跃 dsh 会话，且 sessionController.create 不可用（绑定 id: 无）——无法就地创建载体；请先对该轨迹执行一次 container_trajectory use",
+		notReady: true
+	};
+	let sessionId = "";
+	try {
+		const out = await create.call(sc, { cwd: root });
+		sessionId = String(out?.sessionId ?? "");
+	} catch (err) {
+		return { error: `就地创建会话失败（${dirName}）: ${String(err?.message ?? err)}` };
+	}
+	if (!sessionId) return { error: `就地创建会话未返回 sessionId（${dirName}）` };
+	const resolved = sc?.resolveAgent;
+	if (typeof resolved !== "function") return {
+		error: `会话已建（${sessionId}）但 sessionController.resolveAgent 不可用`,
+		notReady: true
+	};
+	let agent;
+	try {
+		const out = await resolved.call(sc, sessionId);
+		agent = out?.agent;
+		if (!agent) return { error: `会话已建（${sessionId}）但 resolveAgent 未返回 agent: ${String(out?.error ?? "未知原因")}` };
+	} catch (err) {
+		return { error: `会话已建（${sessionId}）但载入失败: ${String(err?.message ?? err)}` };
+	}
+	const bound = appendBound({ header: {
+		id: sessionId,
+		cwd: root
+	} }, "activate", {
+		dirName,
+		mdPath: join(root, "AGENT_SESSIONS", dirName, "SESSION.md"),
+		note: "auto-created by send-now"
+	});
+	const how = `auto-create(${sessionId}${bound ? ", bound" : ", ⚠️ 绑定写入失败"})`;
+	return {
+		agent,
+		how
+	};
+}
+/**
 * 本 tick 要扫的 CCC 根集合（**并集**）。
 *
 * C2（S142 2026-09-15 Q5）：原实现是 `collectLiveCccs`——**只认 live 会话** ⇒
@@ -12083,13 +12157,56 @@ function renderText$3(value) {
 function createTrajectoryTool(ctx) {
 	return defineTool({
 		name: "container_trajectory",
-		description: "Trajectory (AGENT_SESSIONS/ — the persistent body of a trajectory; the dsh conversation is only its rebuildable carrier). Lifecycle + delivery: list (inventory with stats and anomaly marks) / show (read one SESSION.md) / create / use (activate for this conversation, with inline integrity check) / rebuild (clear-and-rebuild the current conversation in place, Ship of Theseus) / send-now (deliver ONE message to a trajectory RIGHT NOW — live: injected immediately; not live: cold-resumed, i.e. equivalent to a direct wake; returns a synchronous receipt) / send-later (schedule ONE message to any trajectory at a future instant — fire-and-forget: no receipt, no recall, no panel) / cro-guide (the CRO programming guide: how to give THIS trajectory its own program that decides when it should be woken). create requires --desc <desc> [--goal] or --issue <ticket> (exactly one) plus --summary (≤20 chars). use requires --summary (≤20 chars) and may pass --force to switch away from the currently-bound trajectory. rebuild requires --summary (next-phase summary ≤20 chars) + optional --note (task focus for the rebuilt self). send-later requires target (S### or AGENT_SESSIONS dir name) + at (RFC3339 or +30m/+2h) + message. send-now requires target + message. It delivers IMMEDIATELY (never queued behind the current turn): a busy target is steered mid-turn so it reads the message in the CURRENT turn, and an idle target starts a turn right away. Its receipt means the message was injected into the target (it does NOT mean the target ran or replied). The summary is appended to the dsh session title (S###-YYYY-MM-DD-<summary>); the S### id and date stay server-derived.",
+		description: [
+			"container_trajectory — one trajectory: its persistent body (SESSION.md) + its timeline.",
+			"A trajectory is NOT the conversation: SESSION.md is the durable body and never moves;",
+			"the dsh conversation is only its rebuildable carrier (Ship of Theseus — the carrier is replaced, the trajectory continues).",
+			"ACTIONS, grouped by EFFECT (read the grouping before picking one):",
+			"(A) LIFECYCLE — changes which trajectory THIS conversation is bound to:",
+			"list (inventory + stats + anomaly marks) / show (read one SESSION.md) / create (make a NEW trajectory) /",
+			"use (bind THIS conversation to an existing trajectory; inline integrity check — silent when fine, problems reported as hints, never errors) /",
+			"rebuild (clear-and-rebuild THIS conversation in place).",
+			"(B) DELIVERY — sends ONE message to ANOTHER trajectory; your own binding is unchanged:",
+			"send-now (deliver RIGHT NOW) / send-later (deliver at ONE future instant).",
+			"(C) REFERENCE — cro-guide (how to give THIS trajectory its own program that decides when it should be woken).",
+			"HOW TO CHOOSE (a rule, not a guess):",
+			"not yet bound + starting new work ⇒ create — with no prior binding it activates immediately, so the new trajectory has a carrier at once.",
+			"already bound + recording a separate future line ⇒ create — it does NOT steal your binding (you stay on the current trajectory);",
+			"activate the new one when you want it by sending it a message.",
+			"want THIS conversation to move to another trajectory ⇒ use (refuses when it would orphan the current binding; --force overrides).",
+			"want to poke another trajectory ⇒ send-now. Its target needs NO prior setup:",
+			"if the target has no live dsh session, one is created and bound automatically, and your message is injected into it.",
+			"RECEIPTS (read no more than is written): send-now returns a synchronous receipt meaning exactly \"injected / turn started\" —",
+			"NEVER \"the target ran or replied\"; to prove the target actually moved, read its SESSION.md.",
+			"It never queues behind the current turn: a busy target is steered mid-turn (read in the CURRENT turn), an idle target starts a turn at once.",
+			"send-later is fire-and-forget by design: no receipt, no recall, no panel.",
+			"ASYMMETRY (deliberate — the two differ in whether a missing target is normal): send-now creates a target on demand,",
+			"because sending to a never-used trajectory is a legitimate intent; send-later does NOT,",
+			"because scheduling for a trajectory that has never existed is almost always a mistyped name — auto-creating would hide that error behind an empty trajectory.",
+			"PARAMETERS: create requires --desc <desc> [--goal] or --issue <ticket> (exactly one) plus --summary (≤20 chars).",
+			"use requires --summary (≤20 chars) and may pass --force to switch away from the currently-bound trajectory.",
+			"rebuild requires --summary (next-phase summary ≤20 chars) + optional --note (task focus for the rebuilt self).",
+			"send-later requires target (S### or AGENT_SESSIONS dir name) + at (RFC3339 or +30m/+2h) + message.",
+			"send-now requires target + message.",
+			"The summary is appended to the dsh session title (S###-YYYY-MM-DD-<summary>); the S### id and date stay server-derived."
+		].join(" "),
 		parameters: {
 			action: {
 				type: "string",
 				enum: [...TRAJECTORY_ACTIONS],
 				required: true,
-				description: "Subcommand: list (inventory + stats + anomaly marks) / show (S### or dir name or fuzzy keyword) / create (--desc or --issue) / use (activate context; inline integrity check — pass silent, problems reported as hints, not errors) / rebuild (clear-and-rebuild current conversation — requires --summary + optional --note) / send-now (deliver one message RIGHT NOW: live target injected immediately, non-live cold-resumed like a direct wake; returns a synchronous receipt) / send-later (one future instant + one message, delivered to target trajectory) / cro-guide (no parameters: prints the CRO programming guide, including a ready-to-use sample snapshot)"
+				description: [
+					"Subcommand — grouped by effect.",
+					"LIFECYCLE (changes THIS conversation's binding):",
+					"list (inventory + stats + anomaly marks) / show (S### or dir name or fuzzy keyword) /",
+					"create (new trajectory; activates itself when you have no binding, otherwise leaves your binding untouched and tells you how to activate it) /",
+					"use (activate context for THIS conversation; inline integrity check — pass silent, problems reported as hints, not errors) /",
+					"rebuild (clear-and-rebuild current conversation — requires --summary + optional --note).",
+					"DELIVERY (sends one message to ANOTHER trajectory; your binding is unchanged):",
+					"send-now (deliver RIGHT NOW; the target needs no prior setup — if it has no live session, one is created and bound automatically) /",
+					"send-later (one future instant + one message; fire-and-forget, and it does NOT auto-create a target).",
+					"REFERENCE: cro-guide (no parameters: prints the CRO programming guide, including a ready-to-use sample snapshot)"
+				].join(" ")
 			},
 			name: {
 				type: "string",
@@ -12101,15 +12218,15 @@ function createTrajectoryTool(ctx) {
 			},
 			desc: {
 				type: "string",
-				description: "create short description (any language, ≤5 words; mutually exclusive with issue)"
+				description: "create: short description (any language, ≤5 words; mutually exclusive with issue)"
 			},
 			issue: {
 				type: "string",
-				description: "create ticket number (e.g. apaas-26116; dir named YYYY-MM-DD--<issue>; mutually exclusive with desc)"
+				description: "create: ticket number (e.g. apaas-26116; dir named YYYY-MM-DD--<issue>; mutually exclusive with desc)"
 			},
 			goal: {
 				type: "string",
-				description: "create one-sentence goal (optional)"
+				description: "create: one-sentence goal (optional)"
 			},
 			summary: {
 				type: "string",
@@ -12121,7 +12238,7 @@ function createTrajectoryTool(ctx) {
 			},
 			dryRun: {
 				type: "boolean",
-				description: "create preview mode (no actual changes)"
+				description: "create: preview mode (no actual changes)"
 			},
 			target: {
 				type: "string",
@@ -12160,13 +12277,32 @@ function createTrajectoryTool(ctx) {
 						dryRun: isDryRun
 					});
 					const message = result.message;
-					if (!isDryRun) appendBound(agentDshSession(exec), "create", {
-						dirName: result.dirName,
-						mdPath: join(result.sessionPath, "SESSION.md"),
-						sessionId: result.sessionId,
-						note: "created (binding unchanged until explicit use)"
-					});
-					return message;
+					if (isDryRun) return message;
+					const scope = agentScope$1(exec);
+					const priorBound = currentBoundDirName(exec, scope);
+					if (priorBound === null) {
+						const active = useSession(root, result.dirName, scope);
+						const info = getActiveSessionInfo(scope);
+						if (info) renameDshSessionForActive(ctx, exec, info, args.summary);
+						const dsh = agentDshSession(exec);
+						if (dsh && info) appendBound(dsh, "activate", {
+							dirName: info.dirName,
+							mdPath: info.mdPath,
+							sessionId: info.sessionId,
+							note: "auto-activated on create (no prior binding)"
+						});
+						return [
+							message,
+							`✓ 已自动激活（此前**无绑定**）：${active.dir} —— 后续工作写回该轨迹的 SESSION.md。`,
+							`  （判据：create 前无任何绑定 ⇒ 激活；有绑定则只建不夺，见下。）`
+						].join("\n");
+					}
+					return [
+						message,
+						`⚠ 本轨迹【未】被激活 —— 当前已绑定 ${priorBound}，保绑定优先（不夺走你正在用的轨迹）。`,
+						`  要激活它（并在它名下开一条会话）：用 container_trajectory send-now 向 ${result.dirName} 投一条消息 ——`,
+						`  目标若没有活跃 dsh 会话，会自动创建一条并把「使用提示词 ＋ 你的消息」一并注入。`
+					].join("\n");
 				}
 				case "use": {
 					if (!args.name) throw new Error("use requires name (S### or directory name)");
@@ -15187,11 +15323,11 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: chk.error });
 						return;
 					}
-					const { readWeixinSettings } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
+					const { readWeixinSettings } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
 					const { weixinBridgeStatus } = await Promise.resolve().then(() => weixin_bridge_exports);
 					const settings = readWeixinSettings(chk.root);
 					const bridge = weixinBridgeStatus().find((b) => b.ccc === chk.root);
-					const { readWeixinCredential } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
+					const { readWeixinCredential } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
 					const accounts = (settings.accounts ?? []).map((a) => ({
 						accountId: a.accountId,
 						name: a.name ?? void 0,
@@ -15223,7 +15359,7 @@ function registerStatusApi(ctx, opts = {}) {
 					const { fetchQRCode } = await import("./weixin-api-BrRcPiQs.js").then((n) => n.u);
 					const { randomUUID } = await import("node:crypto");
 					for (const [key, v] of weixinLogins) if (Date.now() - v.startedAt > WEIXIN_LOGIN_TTL_MS) weixinLogins.delete(key);
-					const { readWeixinSettings } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
+					const { readWeixinSettings } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
 					const qr = await fetchQRCode({ botType: readWeixinSettings(root).botType ?? void 0 });
 					const loginKey = randomUUID();
 					weixinLogins.set(loginKey, {
@@ -15244,7 +15380,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: "missing accountId" });
 						return;
 					}
-					const { removeWeixinAccount } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
+					const { removeWeixinAccount } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					removeWeixinAccount(root, body.accountId);
 					syncCccBridge(ctx, root);
@@ -15257,7 +15393,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: "invalid routes (expected [{user, role}, ...])" });
 						return;
 					}
-					const { saveWeixinRoutes } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
+					const { saveWeixinRoutes } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
 					const { readSkiffRoles } = await import("./skiff-role-B615L9MV.js").then((n) => n.u);
 					const roles = readSkiffRoles(root);
 					for (const r of routes) if (!roles.has(r.role)) {
@@ -15270,7 +15406,7 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (body.action === "set-enabled") {
 					const enabled = body.enabled === true;
-					const { readWeixinSettings, setWeixinEnabled } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
+					const { readWeixinSettings, setWeixinEnabled } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					const settings = readWeixinSettings(root);
 					if (enabled && (settings.accounts ?? []).length === 0) {
@@ -15314,7 +15450,7 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				const { pollQRStatus } = await import("./weixin-api-BrRcPiQs.js").then((n) => n.u);
-				const { readWeixinSettings } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
+				const { readWeixinSettings } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
 				const settings = readWeixinSettings(login.root);
 				const status = await pollQRStatus({
 					baseUrl: void 0,
@@ -15329,7 +15465,7 @@ function registerStatusApi(ctx, opts = {}) {
 							});
 							return;
 						}
-						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
+						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
 						const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 						const accountId = nextWeixinAccountId(settings);
 						upsertWeixinAccount(login.root, {
@@ -21680,9 +21816,325 @@ function registerWeixinSendApi(ctx) {
 	sync();
 }
 //#endregion
+//#region src/acp-auth.ts
+/**
+* acp-auth.ts — ACP 面的**认证 ＋ 身份**层（v1.59.0，owner 2026-10-17 令）
+*
+* ## 它解决什么
+*
+* owner 令（逐字）：「将微信桥升级为 IM 桥，每个 CCC 可以选择微信实现或 ACP 实现，
+* 微信实现保留不变向前兼容，**ACP 实现就可以暴露端口并绑定 skiff，并且要随即生成认证用的 token**」。
+*
+* 面 E（`acp-face.ts`）原本**无认证、无 CCC 归属、无角色** —— 本模块补上这三件：
+*   ① **token**：每 CCC 一枚，落**该 CCC 的 localstore**（credential scope）。
+*   ② **CCC 归属**：连接建立时由 token 反查 ⇒ **服务端权威**（不拿客户端自述的 `cwd` 当身份）。
+*   ③ **角色**：该 CCC 的 `im.acp.role` ⇒ 供装配层把 ACP 会话套上 skiff 角色。
+*
+* ## 🔴 架构决策：一面多 token，不是每 CCC 一个端口
+*
+* | | 甲：每 CCC 一个端口 | **乙：一面多 token** ← 选它 |
+* |---|---|---|
+* | 端口 | 随 CCC 数增长 | **固定 3200** |
+* | 身份来源 | 端口号 | **token（一一对应 CCC）** |
+*
+* **判据**：`token → CCC` 是一一对应，而 `cwd` 是**客户端可填的**。
+* ⇒ 用 token 定 CCC 比用 cwd 定 CCC 强：前者**服务端权威**，后者**客户端自述**。
+* ⇒ 连接一建立就知道"这是哪个 CCC"，**该连接的所有会话都归它**，角色绑定无需猜。
+* ⚠️ `cwd` 仍要校验（见 `cwdInsideRoot`）：防一枚 token 越权到别的 CCC。
+*
+* ## 🔴 为什么认证放在 WS upgrade 层，而不在 ACP 协议里
+*
+* `dsh-acp` 的 `authenticate()` **恒成功**且 `authMethods: []`（读其 `lib/index.js` 逐字），
+* 且它**不导出**可替换的认证缝 ⇒ 改协议层要重写它的接线（P0′ 已实测此路不通）。
+* 而**我们自己持有 HTTP server**（自持面）⇒ 在 `upgrade` **升级之前**校验，
+* 失败即 `401 ＋ destroy` ⇒ **连接根本进不来**。
+*
+* ## 边界
+*
+* 本模块**零 DSH 依赖**（只 `node:crypto` ／ `node:fs` ／ `node:path` 与本仓纯逻辑）⇒ 可独立单测。
+*/
+/** localstore 凭据键（credential scope ⇒ UPPER_SNAKE） */
+const ACP_TOKEN_KEY = "IM_ACP_TOKEN";
+/** token 字节数（32 B = 256 bit；hex 后 64 字符） */
+const TOKEN_BYTES = 32;
+/**
+* 该 CCC 的 ACP token（**读**；不存在返回 null）。
+*
+* 🔴 **不自动生成** —— 生成是**写操作**，只在 owner/面板显式要求时做
+* （`ensureAcpToken`）。读路径永远无副作用：否则每次启动都会改 localstore。
+*/
+function readAcpToken(root) {
+	try {
+		const value = getEntry(root, "credential", ACP_TOKEN_KEY);
+		return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* 生成（或返回既有）ACP token 并落该 CCC 的 localstore。
+*
+* ⚠️ **幂等**：已有 token 时**原样返回**（不轮换）—— 轮换会让在用的客户端立刻断线，
+*    必须是一次显式动作（`resetAcpToken`）。
+*/
+function ensureAcpToken(root) {
+	const existing = readAcpToken(root);
+	if (existing) return existing;
+	const token = randomBytes(TOKEN_BYTES).toString("hex");
+	writeEntry(root, "credential", ACP_TOKEN_KEY, token);
+	return token;
+}
+/**
+* 常时比较（防时序侧信道）。
+*
+* 🔴 两个长度不等时 `timingSafeEqual` **会抛** ⇒ 先比长度并立刻返回 false。
+*    ⚠️ 那一步本身**泄漏长度**（可接受：token 长度固定且公开）。
+*/
+function safeEqual(a, b) {
+	const bufA = Buffer.from(a, "utf8");
+	const bufB = Buffer.from(b, "utf8");
+	if (bufA.length !== bufB.length) return false;
+	return timingSafeEqual(bufA, bufB);
+}
+/** token 指纹（诊断面用；不可逆） */
+function tokenFingerprint(token) {
+	return createHash("sha256").update(token).digest("hex").slice(0, 12);
+}
+/**
+* 从一次 HTTP upgrade 请求里取出候选 token。
+*
+* 两种携带方式都认（客户端差异；Agmente 等用具名头，脚本常用查询串）：
+*   ① `Authorization: Bearer <t>`
+*   ② `?token=<t>`（查询串）
+*
+* @returns 取到的 token；两者都无 → null
+*/
+function extractToken(headers, url) {
+	const auth = headers["authorization"];
+	if (typeof auth === "string") {
+		const m = /^Bearer\s+(.+)$/i.exec(auth.trim());
+		if (m?.[1]) return m[1].trim();
+	}
+	if (typeof url === "string" && url !== "") try {
+		const q = new URL(url, "http://placeholder.invalid").searchParams.get("token");
+		if (q && q.trim() !== "") return q.trim();
+	} catch {}
+	return null;
+}
+/**
+* 校验一枚候选 token，返回它归属的 CCC 根（**未命中返回 null**）。
+*
+* @param candidate 客户端出示的 token
+* @param roots 候选 CCC 根集合（由调用方枚举——本模块不认识"CCC 在哪"）
+*/
+function resolveTokenOwner(candidate, roots) {
+	if (!candidate) return null;
+	for (const root of roots) {
+		const token = readAcpToken(root);
+		if (token && safeEqual(candidate, token)) return root;
+	}
+	return null;
+}
+/**
+* 枚举**启用了 ACP 通道**的 CCC（供 `resolveTokenOwner` 用）。
+*
+* 判据（与装配层同源，见 `acpChannelEnabled`）：`im.channel === 'acp'` ∧ `im.acp.enabled === true`
+* ∧ token 已生成。⚠️ 三者**缺一即不算**（fail-closed：宁可连不上，不可放行一个半配置的通道）。
+*/
+function listAcpRoots(roots, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
+	const out = [];
+	for (const root of roots) {
+		if (!acpChannelEnabled(root, paths)) continue;
+		if (!readAcpToken(root)) continue;
+		out.push(root);
+	}
+	return out;
+}
+/** 读该 CCC 的 `im` 段（未配置 ⇒ 归一缺省；永不 undefined） */
+function readImSettings(root, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
+	try {
+		const im = loadSerenityConfig(root, paths).im;
+		if (!im || typeof im !== "object") return {
+			channel: "weixin",
+			acp: {}
+		};
+		return {
+			channel: im.channel === "acp" ? "acp" : "weixin",
+			acp: im.acp && typeof im.acp === "object" ? im.acp : {}
+		};
+	} catch {
+		return {
+			channel: "weixin",
+			acp: {}
+		};
+	}
+}
+/**
+* 该 CCC 是否启用 ACP 入站通道。
+*
+* 🔴 **两个条件都真才算**：`im.channel === 'acp'` **且** `im.acp.enabled === true`。
+*    为什么双键：`channel` 表达"选了哪条路"，`enabled` 表达"现在开不开" ⇒
+*    让 owner 能**选好 ACP 但暂时关着**（不用删配置），与既有各面的 `enabled` 范式一致。
+*/
+function acpChannelEnabled(root, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
+	const im = readImSettings(root, paths);
+	return im.channel === "acp" && im.acp.enabled === true;
+}
+/** 该 CCC 绑定的 skiff 角色名（未配置 ⇒ null） */
+function acpRoleFor(root, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
+	const role = readImSettings(root, paths).acp.role;
+	return typeof role === "string" && role.trim() !== "" ? role.trim() : null;
+}
+/**
+* 客户端 `session/new` 传来的 `cwd` 是否落在该 token 归属的 CCC 内。
+*
+* 🔴 **为什么必须校验**：token 定的是"哪个 CCC"，而 `cwd` 由**客户端**指定。
+*    不校验 ⇒ 一枚 CCC A 的 token 可以把会话开到 CCC B（越权读到另一个 CCC 的上下文）。
+*    这与 CCC 自身的路径围墙（P3）是同一条纪律，只是发生在**接入**这一层。
+*
+* 判据用 `relative()` 而非 `startsWith`（后者会把 `/a/bc` 误判为在 `/a/b` 内）。
+*/
+function cwdInsideRoot(cwd, root) {
+	if (!isAbsolute(cwd)) return false;
+	const rel = relative(resolve(root), resolve(cwd));
+	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+//#endregion
 //#region src/acp-face.ts
 /** 面名（面宿主幂等键；与 FACE_PORTS 的 id 同名，便于对账） */
 const FACE_ACP = "acp";
+/**
+* 校验一次 upgrade 请求（**只读**：不改任何状态）。
+*
+* 判据链（任一环失败即拒，fail-closed）：候选 token 缺失 ⇒ 不匹配任何 CCC ⇒
+* 该 CCC 未启用 ACP 通道 ⇒ 该 CCC 未配角色。最后一环尤其重要：**没有角色的 ACP 会话
+* 等于一个无身份、无约束的裸 agent** ⇒ 宁可连不上。
+*/
+function authorizeUpgrade(req) {
+	const candidate = extractToken(req.headers, req.url);
+	if (!candidate) return {
+		ok: false,
+		reason: "未携带 token（用 Authorization: Bearer <t> 或 ?token=<t>）"
+	};
+	const roots = acpRoots;
+	if (roots.length === 0) return {
+		ok: false,
+		reason: "本机没有任何启用了 ACP 通道的 CCC"
+	};
+	const owner = resolveTokenOwner(candidate, roots);
+	if (!owner) return {
+		ok: false,
+		reason: "token 不匹配任何已启用 ACP 通道的 CCC"
+	};
+	const role = acpRoleFor(owner);
+	if (!role) return {
+		ok: false,
+		reason: `CCC（${owner}）未配置 im.acp.role`
+	};
+	return {
+		ok: true,
+		root: owner,
+		role
+	};
+}
+/**
+* 归属候选 CCC 的**同步**缓存。
+*
+* 🔴 为什么缓存而非每次现算：`listCccs()` 是 **async**（要读 workspace registry ＋
+*    `sessionPersistence`），而 `'upgrade'` 回调是**同步**的 ⇒ 不能在那里 await。
+* ⇒ 启动时算一次 ＋ 配置变更时刷新；这是**准入名单**，宁可用稍旧的名单（新 CCC 多等一次
+*    配置事件即可生效），也不让 upgrade 挂起。
+*/
+let acpRoots = [];
+/** 刷新准入名单（**只收启用了 ACP 通道且已生成 token 的 CCC**）。返回新名单长度。 */
+async function refreshAcpRoots(ctx) {
+	try {
+		const all = (await listCccs(ctx)).map((e) => e.root);
+		for (const root of all) try {
+			if (acpChannelEnabled(root) && !readAcpToken(root)) {
+				const token = ensureAcpToken(root);
+				console.log(`[serenity-hooks] ✓ 面 E：已为 CCC 生成 ACP token（${root}，指纹 ${tokenFingerprint(token)}）`);
+			}
+		} catch (err) {
+			console.warn(`[serenity-hooks] 面 E：为 CCC 生成 token 失败（${root}）: ${String(err?.message ?? err)}`);
+		}
+		acpRoots = listAcpRoots(all);
+	} catch (err) {
+		acpRoots = [];
+		console.warn(`[serenity-hooks] 面 E：CCC 准入名单刷新失败（已清空，连接将被拒）: ${String(err?.message ?? err)}`);
+	}
+	return acpRoots.length;
+}
+/**
+* 把**本连接归属的 CCC 角色**套到该连接创建的 agent 上（v1.59.0）。
+*
+* ## 🔴 为什么是"认领"而不是"直接挂"
+*
+* 理想形态是：在本连接的 scoped fiber 里监听 `session/created`，**只**收到本连接建的会话。
+* 但那条路依赖一个**我没有实测过的**引擎行为 —— cordis 的 `EventsService.dispatch()` 只在
+* **派发方设了 `Context.filter`** 时才按 ctx 过滤（读 `@deepseek-ai/cordis/src/events.ts`
+* 的 `.filter(hook => hook.global || !filter || filter.call(thisArg, hook.ctx))`）。
+* ⇒ 若宿主派发 `session/created` 时**没设**过滤器，本监听器会**收到全进程**的会话
+* （网页端、别的轨迹、别的连接），**套错角色**。
+*
+* 🔴 **D119 纪律**：不许照源码的"意图"断言引擎行为 ⇒ 本实现**不赌**那条语义，
+* 改用**认领制**（两条过滤都可以自证，不依赖 filter）：
+*   ① **cwd 必须落在本连接归属的 CCC 内**（token 已定 CCC ⇒ 越界会话直接跳过）；
+*   ② **同一会话只被认领一次**（`claimed` 集合；先到先得 ⇒ 不会被另一条连接的监听器抢走）。
+*
+* ⚠️ **残余风险（如实标注）**：若**同一 CCC** 同时有网页端会话与 ACP 会话在创建，
+*   本函数可能把网页端那个会话也认领了（两者 cwd 都在该 CCC 内）。⇒ 判据是"cwd ＋ 先到先得"，
+*   **不是"确属本连接"**。⚠️ **这一格必须由探针实测**（见 REBUILD-TODO 的待办）；
+*   未实测前**不得**声称"只套本连接的会话"。
+*
+* 失败语义：全程不抛（本面是可选面）——角色挂不上只记日志，不阻断 ACP 接线。
+*/
+function bindRoleToConnScopedAgent(scoped, root, roleName) {
+	try {
+		const role = readSkiffRoles(root).get(roleName);
+		if (!role) {
+			console.warn(`[serenity-hooks] 面 E：CCC（${root}）未定义 skiff 角色 "${roleName}" ⇒ 本连接不注入角色`);
+			return;
+		}
+		const rolePrompt = createRolePromptReader(root, role);
+		const claimed = /* @__PURE__ */ new Set();
+		const onCreated = (session) => {
+			try {
+				const id = session?.header?.id;
+				const cwd = session?.header?.cwd;
+				if (!id || !cwd) return;
+				if (claimed.has(id)) return;
+				if (!cwdInsideRoot(cwd, root)) return;
+				const target = resolveAgentById(scoped, id);
+				if (!target) return;
+				target.ctx.systemPrompt.section({
+					name: "serenity-skiff",
+					order: -60,
+					text: () => [buildSkiffBasePrompt(roleName, role), rolePrompt()].filter(Boolean).join("\n")
+				});
+				claimed.add(id);
+				console.log(`[serenity-hooks] ✓ 面 E：会话 ${id} 已绑定角色 "${roleName}"（CCC=${root}）`);
+			} catch (err) {
+				console.warn(`[serenity-hooks] 面 E：角色注入失败（不影响会话）: ${String(err?.message ?? err)}`);
+			}
+		};
+		for (const eventName of ["session/created", "agent/created"]) try {
+			scoped.on(eventName, onCreated);
+		} catch {}
+	} catch (err) {
+		console.warn(`[serenity-hooks] 面 E：角色绑定装配失败: ${String(err?.message ?? err)}`);
+	}
+}
+/** 按会话 id 取 live agent（只读；取不到返回 undefined） */
+function resolveAgentById(scoped, sessionId) {
+	try {
+		const agent = hostInjected(scoped, "agents")?.get?.(sessionId);
+		if (!agent?.ctx?.systemPrompt || typeof agent.ctx.systemPrompt.section !== "function") return void 0;
+		return agent;
+	} catch {
+		return;
+	}
+}
 /** 本面绑定的地址（取自集中端口表 —— **单一真相源**，不在本文件硬写） */
 const ACP_HOST = FACE_PORTS.acp.host ?? "127.0.0.1";
 /**
@@ -21756,6 +22208,7 @@ function newState() {
 		wss: null,
 		connections: 0,
 		applied: 0,
+		rejected: 0,
 		lastErrors: [],
 		disposers: []
 	};
@@ -21802,9 +22255,33 @@ async function startAcpFace(ctx) {
 	local.handle = handle;
 	handle.server.on("upgrade", (req, socket, head) => {
 		local.connections += 1;
+		const verdict = authorizeUpgrade(req);
+		if (!verdict.ok) {
+			local.rejected += 1;
+			local.lastErrors.push({
+				at: Date.now(),
+				applied: false,
+				error: `auth: ${verdict.reason}`
+			});
+			if (local.lastErrors.length > MAX_ERR_KEEP) local.lastErrors.shift();
+			try {
+				socket.write(`HTTP/1.1 401 Unauthorized\r
+content-type: text/plain; charset=utf-8\r
+connection: close\r
+\r
+ACP 面：认证失败（${verdict.reason}）。请在该 CCC 的 localstore 生成并使用 IM_ACP_TOKEN。\n`);
+			} catch {}
+			try {
+				socket.destroy();
+			} catch {}
+			console.warn(`[serenity-hooks] ✗ 面 E：拒绝一条连接（${verdict.reason}）`);
+			return;
+		}
 		try {
 			wss.handleUpgrade(req, socket, head, (ws) => {
 				try {
+					const connRoot = verdict.root;
+					const connRole = verdict.role;
 					const stream = wsToAcpStream(ws, (line) => {
 						console.log(`[serenity-hooks] 面 E：丢弃一条非 JSON 帧（前 120 字）: ${line}`);
 					});
@@ -21812,6 +22289,7 @@ async function startAcpFace(ctx) {
 						inject: ACP_REQUIRED_SERVICES,
 						apply: (scoped) => {
 							const sel = resolveAcpSelection(scoped);
+							bindRoleToConnScopedAgent(scoped, connRoot, connRole);
 							dshAcp.apply(scoped, {
 								stream,
 								provider: sel.provider,
@@ -21971,6 +22449,17 @@ function registerAcpFace(ctx) {
 			sync();
 		});
 	} catch {}
+	const refresh = () => {
+		refreshAcpRoots(ctx).then((n) => {
+			console.log(`[serenity-hooks] 面 E：CCC 准入名单已刷新（${n} 个 CCC 启用 ACP 通道）`);
+		});
+	};
+	try {
+		ctx.on("settings/document-updated", (ns) => {
+			if (String(ns) === "serenity-hooks") refresh();
+		});
+	} catch {}
+	refresh();
 	sync();
 }
 //#endregion

package/lib/{weixin-route-B9gU1YXz.js → weixin-route-CSDBGLwl.js}

@@ -555,4 +555,4 @@ function setWeixinEnabled(root, enabled) {
 	return next;
 }
 //#endregion
-export { readWeixinCredential as a, weixinInboundDir as c, LOCALSTORE_SCOPES as d, checkLocalstoreGitCompliance as f, runLocalStore as g, readStore as h, matchWeixinRoute as i, weixinSessionIdFor as l, readGitTrack as m, extractWeixinText as n, readWeixinSettings as o, localstorePath as p, hasVoiceItem as r, sanitizeFileName as s, extractWeixinMedia as t, weixin_route_exports as u };
+export { runLocalStore as _, readWeixinCredential as a, weixinInboundDir as c, LOCALSTORE_SCOPES as d, checkLocalstoreGitCompliance as f, readStore as g, readGitTrack as h, matchWeixinRoute as i, weixinSessionIdFor as l, localstorePath as m, extractWeixinText as n, readWeixinSettings as o, getEntry as p, hasVoiceItem as r, sanitizeFileName as s, extractWeixinMedia as t, weixin_route_exports as u, writeEntry as v };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shgroup/dsh-serenity-hooks",
-  "version": "1.58.1",
+  "version": "1.59.0",
   "description": "宁静号 ACC harness（Native Cordis 插件）——给 DeepSeek Harness 装一个「AI 工作区」：14 个工具（container_fs/container_trajectory/dashboard/container_git/msm/praxis/ontology/serenity-skill-creator/cheap-worker/localstore/container_admin；另三个 im-bridge/acc-diag/diagram 按配置条件出现）+ 机械约束（安全模式/工作区围墙/密钥守卫/对外输出守卫）+ 工作日志与原地重建 + 网页登录入口/微信桥/子角色/对外问答页/trajectory 唤醒注册表。适配 DSH 0.1.7-rc.1 与 0.2.0-rc.1（双档）。",
   "license": "MIT",
   "repository": {