@shgroup/dsh-serenity-hooks 1.58.2 → 1.59.0

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-serenity-hooks",
-  "version": "1.58.2",
+  "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";
@@ -15323,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,
@@ -15359,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, {
@@ -15380,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);
@@ -15393,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)) {
@@ -15406,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) {
@@ -15450,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,
@@ -15465,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, {
@@ -21816,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";
 /**
@@ -21892,6 +22208,7 @@ function newState() {
 		wss: null,
 		connections: 0,
 		applied: 0,
+		rejected: 0,
 		lastErrors: [],
 		disposers: []
 	};
@@ -21938,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}`);
 					});
@@ -21948,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,
@@ -22107,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.2",
+  "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": {