@shgroup/dsh-serenity-hooks 1.81.0 → 1.83.0

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-serenity-hooks",
-  "version": "1.81.0",
+  "version": "1.83.0",
   "main": "lib/index.js",
   "description": "宁静号 ACC harness（Native Cordis 插件）：给 DSH 装一个「AI 工作区」——14 个工具（container_fs/cognitive_trajectory/dashboard/container_git/msm/praxis/ontology/serenity-skill-creator/cheap-worker/localstore/container_admin；另三个 im-bridge/acc-diag/diagram 按配置条件出现）+ 机械约束（安全模式/工作区围墙/密钥守卫）+ 认知轨迹日志与原地重建 + 网页登录入口/IM 桥/认知轨迹唤醒注册表。轨迹声明 = 轨迹目录下的 trajectory.json（约束面 + 旧标识 uid + CRO 机器绑定 cro.host；旧名 trajectory-constraint.json / skiff.json 仍在读取族里）；轨迹提示词 = 轨迹目录下的 PROMPT.md（一条轨迹「是谁、按什么章程工作」，所有轨迹通用，追加在容器层与质量层之后，不替换它们）。适配 DSH 0.1.7-rc.1 / 0.2.0-rc.1 / 0.2.1-rc.1（三档，deepseek-ai/deepseek-harness）。",
   "engines": {

package/lib/im/bridge.d.ts

@@ -29,6 +29,12 @@ import { type WeixinMessage } from './ilink.js';
 import { resolveInboundTarget, manualOutputFallbackNeeded, type ResolvedInboundTarget } from './inbound-event.js';
 export { manualOutputFallbackNeeded, resolveInboundTarget };
 export type { ResolvedInboundTarget };
+/** 记下最近一次入站带来的 `context_token`（**只存非空**；空串会把好票覆盖成坏票） */
+export declare function rememberContextToken(accountId: string, userId: string, token: string | undefined): void;
+/** 取该用户最近一次的 `context_token`（没有 ⇒ `undefined`，调用方按"裸发"处理并如实回执） */
+export declare function recallContextToken(accountId: string, userId: string): string | undefined;
+/** 测试辅助：清空 context_token 缓存（生产零调用；与 resetWeixinTypingCache 同款） */
+export declare function resetWeixinContextCache(): void;
 /** 测试辅助：清空 typing_ticket 缓存（生产零调用） */
 export declare function resetWeixinTypingCache(): void;
 /**

package/lib/im/guard.d.ts

@@ -51,13 +51,35 @@ export declare function noteManualOutputSession(sessionId: string, session: Manu
 export declare function forgetManualOutputSession(sessionId: string): void;
 /** 是否手动模式会话（测试/诊断用） */
 export declare function isManualOutputSession(sessionId: string): boolean;
-/** 本轮是否已成功发送（测试/诊断用；桥在每轮结束时读它决定是否兜底） */
-export declare function hasSentThisTurn(sessionId: string): boolean;
 /**
- * 桥：**每轮开始时**清空本会话的"已发送"标记（turn 边界由桥掌握——v1.30.17）。
- * 闸门侧不再于 turn-stopping 结算清空，否则桥读不到本轮结果、无法兜底。
+ * 本轮是否已成功发送。
+ *
+ * @param turn 期望的轮号（`agent/turn-stopping` 的 `payload.turn`）。
+ *   - **省略** ⇒ 旧语义："这个会话发过就算"（测试与桥的兜底判定用）。
+ *   - **给了** ⇒ 按轮比：只有"**这一轮**发的"才算。
+ *   - **任一侧取不到轮号**（记录是 `null`，或 `turn` 传了 `null`）⇒ **偏向"发过"**。
+ *     🔴 方向是刻意的：误判"没发"的代价 = 打回 + 重复回答（用户看到两轮，本缺陷本尊）；
+ *     误判"发过"的代价 = 少打回一次（用户可能真没收到一条）。前者已经发生过、后者尚未。
+ */
+export declare function hasSentThisTurn(sessionId: string, turn?: number | null): boolean;
+/**
+ * 🔴 **桥不再调用本函数**（2026-10-21）。
+ *
+ * 旧语义 `clearSentThisTurn(sessionId)` = "来了新消息就当这个会话没发过"，
+ * 它**连正在跑那一轮的证据一起抹掉** —— 这正是"同一条消息被处理两轮"的根因：
+ * `12:08:25 发送成功 → 12:08:56 新入站(抹) → 12:09:19 那一轮 turn-stopping 判"没发" ⇒ 打回`。
+ *
+ * ## 现在的分工（判据只有一处：轮号）
+ *
+ * - **置位**：`tools/post-execute` 发送成功 ⇒ 记下**当前轮号**（`currentTurnOf`）。
+ * - **判定**：`agent/turn-stopping` 拿 `payload.turn` 与记录比对（`hasSentThisTurn`）。
+ * - **陈旧**：靠"轮号不等"自然淘汰 —— 上一轮发的记录，在下一轮 stopping 时天然不匹配。
+ *   ⇒ **不再需要任何"清空"动作**，也就不存在"清错人的记录"这件事。
+ *
+ * 本函数只留给**测试与显式重置**（如切换手动/自动模式）。`turn` 给定时按轮清，
+ * 是给诊断用的窄口子，生产路径不调用。
  */
-export declare function clearSentThisTurn(sessionId: string): void;
+export declare function clearSentThisTurn(sessionId: string, turn?: number | null): void;
 /** 闸门是否装配成功（未装配 → 桥不做兜底：宁可静默也不冒重复发送的风险） */
 export declare function isWeixinOutputGuardActive(): boolean;
 /**

package/lib/im/inbound-event.d.ts

@@ -124,6 +124,11 @@ export declare function resolveInboundTarget(ctx: Context, input: {
         trajectory: string;
     } | null;
 }): Promise<ResolvedInboundTarget | null>;
+declare function acquireSessionLock(key: string): Promise<() => void>;
+/** 测试/诊断用：当前有几条会话仍持有锁位（0 = 全部释放） */
+export declare function __sessionLockCountForTest(): number;
+/** 测试专用：直接拿真锁（不复制实现 —— 实现换形状时本导出会先炸，不会静默失效） */
+export declare const __acquireSessionLockForTest: typeof acquireSessionLock;
 /**
  * **一条入站消息的主流程**（通道中立）。
  *
@@ -165,3 +170,4 @@ export declare function manualOutputFallbackNeeded(input: {
     sentThisTurn: boolean;
     answer: string;
 }): boolean;
+export {};

package/lib/index.js

@@ -4,7 +4,7 @@ import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as
 import { A as sessionEvents, B as isoLocal, C as listSessions, E as parseTrajectoryCode, F as trajectoryDescOf, H as localHuman, I as useSession, L as TRAJECTORY_FILENAME, M as setActiveSessionInfo, N as showSession, O as readTrajectoryUid, P as summarize, R as TRAJECTORY_LEGACY_FILENAMES, S as listActiveTrajectories, T as parseSessionContextFromEvents, U as localIdStamp, V as localFileStamp, _ as createSession, a as readTrajectoryConstraintAt, b as getActiveSessionInfo, c as trajectoryConstraintForSession, f as COGNITIVE_TRAJECTORY_ACTIONS, g as clearActiveSessionInfo, h as archiveSession, j as sessionsRoot, k as resolveSessionByTitle, m as UID_FILENAME, n as isTrajectoryConstrained, o as readTrajectoryConstraintByCode, r as listTrajectoryConstraints, s as replacesDefaultIdentity, t as TRAJECTORY_CONSTRAINT_FILENAME, v as extractSessionMdPathFromText, w as namingTitleFor, y as findSession, z as readTrajectoryFile } from "./profile-CiRWh2a2.js";
 import { n as checkLocalstoreGitCompliance, o as readStore, s as runLocalStore, t as LOCALSTORE_SCOPES } from "./service-DDmHSglV.js";
 import { _ as resolveConstraintSystemPrompt, a as listBoundSessionIds, d as constraintCognitiveTrajectory, f as constraintSystemPromptSource, g as profileWriteWhitelist, h as profileToolWhitelist, i as carrierState, l as TRAJECTORY_CONSTRAINT_HINT, n as PLUGIN_SOURCE, o as readLastBound, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, t as ACC_MESSAGE_KIND, v as ACC_VERSION, y as findPackageRoot } from "./message-source-CfqdGIi2.js";
-import { A as buildResourceIndex, C as verifyPassword, D as recordToolUsage, E as verifyTotpCode, F as hasTrajectoryPrompt, M as isSafeSkillName, N as truncateContent, O as REFERENCE_DIR, P as TRAJECTORY_PROMPT_FILENAME, S as toWire, T as MECHANISM_PORTS, _ as registerEntrySkillSectionGlobal, a as trajectoryConstraintFor, b as projectKnownWorkspaces, c as trajectoryWorkspaceMdPath, d as CHEAP_WORKER_GUIDE, f as providerAvailabilityError, g as registerEntrySkillSection, h as registerCognitiveTrajectorySkillSection, i as getTrajectoryAgent, j as buildResourceNameSuffix, k as SKILL_ONTOLOGY_FILE, l as unregisterTrajectorySession, m as splitModel, n as createTrajectoryAgent, o as trajectoryConstraintMsmGate, p as requireWhitelistedModel, r as ensureWorkspacePromptSection, s as trajectoryConstraintParticipates, t as askTrajectory, u as workspaceCognitiveTrajectoryLine, v as applyWirePatch, w as FACE_PORTS, x as readAdvancedSettings, y as migrateLegacyLocalstore } from "./session-KBRbYb52.js";
+import { A as buildResourceIndex, C as verifyPassword, D as recordToolUsage, E as verifyTotpCode, F as hasTrajectoryPrompt, M as isSafeSkillName, N as truncateContent, O as REFERENCE_DIR, P as TRAJECTORY_PROMPT_FILENAME, S as toWire, T as MECHANISM_PORTS, _ as registerEntrySkillSectionGlobal, a as trajectoryConstraintFor, b as projectKnownWorkspaces, c as trajectoryWorkspaceMdPath, d as CHEAP_WORKER_GUIDE, f as providerAvailabilityError, g as registerEntrySkillSection, h as registerCognitiveTrajectorySkillSection, i as getTrajectoryAgent, j as buildResourceNameSuffix, k as SKILL_ONTOLOGY_FILE, l as unregisterTrajectorySession, m as splitModel, n as createTrajectoryAgent, o as trajectoryConstraintMsmGate, p as requireWhitelistedModel, r as ensureWorkspacePromptSection, s as trajectoryConstraintParticipates, t as askTrajectory, u as workspaceCognitiveTrajectoryLine, v as applyWirePatch, w as FACE_PORTS, x as readAdvancedSettings, y as migrateLegacyLocalstore } from "./session-BF4C3hJL.js";
 import { n as hasSessionLogById, r as sessionsRootDir } from "./cleanup-C-92qnDs.js";
 import { n as readSimpleSettings, r as registerSettingsSection } from "./settings-Dj4_ppTC.js";
 import { REGISTERED_TOOLS } from "./invariant.js";
@@ -9461,15 +9461,51 @@ async function createAndBindTarget(ctx, root, dirName) {
 		createdAsUser: true
 	});
 	const openingNote = deliverCarrierOpening(agent, buildCarrierOpening(parseTrajectoryCode(dirName) ?? dirName, trajectoryDescOf(dirName))) ? ", opening-as-user" : ", ⚠️ 开场白未投递";
+	const titleNote = renameCarrierTitle(ctx, agent, root, dirName);
 	const wsNote = workspaceId !== void 0 ? "" : await attachToWorkspace(ctx, root, sessionId);
 	const viaNote = workspaceId !== void 0 ? ", via-workspaceId(=用户同一形态)" : ", via-cwd+attach";
-	const how = `auto-create(${sessionId}${bound.ok ? ", bound" : `, ⚠️ 绑定写入失败（${bound.code}）`}${viaNote}${openingNote}${wsNote})`;
+	const how = `auto-create(${sessionId}${bound.ok ? ", bound" : `, ⚠️ 绑定写入失败（${bound.code}）`}${viaNote}${openingNote}${titleNote}${wsNote})`;
 	return {
 		agent,
 		how
 	};
 }
 /**
+* 把刚建的载体会话标题**钉成与 `use` 同一形态**（2026-10-21，owner 报「标题不规范」）。
+*
+* ## 为什么单独成函数
+*
+* 它是**全仓第二个**写会话标题的点（第一个是 `use`/`rebuild` 的 `renameDshSessionOnUse`）。
+* 集中在一处，将来若要改命名规则，判据仍在 `namingTitleFor` 一个地方。
+*
+* ## 三者顺序不可换
+*
+* 必须在 ③b（投开场白）**之后**调用：
+* - 开场白让 `titleInput.count` > 0，是标题得以成立的前提；
+* - 放在之后还有**降级好处**：万一 `rename` 失败，宿主自己的 fallback 标题仍在
+*   （难看但存在），而不是两者皆无。
+*
+* @returns 回执片段（成功 `, titled` ／ 失败 `, ⚠️ 标题未写（原因）`）—— **必须出声**，
+*   否则"标题没写"会表现成"这条轨迹就是这名字"（D186：守卫可以拒绝，但不许不出声）。
+*/
+function renameCarrierTitle(ctx, agent, root, dirName) {
+	try {
+		const titles = hostService(ctx, "sessionTitle");
+		if (!titles || typeof titles.rename !== "function") return ", ⚠️ 标题未写（sessionTitle 不可用）";
+		const session = agent.session;
+		if (!session || typeof session !== "object") return ", ⚠️ 标题未写（无 session）";
+		const title = namingTitleFor({
+			sessionId: parseTrajectoryCode(dirName) ?? dirName,
+			dirName,
+			mdPath: join(root, "AGENT_SESSIONS", dirName, "SESSION.md")
+		});
+		titles.rename(session, title);
+		return ", titled";
+	} catch (err) {
+		return `, ⚠️ 标题未写（${String(err?.message ?? err)}）`;
+	}
+}
+/**
 * 把刚建的会话挂进 **cwd 所属的那个工作区**（2026-10-17 缺陷修复）。
 *
 * 🔴 **为什么必须我们自己做（宿主源码取证，不是推断）**：
@@ -18997,10 +19033,23 @@ function installWeixinAccountImpl(d) {
 }
 const manualSessions = /* @__PURE__ */ new Map();
 /**
-* 本轮是否已成功发送（**由桥在每轮开始时清空** `clearSentThisTurn`；闸门只置位不清空——
-* v1.30.17 起桥要在 `askTrajectory` 返回后读它决定是否兜底，故 turn-stopping 不再结算清空）。
+* 「已发送」记账 —— 值是**发送发生时的轮号**（`null` = 取不到轮号，退化为旧语义）。
+*
+* ## 🔴 为什么必须是「轮号」而不是一个布尔（2026-10-21 实测缺陷）
+*
+* 旧形态是 `Set<sessionId>`：桥在**每条入站一到达**就 `clearSentThisTurn()`（`inbound-event.ts`），
+* 而闸门只在 `tools/post-execute` 置位、`turn-stopping` 只读。
+* ⇒ **一个还在跑的轮，它"我已经发了"的证据会被后到的那条入站抹掉。**
+*
+* 现场时刻线（真机，12:08~12:10）：`12:08:25` 发送成功 → `12:08:56` 新入站（抹）→
+* `12:09:19` 那一轮的 `turn-stopping` 读空 ⇒ 判"没发" ⇒ 打回 ⇒ 模型重答。
+* 用户看到的就是"同一条消息被处理了两轮"。
+*
+* ⇒ 记**轮号**之后：抹除操作可以问"我要抹的这一发，是不是**当前这一轮**发的"；
+*   `turn-stopping` 也可以问"这一发是不是**我这一轮**发的"。两处都从"是不是同一轮"出发，
+*   而不是从"这个会话有没有发过"出发。
 */
-const sentThisTurn = /* @__PURE__ */ new Set();
+const sentTurn = /* @__PURE__ */ new Map();
 /** 连续打回计数（成功发送即清零） */
 const rebukeCounts = /* @__PURE__ */ new Map();
 /** 闸门是否装配成功（v1.30.17：桥据此判断能否信任"未发送"这一判定——未装配时不兜底，防重复发送） */
@@ -19013,19 +19062,25 @@ function noteManualOutputSession(sessionId, session) {
 /** 桥：非手动模式 / 会话失效 → 注销（闸门随之失效，零干预） */
 function forgetManualOutputSession(sessionId) {
 	manualSessions.delete(sessionId);
-	sentThisTurn.delete(sessionId);
+	sentTurn.delete(sessionId);
 	rebukeCounts.delete(sessionId);
 }
-/** 本轮是否已成功发送（测试/诊断用；桥在每轮结束时读它决定是否兜底） */
-function hasSentThisTurn(sessionId) {
-	return sentThisTurn.has(sessionId);
-}
 /**
-* 桥：**每轮开始时**清空本会话的"已发送"标记（turn 边界由桥掌握——v1.30.17）。
-* 闸门侧不再于 turn-stopping 结算清空，否则桥读不到本轮结果、无法兜底。
+* 本轮是否已成功发送。
+*
+* @param turn 期望的轮号（`agent/turn-stopping` 的 `payload.turn`）。
+*   - **省略** ⇒ 旧语义："这个会话发过就算"（测试与桥的兜底判定用）。
+*   - **给了** ⇒ 按轮比：只有"**这一轮**发的"才算。
+*   - **任一侧取不到轮号**（记录是 `null`，或 `turn` 传了 `null`）⇒ **偏向"发过"**。
+*     🔴 方向是刻意的：误判"没发"的代价 = 打回 + 重复回答（用户看到两轮，本缺陷本尊）；
+*     误判"发过"的代价 = 少打回一次（用户可能真没收到一条）。前者已经发生过、后者尚未。
 */
-function clearSentThisTurn(sessionId) {
-	sentThisTurn.delete(sessionId);
+function hasSentThisTurn(sessionId, turn) {
+	if (!sentTurn.has(sessionId)) return false;
+	if (turn === void 0) return true;
+	const recorded = sentTurn.get(sessionId) ?? null;
+	if (recorded === null || turn === null) return true;
+	return recorded === turn;
 }
 /** 闸门是否装配成功（未装配 → 桥不做兜底：宁可静默也不冒重复发送的风险） */
 function isWeixinOutputGuardActive() {
@@ -19075,6 +19130,29 @@ function buildManualOutputRebuke(session) {
 	].join("\n");
 }
 /**
+* 从 `tools/post-execute` / 会话事件里取**当前轮号**（取不到 ⇒ `null`）。
+*
+* 为什么要费这个劲：修"同一条消息处理两轮"的判据是「这一发是不是**我这一轮**发的」，
+* 而 `tools/post-execute` 的 `exec` 上**不一定**带 turn（宿主形状随版本变）。
+* ⇒ 三级兜底：① `exec.turn` ② `agent.session` 的最后一个 `turn/start` ③ `null`（退化为旧语义）。
+* ⛔ `null` 时**绝不**当成"发过了/没发过"的强判据 —— 见 `hasSentThisTurn` 的降级说明。
+*/
+function currentTurnOf(exec, agent) {
+	const direct = exec?.turn;
+	if (typeof direct === "number" && Number.isFinite(direct)) return direct;
+	const events = agent?.session;
+	const list = typeof events?.snapshotEvents === "function" ? events.snapshotEvents() : events?.events;
+	if (!Array.isArray(list)) return null;
+	for (let i = list.length - 1; i >= 0; i--) {
+		const e = list[i];
+		if (e?.type === "turn/start") {
+			const t = e.data?.turn;
+			return typeof t === "number" && Number.isFinite(t) ? t : null;
+		}
+	}
+	return null;
+}
+/**
 * 装配闸门（index.ts apply 调用）。
 * 只对**已登记的手动模式会话**生效——其他会话（主舱/其他 轨迹约束会话）零干预。
 */
@@ -19086,7 +19164,7 @@ function registerWeixinOutputGuard(ctx) {
 				const sessionId = sessionIdOf$1(exec?.agent);
 				if (sessionId && manualSessions.has(sessionId)) {
 					if (isSuccessfulImSend(exec, result, manualSessions.get(sessionId)?.channel ?? "weixin")) {
-						sentThisTurn.add(sessionId);
+						sentTurn.set(sessionId, currentTurnOf(exec, exec.agent));
 						rebukeCounts.delete(sessionId);
 					}
 				}
@@ -19105,7 +19183,7 @@ function registerWeixinOutputGuard(ctx) {
 			if (!sessionId) return;
 			const session = manualSessions.get(sessionId);
 			if (!session) return;
-			if (sentThisTurn.has(sessionId)) return;
+			if (hasSentThisTurn(sessionId, payload?.turn ?? null)) return;
 			const count = (rebukeCounts.get(sessionId) ?? 0) + 1;
 			if (count > 2) {
 				rebukeCounts.delete(sessionId);
@@ -19235,6 +19313,41 @@ async function resolveInboundTarget(ctx, input) {
 	};
 }
 /**
+* 同会话入站**串行化**（2026-10-21，修"同一条消息被处理两轮"的第二个缺陷）。
+*
+* ## 为什么必须有锁（R↓，代价换来的）
+*
+* `askTrajectory` 的成功判据是"`assistant/message` **条数增长**"。两条入站并发时，
+* 后一条的快照包含前一条尚未落盘的产出 ⇒ **前一轮的产出会满足后一条的成功判据**
+* ⇒ 兜底 / `reply-fallback` 可能拿到**错轮**的答案（真机实测：把内部过程话发给了家人）。
+*
+* ## 粒度与边界
+*
+* - 按**会话 id**加锁：不同轨迹（各 IM 账号）各跑各的，互不拖慢。
+* - ⚠️ 与投递侧"不排队"**不是一回事**：`send-now` 的"当场注入"是**投递**语义，
+*   这里排的是**处理**语义 —— 同一会话不该同时开两轮。两者不冲突。
+* - 用 acquire/release 而不是 callback 形态：主流程已在 `try/catch/finally` 里，
+*   callback 会把整段重新缩进，diff 看不清"到底改了什么"。
+*/
+const sessionLocks = /* @__PURE__ */ new Map();
+async function acquireSessionLock(key) {
+	const prev = sessionLocks.get(key) ?? Promise.resolve();
+	let release = () => {};
+	const held = new Promise((resolve) => {
+		release = resolve;
+	});
+	const mine = prev.catch(() => void 0).then(() => held);
+	sessionLocks.set(key, mine);
+	await prev.catch(() => void 0);
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		if (sessionLocks.get(key) === mine) sessionLocks.delete(key);
+		release();
+	};
+}
+/**
 * **一条入站消息的主流程**（通道中立）。
 *
 * 职责：路由 → 固定会话 id 创建/延续 → 提问 → 回复（或被闸门拦下后兜底）。
@@ -19288,8 +19401,21 @@ async function handleInboundEvent(ctx, root, accountId, io, event, preset) {
 		}).catch(() => {});
 		return;
 	}
+	let releaseLock = null;
 	try {
 		const sessionId = weixinSessionIdForTrajectory(trajectory);
+		/**
+		* 🔴 **同会话串行化**（2026-10-21，修"同一条消息被处理两轮"的第二个缺陷）。
+		*
+		* `askTrajectory` 的成功判据是"`assistant/message` **条数增长**"。两条入站并发时，
+		* 后一条的快照包含前一条尚未落盘的产出 ⇒ **前一轮的产出会满足后一条的成功判据**
+		* ⇒ 兜底/`reply-fallback` 可能拿到**错轮**的答案（真机实测：把内部过程话发给了家人）。
+		*
+		* 锁的粒度 = **一个会话同一时刻只跑一条入站**（不同轨迹各跑各的，互不拖慢）。
+		* ⚠️ 与投递侧"不排队"不是一回事：`send-now` 的"当场注入"是**投递**语义，
+		* 这里排的是**处理**语义 —— 两者不冲突。
+		*/
+		releaseLock = await acquireSessionLock(sessionId);
 		const existing = getTrajectoryAgent(sessionId);
 		const hc = readCheapWorkerConfig(root);
 		const ref = existing ? {
@@ -19369,7 +19495,18 @@ async function handleInboundEvent(ctx, root, accountId, io, event, preset) {
 			if (text) parts.push(text);
 			parts.push(...mediaNotes, ...degradedNotes);
 			if (manualOutput) {
-				clearSentThisTurn(sessionId);
+				/**
+				* 🔴 **不在这里清空"已发送"标记**（2026-10-21 修"同一条消息被处理两轮"）。
+				*
+				* 旧写法 `clearSentThisTurn(sessionId)` 的语义是"来了新消息就当这个会话没发过"——
+				* 而它**连正在跑那一轮的证据一起抹掉**：真机时刻线
+				* `12:08:25 发送成功 → 12:08:56 新入站(抹) → 12:09:19 那一轮 turn-stopping 判"没发" ⇒ 打回`
+				* ⇒ 用户看到的就是"同一条消息被处理了两轮"。
+				*
+				* 现在**没有任何清空动作**：标记记的是**轮号**，上一轮发的记录在下一轮 `turn-stopping`
+				* 时天然不匹配（`hasSentThisTurn` 按轮比）⇒ 陈旧记录靠"轮号不等"淘汰，
+				* 不靠"谁来抹掉"。清空动作本身就是误伤面。
+				*/
 				noteManualOutputSession(sessionId, {
 					root,
 					accountId,
@@ -19445,6 +19582,8 @@ async function handleInboundEvent(ctx, root, accountId, io, event, preset) {
 		console.log(`[serenity-hooks] im-bridge error (ccc=${root}): ${msg}`);
 		const stack = err instanceof Error ? err.stack : void 0;
 		if (stack) console.log(`[serenity-hooks] im-bridge stack:\n${stack.slice(0, 1500)}`);
+	} finally {
+		releaseLock?.();
 	}
 }
 /**
@@ -19673,7 +19812,9 @@ function installFeishuAccountImpl() {
 var bridge_exports = /* @__PURE__ */ __exportAll({
 	handleIncoming: () => handleIncoming,
 	handleMachineIncoming: () => handleMachineIncoming,
+	recallContextToken: () => recallContextToken,
 	registerWeixinBridge: () => registerWeixinBridge,
+	rememberContextToken: () => rememberContextToken,
 	resolveInboundTarget: () => resolveInboundTarget,
 	resolveWeixinAccount: () => resolveWeixinAccount,
 	sendProactiveText: () => sendProactiveText,
@@ -19697,6 +19838,52 @@ const MACHINE_SCOPE = "<machine>";
 const machineLoops = /* @__PURE__ */ new Map();
 /** typing_ticket 缓存（每 (accountId, fromUserId)；getconfig 一次后续复用——对齐参考实现 typingTicketCache） */
 const typingTicketByUser = /* @__PURE__ */ new Map();
+/**
+* 🔴 **最近一次 `context_token` 缓存**（每 `(accountId, userId)`）—— 2026-10-21，owner 报
+* 「久不在微信发言，认知轨迹主动发消息就不通」。
+*
+* ## 为什么必须有它（协议规范，不是我们的发明）
+*
+* 微信 iLink 协议的 `context_token` **不是"用户 ID"**，而是
+* **「当前对话上下文的会话能力令牌」**（[公开协议规范] §5.10）。规范逐字：
+*
+* - **文本回复：必填。图片/文件/视频回复：必填。**（§6.4）
+* - 「以 `(accountId, userId)` 为 key **缓存最近一次 `context_token`**」（§5.10 工程建议）
+* - 「**主动发消息能力**：公开实现普遍依赖**最近一次入站消息**带来的 `context_token`」（§12 对比表）
+*   —— 这是微信相对 Telegram/Slack 的**根本差异**（那两家只要知道 chat_id 就行）。
+* - 「协议里**未观察到**单独"打开会话"的 API」（§5.10）⇒ **没有任何办法主动"开一个会话"**，
+*   只能靠人发一条消息来刷新这张票。
+*
+* ## 🔴 修前我们是什么状态
+*
+* 收到 token 后**只用一次就丢**（唯一消费点是"回复这一条消息"）⇒ 那条回复发完，
+* 手上就**再没有票**了 ⇒ 之后任何**主动**发送都是裸发（不带 `context_token`）。
+* ⇒ 这与 owner 的观察完全吻合：**刚聊过就通**（票还在窗口内/刚被刷新），**隔久了就不通**。
+* ⚠️ 这**不是心跳问题** —— 规范里根本没有心跳；是**票没留住**。
+*
+* ## 边界（照规范原话）
+*
+* - **不跨用户复用、不跨 bot 账号复用**（key 含 accountId 与 userId 两段）。
+* - **不伪造 token**：只存服务端真给过的。
+* - **进程重启即丢失**（内存缓存）——规范也确认这条，因为**没有开新会话的 API**；
+*   重启后的第一条主动消息仍可能失败，这是**平台限制**，由 O3 的失败文案如实告知。
+*/
+const contextTokenByUser = /* @__PURE__ */ new Map();
+/** context_token 的缓存键（与 typing 同款两段式，但**语义不同**：这里存的是会话票） */
+function contextCacheKey(accountId, userId) {
+	return `${accountId}|${userId}`;
+}
+/** 记下最近一次入站带来的 `context_token`（**只存非空**；空串会把好票覆盖成坏票） */
+function rememberContextToken(accountId, userId, token) {
+	if (!userId) return;
+	const t = (token ?? "").trim();
+	if (t === "") return;
+	contextTokenByUser.set(contextCacheKey(accountId, userId), t);
+}
+/** 取该用户最近一次的 `context_token`（没有 ⇒ `undefined`，调用方按"裸发"处理并如实回执） */
+function recallContextToken(accountId, userId) {
+	return contextTokenByUser.get(contextCacheKey(accountId, userId));
+}
 function typingCacheKey(accountId, fromUserId) {
 	return `${accountId}|${fromUserId}`;
 }
@@ -19777,6 +19964,7 @@ async function sendTypingStop(cred, accountId, fromUserId) {
 async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 	const fromUserId = msg.from_user_id;
 	if (!fromUserId) return;
+	rememberContextToken(accountId, fromUserId, msg.context_token);
 	await handleInboundEvent(ctx, root, accountId, {
 		sendText: async ({ toUserId, text, replyRef }) => {
 			await sendTextMessage({
@@ -20107,18 +20295,45 @@ async function sendProactiveText(input) {
 	const { accountId, cred } = account;
 	const trajectory = matchWeixinRoute(settings.routes ?? [], toUserId) ?? "";
 	const sessionId = weixinSessionIdForTrajectory(trajectory !== "" ? trajectory : sanitizeFileName$1(toUserId) || "unknown");
+	/**
+	* 🔴 **带上最近一次的 `context_token`**（2026-10-21，协议规范 §5.10/§6.4）。
+	*
+	* 修前这里是**裸发**（`sendTextMessage` 不传 `contextToken`）。而规范把 `context_token`
+	* 定为「会话能力令牌」：主动发送**依赖最近一次入站消息**带来的那张票（§12 对比表逐字：
+	* 这正是微信相对 Telegram/Slack 的根本差异）。
+	* ⇒ 没有票时，服务端无法把消息关联到对话窗口 ⇒ 表现为"久不发言就发不出去"。
+	*
+	* ⚠️ **仍然允许无票发送**（不改成硬拒绝）：修前就是这么发的，而且**部分时机它是能成功的**
+	* （票还在服务端窗口内的那些时刻）。改成硬拒绝 = 把"有时能发"变成"永远不发"。
+	* ⇒ 取**尽力而为 + 如实回执**：能带就带；没票照发，但把"没票"这件事**写进回执**，
+	* 让人知道这一条是"运气发出去的"（D186：可以降级，但不许不出声）。
+	*/
+	const contextToken = recallContextToken(accountId, toUserId);
 	try {
 		await sendTextMessage({
 			baseUrl: cred.baseUrl,
 			token: cred.token,
 			toUserId,
-			text: input.text
+			text: input.text,
+			...contextToken === void 0 ? {} : { contextToken }
 		});
 	} catch (err) {
+		/**
+		* 🔴 **失败必须落盘**（2026-10-21，O1）。修前失败只回给调用方、**不写任何流水**
+		* （outgoing hook 只在**成功后**触发）⇒ 「失败过没有、失败成什么样」在盘上不可见
+		* ⇒ 下次报障只能猜。这里补上**只有失败才会产生**的那行日志。
+		*
+		* ⚠️ 按规范 §11：`ret=-2` 在社区实现里被误报成"rate limited"，
+		*    而真因常是**缺 `context_token`**（第三方实测）⇒ 故把「有没有票」一起记进日志，
+		*    这样一眼能分辨"票的问题"还是"账号/网络的问题"。
+		*/
+		const detail = err instanceof Error ? err.message : String(err);
+		console.warn(`[serenity-hooks] ✗ im 主动发送失败: account=${accountId} user=${toUserId} contextToken=${contextToken === void 0 ? "ABSENT(无票，裸发)" : "present"} err=${detail}`);
 		return {
 			ok: false,
 			code: "SEND_FAILED",
-			error: `发送失败: ${err instanceof Error ? err.message : String(err)}`
+			error: `发送失败: ${detail}`,
+			...contextToken === void 0 ? { remediation: "该用户近期未发过消息 ⇒ 手上没有 context_token（会话能力令牌）。协议没有\"主动开新会话\"的 API ⇒ 请先让用户在微信里发一条消息激活会话，再重试。" } : {}
 		};
 	}
 	if (settings.hook) invokeWeixinHook(root, settings.hook, buildOutgoingHookEvent({

package/lib/{session-KBRbYb52.js → session-BF4C3hJL.js}

@@ -2555,6 +2555,51 @@ function countAssistantMessages(session) {
 	return n;
 }
 /**
+* 会话当前轮号（最后一个 `turn/start` 的 `turn`；取不到 ⇒ `null`）。
+*
+* 🔴 为什么需要它（2026-10-21，"同一条消息被处理两轮"的第二处缺陷）：
+* 判"本轮是否产出"用的是 **`assistant/message` 条数增长**。而在**并发入站**下，
+* 后一条的快照里，**前一条那一轮**还在继续产出 assistant 消息 ⇒ 计数照样增长
+* ⇒ 后一条会把**别人那一轮的文本**当成自己的答案（真机实测：兜底把内部过程话发给了家人）。
+* ⇒ 增长必须限定在「**这一轮开始之后**新出现的事件」里。
+*/
+function currentTurnOfSession(session) {
+	const events = sessionEvents(session);
+	for (let i = events.length - 1; i >= 0; i--) {
+		const e = events[i];
+		if (e?.type === "turn/start") {
+			const t = e.data?.turn;
+			return typeof t === "number" && Number.isFinite(t) ? t : null;
+		}
+	}
+	return null;
+}
+function snapshotSession(session) {
+	return {
+		turn: currentTurnOfSession(session),
+		assistantCount: countAssistantMessages(session),
+		eventCount: sessionEvents(session).length
+	};
+}
+/**
+* **本轮**（快照之后）是否产出了 assistant 消息。
+*
+* 判据顺序（每一条都是被真账打出来的）：
+* ① 只数**快照之后**新增的事件 ⇒ 前一轮续跑的产出**不进账**（2026-10-21）；
+* ② 若快照时的轮号已知，且现在的轮号变了 ⇒ 那是**别的轮**在产出 ⇒ 不算我的；
+* ③ 条数确实增长 ⇒ 成功。
+*/
+function grewWithFreshAssistant(session, snap) {
+	const events = sessionEvents(session);
+	if (events.length <= snap.eventCount) return false;
+	const now = currentTurnOfSession(session);
+	if (snap.turn !== null && now !== null && now !== snap.turn) return false;
+	let fresh = 0;
+	for (let i = snap.eventCount; i < events.length; i++) if (events[i]?.type === "assistant/message") fresh += 1;
+	if (fresh > 0) return true;
+	return countAssistantMessages(session) > snap.assistantCount;
+}
+/**
 * 等**本轮**产出一条 assistant 消息。
 *
 * ## 为什么不能用 `waitAgentIdle` 单独当判据（2026-10-19 复读缺陷）
@@ -2570,9 +2615,19 @@ function countAssistantMessages(session) {
 * ② 成功 ⟺ 该计数**增长**；
 * ③ 超时或有界轮询耗尽 ⇒ `false`（调用方据此给空答案，兜底不触发）。
 */
-async function waitForTurnAssistant(ctx, agent, beforeAssistantCount, opts = {}) {
+async function waitForTurnAssistant(ctx, agent, before, opts = {}) {
 	const timeoutMs = opts.timeoutMs ?? ASK_TURN_TIMEOUT_MS;
-	const grew = () => countAssistantMessages(agent.session) > beforeAssistantCount;
+	/**
+	* 快照兼容两种入参：数字（旧调用方的"条数"）与 `SessionSnapshot`（新，带轮号与事件位）。
+	* 🔴 数字形态**仍然可用**，因为既有测试与调用点按数字传，而它们的语义（"条数增长"）
+	* 在本轮修法之后依然成立 —— 只是**并发**时不够。给 `SessionSnapshot` 才拿到全部判别力。
+	*/
+	const snap = typeof before === "number" ? {
+		turn: null,
+		assistantCount: before,
+		eventCount: 0
+	} : before;
+	const grew = () => typeof before === "number" ? countAssistantMessages(agent.session) > before : grewWithFreshAssistant(agent.session, snap);
 	if (await Promise.race([waitAgentIdle(ctx, agent).then(() => true), new Promise((resolve) => {
 		setTimeout(() => resolve(false), timeoutMs);
 	})])) return grew();
@@ -2581,10 +2636,17 @@ async function waitForTurnAssistant(ctx, agent, beforeAssistantCount, opts = {})
 /**
 * 提问一轮：followup → 等**本轮**回答 → 读答案。
 *
+* ## 🔴 2026-10-21：快照从"条数"升级为"（轮号, 条数, 事件位）"
+*
+* 并发入站时，后一条的快照里**前一条那一轮还在产出** ⇒ 旧判据（条数增长）会被满足
+* ⇒ 后一条把**别人那一轮的文本**当自己的答案。新快照让"增长"只在**本轮的窗口内**才成立。
+* 配套：调用侧（`im/inbound-event.ts`）给**同一会话**加了串行锁 —— 两层都要，缺一不可：
+* 锁防"同时开两轮"，快照防"锁被绕过时（如别的路径直接调本函数）把错轮的文本当答案"。
+*
 * @param options.timeoutMs 本轮等待上限（测试注入；生产用缺省）
 */
 async function askTrajectory(ctx, agent, question, options) {
-	const beforeAssistant = countAssistantMessages(agent.session);
+	const beforeSnapshot = snapshotSession(agent.session);
 	agent.followup(createUserMessage({
 		content: [{
 			type: "text",
@@ -2593,7 +2655,7 @@ async function askTrajectory(ctx, agent, question, options) {
 		source: PLUGIN_SOURCE
 	}));
 	return {
-		answer: await waitForTurnAssistant(ctx, agent, beforeAssistant, { timeoutMs: options?.timeoutMs }) ? lastAssistantText(agent) : "",
+		answer: await waitForTurnAssistant(ctx, agent, beforeSnapshot, { timeoutMs: options?.timeoutMs }) ? lastAssistantText(agent) : "",
 		sessionId: String(agent.session.id ?? "")
 	};
 }

package/lib/trajectory/session.d.ts

@@ -105,6 +105,18 @@ interface TrajectoryAskResult {
     answer: string;
     sessionId: string;
 }
+/**
+ * 会话快照：**调用那一刻**的（轮号, assistant 条数, 事件条数）。
+ *
+ * 三个值一起记，是因为判"增长"要能回答两个问题：
+ * ① 有没有新的 assistant 消息？（条数）
+ * ② 那些新消息是不是**我这一轮**产的？（轮号 ＋ 只看快照之后的事件）
+ */
+interface SessionSnapshot {
+    turn: number | null;
+    assistantCount: number;
+    eventCount: number;
+}
 /**
  * 等**本轮**产出一条 assistant 消息。
  *
@@ -121,13 +133,20 @@ interface TrajectoryAskResult {
  * ② 成功 ⟺ 该计数**增长**；
  * ③ 超时或有界轮询耗尽 ⇒ `false`（调用方据此给空答案，兜底不触发）。
  */
-export declare function waitForTurnAssistant(ctx: unknown, agent: Agent, beforeAssistantCount: number, opts?: {
+export declare function waitForTurnAssistant(ctx: unknown, agent: Agent, before: number | SessionSnapshot, opts?: {
     timeoutMs?: number;
     pollMs?: number;
 }): Promise<boolean>;
 /**
  * 提问一轮：followup → 等**本轮**回答 → 读答案。
  *
+ * ## 🔴 2026-10-21：快照从"条数"升级为"（轮号, 条数, 事件位）"
+ *
+ * 并发入站时，后一条的快照里**前一条那一轮还在产出** ⇒ 旧判据（条数增长）会被满足
+ * ⇒ 后一条把**别人那一轮的文本**当自己的答案。新快照让"增长"只在**本轮的窗口内**才成立。
+ * 配套：调用侧（`im/inbound-event.ts`）给**同一会话**加了串行锁 —— 两层都要，缺一不可：
+ * 锁防"同时开两轮"，快照防"锁被绕过时（如别的路径直接调本函数）把错轮的文本当答案"。
+ *
  * @param options.timeoutMs 本轮等待上限（测试注入；生产用缺省）
  */
 export declare function askTrajectory(ctx: Context, agent: Agent, question: string, options?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shgroup/dsh-serenity-hooks",
-  "version": "1.81.0",
+  "version": "1.83.0",
   "description": "宁静号 ACC harness（Native Cordis 插件）——给 DeepSeek Harness 装一个「AI 工作区」：14 个工具（container_fs/cognitive_trajectory/dashboard/container_git/msm/praxis/ontology/serenity-skill-creator/cheap-worker/localstore/container_admin；另三个 im-bridge/acc-diag/diagram 按配置条件出现）+ 机械约束（安全模式/工作区围墙/密钥守卫/对外输出守卫）+ 认知轨迹日志与原地重建 + 网页登录入口/IM 桥/认知轨迹唤醒注册表。轨迹声明 = 轨迹目录下的 trajectory.json（约束面 + 旧标识 uid + CRO 机器绑定 cro.host；旧名 trajectory-constraint.json / skiff.json 仍在读取族里）；轨迹提示词 = 轨迹目录下的 PROMPT.md（一条轨迹「是谁、按什么章程工作」，所有轨迹通用，追加在容器层与质量层之后，不替换它们）。适配 DSH 0.1.7-rc.1 / 0.2.0-rc.1 / 0.2.1-rc.1（三档）。",
   "license": "MIT",
   "repository": {