@shgroup/dsh-serenity-hooks 1.39.1 → 1.39.3

package/README.md

@@ -270,10 +270,11 @@ DSH 一个进程可以同时带多个工作区，每个工作区各自对接自
 
 **定时唤醒**：用 `container_trajectory send-later` 登记一条"唤醒" = 未来某时刻 + 一条消息——可以给自己预约，也可以唤醒别的轨迹；落在工作区内的 `AGENT_SESSIONS/wake-registry.json`（可读可审计），到点由中心调度器投递，**不阻塞、不等待、也不回执**。
 
-**即时投递**：用 `container_trajectory send-now` 把一条消息**现在**就递过去——目标在内存里就**立即注入**；不在内存里就**冷载入后投递**（**等效于直接唤醒**，但**不等调度器的 5 分钟节拍**）。它**有同步回执**（告诉你走了 live 还是冷载入），**不落注册表**（那张表专管"未来时刻"）。
+**即时投递**：用 `container_trajectory send-now` 把一条消息**现在**就递过去，并且**不排队**——目标在内存里且**正在跑轮次**，就 `steer` **当场注入当前轮**；目标空闲就**立即起一轮**；目标不在内存里就**冷载入后投递**（**等效于直接唤醒**，但**不等调度器的 5 分钟节拍**）。它**有同步回执**（告诉你走了 live 还是冷载入），**不落注册表**（那张表专管"未来时刻"）。
 
 - 两者只差两处：**时刻**（现在 / 未来）与**回执**（有 / 无）。"预约"天生是 fire-and-forget（不可回收、不回执），"递话"则是一次调用一次答复——**各自语义干净，不把两种语义塞进同一个动作**（🔴 **更名**：这对动作原名 `wake-later` / `send-message`，现名 **`send-later` / `send-now`**——族名取共享词干 `send-`、轴取 `-later`/`-now`，因为「唤醒」是两条路径**共有**的属性，不配做区分；**硬切无别名**）
-- ⚠️ **回执只到"已入队"**：它**不表示**目标已经执行或答复；目标正在跑轮次时，消息在**轮次边界**生效（**不打断当前轮**）。要确证"目标真的动了"，得看它自己的 `SESSION.md`
+- ⚠️ **回执只到"已注入 / 已起轮"**：它**不表示**目标已经执行或答复。要确证"目标真的动了"，得看它自己的 `SESSION.md`（**不得凭回执结案**）
+- ⚠️ **唯一的例外路径**：`steer` 不可用时**退回排队**（fail-safe：**宁可排队，不可静默丢消息**）——此时回执文案写明"steer 不可用 ⇒ 退回 followup"。**`send-later` 不受影响**：预约的本职是"到点唤起"，在跑时排队不打断当前轮是它被实证验收过的行为
 
 - **目标没打开也能唤醒**：会话不在内存里时先把它载入再投递（**冷唤醒**）；载入不了则条目留在登记表里并记下原因，**不静默丢弃**
 - **"周期"归工作区自己**：要一轮接一轮，就由**收到唤醒的那条轨迹**在每轮结束时再排一次下一轮——ACC 只提供"到点投递一条消息"这个原语，不替工作区决定节拍（焦点、节拍、偏见都由工作区自定；任意条轨迹并行、互不干扰）

package/dsh.plugin.json

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

package/lib/index.js

@@ -2,11 +2,12 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { a as hostSettings, c as hostWebServer, i as hostSessions, n as hostInjected, o as hostSubagents, r as hostService, s as hostWeb, t as hostAgents } from "./access-fiehjxV6.js";
 import { a as findSerenityRoot, c as matchBlacklist, d as readCccName$1, f as readExclusiveTools, h as resolveInside, i as findGitRoot, l as pathInside, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readHandymanConfig, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-NlLr_sxy.js";
 import { i as cccRootForExec, n as agentCwdFor, o as listCccs, r as cccRootForCwd, t as NO_CCC_FROM_AGENT_CWD } from "./ccc-roots-Bd_SjEs7.js";
+import { C as useSession, S as summarize, T as localFileStamp, _ as resolveSessionByTitle, a as resolveSessionTrajectoryLabel, b as setActiveSessionInfo, c as TRAJECTORY_ACTIONS, d as extractSessionMdPathFromText, f as findSession, g as readActiveSessionMd, h as parseSessionContextFromEvents, i as readLastBound, l as clearActiveSessionInfo, m as listSessions, o as supersedeOtherBindings, p as getActiveSessionInfo, r as pruneMissingBindings, s as DEFAULT_SESSION_SCOPE, t as appendBound, u as createSession, v as sessionEvents$1, w as isoLocal, x as showSession, y as sessionsRoot } from "./trajectory-bound-B9o_4CMF.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-B2ajFypI.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-CEHL5cek.js";
 import { a as unregisterSkiffSession$1, i as skiffSessionSnapshot$1, n as skiffRoleFor$1, r as skiffSessionInfo$1, t as registerSkiffSession$1 } from "./skiff-registry-FTjoWQTQ.js";
-import { _ as sessionsRoot, a as DEFAULT_SESSION_SCOPE, b as summarize, c as createSession, d as getActiveSessionInfo, f as listSessions, g as sessionEvents$1, h as resolveSessionByTitle, i as resolveSessionTrajectoryLabel, l as extractSessionMdPathFromText, m as readActiveSessionMd, o as TRAJECTORY_ACTIONS, p as parseSessionContextFromEvents, r as readLastBound, s as clearActiveSessionInfo, t as appendBound, u as findSession, v as setActiveSessionInfo, x as useSession, y as showSession } from "./trajectory-bound-CApZRbvx.js";
-import { a as WAKE_CATCH_UP_MS, i as registerDisposer, n as sendToTrajectory, o as addWake, r as wakeSchedulerState, s as listWakes, t as registerWakeScheduler } from "./wake-scheduler-B50eu0jb.js";
+import { r as sessionsRootDir, t as hasSessionLogById } from "./session-cleanup-BtkSmry8.js";
+import { a as WAKE_CATCH_UP_MS, i as registerDisposer, n as sendToTrajectory, o as addWake, r as wakeSchedulerState, s as listWakes, t as registerWakeScheduler } from "./wake-scheduler-CCpCk-7r.js";
 import { a as FACE_PORTS, c as MECHANISM_PORTS, i as ACP_HTTP_PORT, l as SKIFF_DEBUG_PORT, n as registerSettingsSection, o as GATEWAY_PORT, s as MAIN_WEB_PORT, t as readSimpleSettings, u as WEIXIN_SEND_PORT } from "./settings-section-DMDUoQum.js";
 import { a as markdownToPlainText, c as sendTyping, i as getUpdates, l as sniffImageExt, n as downloadMedia, o as sendFileMessage, r as getConfig, s as sendTextMessage, t as TypingStatus } from "./weixin-api-CtFYm53S.js";
 import z from "@deepseek-ai/schemastery";
@@ -73,7 +74,7 @@ function getFileInfo(absPath, name) {
 			type: detectFileType(stat),
 			size: stat.size,
 			sizeHuman: humanSize(stat.size),
-			mtime: stat.mtime.toISOString()
+			mtime: isoLocal(stat.mtime)
 		};
 	} catch {
 		return {
@@ -356,7 +357,7 @@ function runCcFs(root, args) {
 				`path: ${safeRel(root, absPath)}`,
 				`type: ${fileType}`,
 				`size: ${stat.size} (${humanSize(stat.size)})`,
-				`mtime: ${stat.mtime.toISOString()}`,
+				`mtime: ${isoLocal(stat.mtime)}`,
 				`mode: ${modeStr}`,
 				`uid: ${stat.uid}`,
 				`gid: ${stat.gid}`
@@ -552,7 +553,7 @@ async function runKit(root, args, hostCtx) {
 		case "time": {
 			const now = /* @__PURE__ */ new Date();
 			return {
-				now_iso: now.toISOString(),
+				now_iso: isoLocal(now),
 				now_local: now.toString(),
 				epoch_ms: now.getTime()
 			};
@@ -965,7 +966,7 @@ Directory of ACC capabilities — each area lists where to go for details (guide
                          专属工具（**默认对所有 CCC 隐藏**，只有在自己 exclusiveTools 里点名的 CCC 可见）→ acc-diag（运行态诊断）
   ④ 角色与对外面      → container_admin role（Skiff 认知子集角色：guide/validate/apply/list——skiff_admin 已并入）
                          ACP（程序化 JSON-RPC 3100）/ Skiff 问答页（公网 ask）——面板「外部能力」组
-  ⑤ 自主与接入        → container_trajectory send-now（跨轨迹的**即时**递送：live 目标立即注入，非 live 冷载入——等效于直接 wake；**有同步回执**）
+  ⑤ 自主与接入        → container_trajectory send-now（跨轨迹的**即时**递送，**不排队**：live 目标在跑就当场注入当前轮、空闲则立即起轮；非 live 冷载入——等效于直接 wake；**有同步回执**）
                          container_trajectory send-later（跨轨迹的"未来时刻 + 一条 message"；fire-and-forget，无回执无回收）
                          weixin 微信桥（配置/扫码/路由/消息 hook——CCC 侧 weixin-doctor MSM：msm("weixin-doctor", ["guide"])）
   ⑥ CCC 配置总览      → container_admin msm ccc-config（9 段：handyman/sessionKeeper/localstore/hooks/safeMode/skiff/trajectory/weixin/**exclusiveTools**）
@@ -1257,7 +1258,27 @@ function loadMsmEntries(root) {
 function findEntry(root, name) {
 	return loadMsmEntries(root).find((e) => e.name === name) ?? null;
 }
-/** 扫描各 skill scripts/ 下的非测试脚本（DC-M3 正向基准，对齐 osp） */
+/**
+* 扫描各 skill `scripts/` 下的**未注册候选**（DC-M3 正向基准，对齐 osp）。
+*
+* 🔴 **入口判据**（S151 轮 112 跨轨迹信号 → S142 实测精化，2026-09-17；取证见 S142 §0q）：
+*   · **入口 ⟺ 有 shebang（`^#!`） ∨ 声明了 `function main(`** —— **`process.argv` 单独不算**。
+*     反例（实测）：`home-desk/scripts/lib/desk-dispatch.ts` 含 **5** 处 `process.argv`，
+*     但无 shebang / 无 `main()`，且被 `desk-window.ts`、`desk-vision.ts` **import** ⇒ **它是库**。
+*   · **库 ⟺ 无 shebang ∧ 无 `main()` ∧ 被其它脚本 import** ⇒ **不是 MSM 候选，不上报**。
+*     ⚠️ **"有 `.test.ts`" 不是入口证据** —— 库**同样**有测试
+*     （`home-serenity/scripts/dev-kit/dev-kit.test.ts` 开头自述"**共享库单测**"）。
+*     📌 实现只测**前两条**（shebang / `main()`）：第三条"被 import"是**描述性**的，不作判据 ——
+*     因为**无 CLI 入口的文件本来就不可能被 `msm()` 调用**，上报它只会得到一条无法处置的欠账。
+*     🔗 **与 DC-M2 自洽**：DC-M2 本就要求**已注册**脚本必须有 main() 守卫 ⇒ 把"无入口"的文件
+*     排除出候选，与注册表的契约**同向**（两条判据不会互相打架）。
+*
+* 🔴 **本函数只扫 `scripts/` 一层（非递归），这是当前刻意的语义**（嵌套子域对容器不可见；
+*   见 CCC `docs/t024-msm-skill-inventory.md` §3b）。**若将来改为递归，上面的判据就是护栏**：
+*   嵌套候选实测 **8 个**（`dev-kit/` 5 + `home-desk/scripts/lib/` 3）**全部是库**——
+*   不按判据过滤，一次递归就会制造 8 条假欠账，并可能诱使后续轮次把库注册成**假 MSM**。
+*   ⇒ **改递归前先读本条注释。**
+*/
 function scanSkillScripts(root) {
 	const out = [];
 	const skillsDir = join(root, ".opencode", "skills");
@@ -1265,10 +1286,34 @@ function scanSkillScripts(root) {
 	for (const skill of readdirSync(skillsDir)) {
 		const scriptsDir = join(skillsDir, skill, "scripts");
 		if (!existsSync(scriptsDir)) continue;
-		for (const f of readdirSync(scriptsDir)) if (/\.(ts|js|mjs)$/.test(f) && !/\.(test|spec)\./.test(f)) out.push(join(".opencode", "skills", skill, "scripts", f));
+		for (const f of readdirSync(scriptsDir)) {
+			const abs = join(scriptsDir, f);
+			let isFile = false;
+			try {
+				isFile = statSync(abs).isFile();
+			} catch {
+				continue;
+			}
+			if (!isFile) continue;
+			if (!/\.(ts|js|mjs)$/.test(f)) continue;
+			if (/\.(test|spec)\./.test(f)) continue;
+			if (!hasCliEntry(abs)) continue;
+			out.push(join(".opencode", "skills", skill, "scripts", f));
+		}
 	}
 	return out.sort();
 }
+/** 入口判据的机械实现（判据、反例与递归化护栏见 `scanSkillScripts` 注释） */
+function hasCliEntry(absPath) {
+	let text;
+	try {
+		text = readFileSync(absPath, "utf-8");
+	} catch {
+		return true;
+	}
+	if (/^#!/.test(text)) return true;
+	return /\b(?:async\s+)?function\s+main\s*\(/.test(text);
+}
 /**
 * **注册表「质量契约」判据（DC-M1~M4）** —— 具名出口（C5 观察面归一，2026-09-15）。
 *
@@ -1666,7 +1711,7 @@ function writeProgress(root, label, p) {
 	writeFileSync(json, JSON.stringify({
 		...p,
 		status: p.status ?? "running",
-		updated: (/* @__PURE__ */ new Date()).toISOString()
+		updated: isoLocal()
 	}, null, 2) + "\n", "utf-8");
 	const lines = [
 		`# handyman: ${label}`,
@@ -1694,7 +1739,7 @@ function writeFailedStatus(root, label, info) {
 		status: "failed",
 		errorCode: info.errorCode,
 		errorMessage: info.errorMessage,
-		updated: (/* @__PURE__ */ new Date()).toISOString(),
+		updated: isoLocal(),
 		lastResponse: prev?.lastResponse ?? ""
 	}, null, 2) + "\n", "utf-8");
 }
@@ -1821,7 +1866,7 @@ function listActiveHandymen(root) {
 			});
 		} catch {}
 	}
-	out.sort((a, b) => a.updated < b.updated ? 1 : -1);
+	out.sort((a, b) => Date.parse(b.updated) - Date.parse(a.updated));
 	return out;
 }
 //#endregion
@@ -2808,7 +2853,7 @@ async function runHandymanJob(ctx, opts) {
 				done: false,
 				label,
 				model,
-				updated: (/* @__PURE__ */ new Date()).toISOString(),
+				updated: isoLocal(),
 				lastResponse
 			};
 			writeProgress(root, label, progress);
@@ -2824,7 +2869,7 @@ async function runHandymanJob(ctx, opts) {
 			done,
 			label,
 			model,
-			updated: (/* @__PURE__ */ new Date()).toISOString(),
+			updated: isoLocal(),
 			lastResponse,
 			status: done ? "done" : "running"
 		});
@@ -3125,7 +3170,7 @@ 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). 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. Its receipt means the message was QUEUED into the target (it does NOT mean the target ran or replied; a busy target applies it at its next round boundary). The summary is appended to the dsh session title (S###-YYYY-MM-DD-<summary>); the S### id and date stay server-derived.",
+		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). 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.",
 		parameters: {
 			action: {
 				type: "string",
@@ -3241,6 +3286,13 @@ function createTrajectoryTool(ctx) {
 						context: active.context
 					};
 					if (advisory) out.advisory = advisory;
+					if (dsh) {
+						const selfId = String(dsh.header?.id ?? "");
+						const superseded = supersedeOtherBindings(root, info?.dirName ?? targetDirName, selfId === "" ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([selfId]));
+						if (superseded.length > 0) out.supersededBindings = superseded;
+						const pruned = pruneMissingBindings(root, (id) => !hasSessionLogById(sessionsRootDir(), id));
+						if (pruned.length > 0) out.prunedBindings = pruned;
+					}
 					return out;
 				}
 				case "rebuild": {
@@ -3295,8 +3347,8 @@ function createTrajectoryTool(ctx) {
 						output: [
 							"✓ 已即时投递",
 							`  · ${res.detail}`,
-							"  · 语义：消息**已进入目标队列**；目标若正在跑轮次，则在**轮次边界**生效（不打断当前轮）。",
-							"  · ⚠️ 回执只到「已入队」——**不表示**目标已执行或已答复。判\"目标真的动了\"须看它自己的 SESSION.md（文件级判据）。"
+							"  · 语义：**不排队** —— 目标正在跑轮次则**当场注入当前轮**（steer），空闲则立即起一轮（followup）。",
+							"  · ⚠️ 回执只到「已注入 / 已起轮」——**不表示**目标已执行或已答复。判\"目标真的动了\"须看它自己的 SESSION.md（文件级判据）。"
 						].join("\n")
 					};
 				}
@@ -4049,12 +4101,12 @@ function syncSafeModeRestriction(agent, root) {
 		const dispose = agent.ctx.tools.restrict({ deny: [...SAFE_MODE_DENY_TOOLS] });
 		safeModeRestrictions.set(key, dispose);
 		restrictDiag.lastKey = key;
-		restrictDiag.lastAttemptAt = (/* @__PURE__ */ new Date()).toISOString();
+		restrictDiag.lastAttemptAt = isoLocal();
 		restrictDiag.lastSuccess = true;
 		restrictDiag.lastError = null;
 	} catch (e) {
 		restrictDiag.lastKey = key;
-		restrictDiag.lastAttemptAt = (/* @__PURE__ */ new Date()).toISOString();
+		restrictDiag.lastAttemptAt = isoLocal();
 		restrictDiag.lastSuccess = false;
 		restrictDiag.lastError = e.message;
 		console.error(`[serenity-hooks] restrict 失败 (key=${key}):`, e.message);
@@ -6394,7 +6446,7 @@ function getStatus(cwd, configPaths = DEFAULT_SERENITY_CONFIG_PATHS) {
 function setSafeMode(root, on) {
 	const marker = resolve(root, SAFE_MODE_MARKER);
 	if (on) {
-		if (!existsSync(marker)) writeFileSync(marker, (/* @__PURE__ */ new Date()).toISOString() + "\n", "utf-8");
+		if (!existsSync(marker)) writeFileSync(marker, isoLocal() + "\n", "utf-8");
 	} else rmSync(marker, { force: true });
 	return { on: isSafeModeOn(root) };
 }
@@ -6458,7 +6510,7 @@ function saveImageToTmp(root, mediaType, data) {
 	const dir = join(root, IMAGE_UPLOAD_DIR);
 	mkdirSync(dir, { recursive: true });
 	const ext = EXT_BY_MEDIA[mediaType] ?? "img";
-	const filename = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 8)}.${ext}`;
+	const filename = `${localFileStamp()}-${Math.random().toString(36).slice(2, 8)}.${ext}`;
 	writeFileSync(join(dir, filename), bytes);
 	return `${IMAGE_UPLOAD_DIR}/${filename}`;
 }
@@ -6486,7 +6538,7 @@ function saveFileToTmp(root, fileName, data) {
 	const dir = join(root, FILE_UPLOAD_DIR);
 	mkdirSync(dir, { recursive: true });
 	const safeName = sanitizeFileName(fileName);
-	const filename = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 8)}-${safeName}`;
+	const filename = `${localFileStamp()}-${Math.random().toString(36).slice(2, 8)}-${safeName}`;
 	writeFileSync(join(dir, filename), bytes);
 	return `${FILE_UPLOAD_DIR}/${filename}`;
 }
@@ -6985,7 +7037,7 @@ function registerStatusApi(ctx, opts = {}) {
 					const id = s.id ?? s.header?.id;
 					if (id) liveIds.add(id);
 				}
-				const { sessionsRootDir, collectEligibleSessions, performCleanup, cutoffDaysAgo } = await import("./session-cleanup-B6IHZgww.js");
+				const { sessionsRootDir, collectEligibleSessions, performCleanup, cutoffDaysAgo } = await import("./session-cleanup-BtkSmry8.js").then((n) => n.n);
 				const root = sessionsRootDir();
 				if (req.method === "GET") {
 					const { candidates } = performCleanup(root, cutoffDaysAgo(days), liveIds, { dryRun: true });
@@ -6997,7 +7049,7 @@ function registerStatusApi(ctx, opts = {}) {
 						candidates: candidates.map((c) => ({
 							id: c.id,
 							project: c.project,
-							lastActive: new Date(c.lastActiveMs).toISOString()
+							lastActive: isoLocal(c.lastActiveMs)
 						}))
 					});
 					return;
@@ -8853,7 +8905,7 @@ function writeRebuildDiag(root, entry) {
 		if (entry.event === "rebuilt") s.rebuiltCount += 1;
 		if (entry.event === "ttl-dropped") s.droppedCount += 1;
 		if (entry.event === "failed") s.failedCount += 1;
-		s.lastTs = (/* @__PURE__ */ new Date()).toISOString();
+		s.lastTs = isoLocal();
 		s.lastSessionId = entry.sessionId;
 		s.lastEvent = entry.event;
 		s.detail = entry.detail;
@@ -9029,7 +9081,7 @@ function registerRebuildTurnHook(ctx) {
 			writeRebuildDiag(resolveSerenityRootFor(agent), {
 				sessionId: id,
 				event: "ttl-dropped",
-				detail: `queuedAt=${new Date(pending.queuedAt).toISOString()} older than ${PENDING_TTL_MS / 6e4}min TTL — turn did not end in time`
+				detail: `queuedAt=${isoLocal(pending.queuedAt)} older than ${PENDING_TTL_MS / 6e4}min TTL — turn did not end in time`
 			});
 			return;
 		}
@@ -14271,7 +14323,7 @@ function containerStatus(opts = {}) {
 */
 /** 人读渲染一行时钟状态（"为何没有 tick" 的第一手判据） */
 function renderClock(label, s) {
-	const ts = (ms) => ms === null ? "（从未）" : new Date(ms).toISOString();
+	const ts = (ms) => ms === null ? "（从未）" : isoLocal(ms);
 	const parts = [
 		`armed=${s.armed}`,
 		`全局闸=${s.enabled}`,

package/lib/{session-cleanup-B6IHZgww.js → session-cleanup-BtkSmry8.js}

@@ -1,3 +1,4 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { join } from "node:path";
 import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
 //#region src/session-cleanup.ts
@@ -19,6 +20,16 @@ import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
 *
 * 本模块纯逻辑（零 ctx 依赖）：传入 sessionsRoot + liveIds，可单测。
 */
+var session_cleanup_exports = /* @__PURE__ */ __exportAll({
+	collectEligibleSessions: () => collectEligibleSessions,
+	cutoffDaysAgo: () => cutoffDaysAgo,
+	findSessionLog: () => findSessionLog,
+	hasSessionLogById: () => hasSessionLogById,
+	performCleanup: () => performCleanup,
+	sessionLogArtifacts: () => sessionLogArtifacts,
+	sessionLogBytesById: () => sessionLogBytesById,
+	sessionsRootDir: () => sessionsRootDir
+});
 /** DSH 会话 root：env DSH_HOME → ~/.dsh（config-ops globalConfigPath 同款推导） */
 function sessionsRootDir() {
 	const dshHome = process.env.DSH_HOME ?? join(process.env.HOME ?? "", ".dsh");
@@ -142,9 +153,61 @@ function performCleanup(root, cutoffMs, liveIds = /* @__PURE__ */ new Set(), opt
 function dirOf(logPath) {
 	return logPath.slice(0, logPath.lastIndexOf("/")) || logPath;
 }
+/**
+* 某一 dsh 会话（目录名 / 会话 id）的**当前世代日志体积**（字节）。
+*
+* 为什么要它（S142 §0y「旧会话累积 ⇒ dsh 内存崩溃」，所有者令）：
+*   · 宿主恢复/继续一条会话必须**重放全部事件**（`scanLog` → `materializeAppendBatch`）
+*     ⇒ **代价 ∝ 日志体积**；
+*   · 实测（`_tmp/measure-session-load.mjs`，照宿主 `scanZstdFrames` 复刻）：
+*     一条 **72.2 MB**（zstd）的日志 = 35 559 个 frame / 252.6 MB 文本 / 62 680 条事件，
+*     **光是读一遍峰值 RSS +1 175 MB**（探针什么都不保留）；
+*   · 而宿主的解析缓存 `COLD_LOG_MEMO_MAX_ENTRIES = 2` 是**按条数限、不按字节限**的
+*     （`dsh-session-persistence-jsonl/lib/index.js:2175`）⇒ 两条巨日志 = 上限内。
+* 🔴 **在本函数之前，ACC 侧没有任何地方知道"绑定的这条会话日志多大"——这个信号根本不存在。**
+* 这是"靠 agent 自觉 rebuild 不够"的机制层原因（keeper 的 K 量的是**模型上下文**，压缩后回落；
+* 而**日志文件只增不减** ⇒ rebuild 提醒永远不会因为"日志 72 MB"触发）。
+*
+* 只认会话目录（含任意世代日志）；返回**最高世代**的日志（= 宿主 `findLog` 选中的当前世代）。
+* 未命中 / 不可读 → null（非错误，调用方按"未知"处理）。
+* @param root - DSH 会话 root（{@link sessionsRootDir}）
+* @param sessionId - 会话目录名（`.bindings.json` 的键，含 `session-` 前缀）或裸 id
+* @returns 字节数 + 日志绝对路径；未命中 → null
+*/
+function sessionLogBytesById(root, sessionId) {
+	if (sessionId === "" || !existsSync(root)) return null;
+	const dirName = sessionId.startsWith("session-") ? sessionId : `session-${sessionId}`;
+	for (const project of readdirSync(root, { withFileTypes: true })) {
+		if (!project.isDirectory()) continue;
+		const log = findSessionLog(join(root, project.name, dirName));
+		if (log === null) continue;
+		try {
+			return {
+				bytes: statSync(log).size,
+				path: log
+			};
+		} catch {
+			return null;
+		}
+	}
+	return null;
+}
+/**
+* **(c) 绑定一致性兜底**的判据：某会话的日志**是否仍在磁盘上**。
+*
+* 🔴 **fail-closed**：sessions root 本身不存在时**一律返回 true（当作"在"）**——
+* 否则换 `DSH_HOME` / 换机器会让"全部绑定看起来都悬空"，进而误清整张绑定表。
+* 只有"root 在、而这个会话目录确实不在"才算悬空。
+* @param sessionRoot - DSH 会话 root（{@link sessionsRootDir}）
+* @param sessionId - 会话目录名（`.bindings.json` 的键）或裸 id
+*/
+function hasSessionLogById(sessionRoot, sessionId) {
+	if (!existsSync(sessionRoot)) return true;
+	return sessionLogBytesById(sessionRoot, sessionId) !== null;
+}
 /** 便捷：默认 N 天前为 cutoff（供 API/调用方） */
 function cutoffDaysAgo(days, nowMs = Date.now()) {
 	return nowMs - days * DAY_MS;
 }
 //#endregion
-export { cutoffDaysAgo, performCleanup, sessionsRootDir };
+export { session_cleanup_exports as n, sessionsRootDir as r, hasSessionLogById as t };

package/lib/session-cleanup.d.ts

@@ -73,6 +73,41 @@ export declare function performCleanup(root: string, cutoffMs: number, liveIds?:
     candidates: CandidateSession[];
     result: CleanupResult | null;
 };
+/**
+ * 某一 dsh 会话（目录名 / 会话 id）的**当前世代日志体积**（字节）。
+ *
+ * 为什么要它（S142 §0y「旧会话累积 ⇒ dsh 内存崩溃」，所有者令）：
+ *   · 宿主恢复/继续一条会话必须**重放全部事件**（`scanLog` → `materializeAppendBatch`）
+ *     ⇒ **代价 ∝ 日志体积**；
+ *   · 实测（`_tmp/measure-session-load.mjs`，照宿主 `scanZstdFrames` 复刻）：
+ *     一条 **72.2 MB**（zstd）的日志 = 35 559 个 frame / 252.6 MB 文本 / 62 680 条事件，
+ *     **光是读一遍峰值 RSS +1 175 MB**（探针什么都不保留）；
+ *   · 而宿主的解析缓存 `COLD_LOG_MEMO_MAX_ENTRIES = 2` 是**按条数限、不按字节限**的
+ *     （`dsh-session-persistence-jsonl/lib/index.js:2175`）⇒ 两条巨日志 = 上限内。
+ * 🔴 **在本函数之前，ACC 侧没有任何地方知道"绑定的这条会话日志多大"——这个信号根本不存在。**
+ * 这是"靠 agent 自觉 rebuild 不够"的机制层原因（keeper 的 K 量的是**模型上下文**，压缩后回落；
+ * 而**日志文件只增不减** ⇒ rebuild 提醒永远不会因为"日志 72 MB"触发）。
+ *
+ * 只认会话目录（含任意世代日志）；返回**最高世代**的日志（= 宿主 `findLog` 选中的当前世代）。
+ * 未命中 / 不可读 → null（非错误，调用方按"未知"处理）。
+ * @param root - DSH 会话 root（{@link sessionsRootDir}）
+ * @param sessionId - 会话目录名（`.bindings.json` 的键，含 `session-` 前缀）或裸 id
+ * @returns 字节数 + 日志绝对路径；未命中 → null
+ */
+export declare function sessionLogBytesById(root: string, sessionId: string): {
+    bytes: number;
+    path: string;
+} | null;
+/**
+ * **(c) 绑定一致性兜底**的判据：某会话的日志**是否仍在磁盘上**。
+ *
+ * 🔴 **fail-closed**：sessions root 本身不存在时**一律返回 true（当作"在"）**——
+ * 否则换 `DSH_HOME` / 换机器会让"全部绑定看起来都悬空"，进而误清整张绑定表。
+ * 只有"root 在、而这个会话目录确实不在"才算悬空。
+ * @param sessionRoot - DSH 会话 root（{@link sessionsRootDir}）
+ * @param sessionId - 会话目录名（`.bindings.json` 的键）或裸 id
+ */
+export declare function hasSessionLogById(sessionRoot: string, sessionId: string): boolean;
 /** 便捷：默认 N 天前为 cutoff（供 API/调用方） */
 export declare function cutoffDaysAgo(days: number, nowMs?: number): number;
 export {};

package/lib/time.d.ts

@@ -0,0 +1,50 @@
+/**
+ * time.ts — ACC **时间呈现的单一真相源**（S142 2026-09-17，所有者令：「统一 ACC 所有使用时间的地方使用当地时区」）
+ *
+ * ── 存在的理由：**把"时刻"与"呈现"分开**（R↓）
+ *
+ *  · **时刻（instant）** = epoch 毫秒（`Date.now()`）—— **与时区无关**。
+ *    比较 / 差值 / TTL / 调度 / TOTP 一律照旧，**不得"本地化"**：
+ *    把时刻换成"当地钟面"会让它**不可比**（跨偏移、跨夏令时都会错）。
+ *  · **呈现（rendition）** = 给人看、或存给人看的字符串 —— **一律当地时区 + 显式偏移**，
+ *    如 `2026-09-17T17:20:00.123+08:00`。
+ *    ⚠️ **偏移不能省**（这是本模块最容易被"简化"掉的一点）：省了就丢掉"这是哪一刻"，
+ *    而且**跨格式的字符串排序会错**（`...T09:00:00Z` 与 `...T17:00:00+08:00` 是同一刻，
+ *    字典序却相反）。带偏移的 RFC3339 **同时**满足"当地钟面"与"可解析、可比较"。
+ *  · **当地** = 运行机器的本地时区（node 在 `Asia/Shanghai` 即 `+08:00`）—— **不硬编码时区名**，
+ *    否则换机器/换地区就错。偏移**按被格式化的那个时刻求**（`getTimezoneOffset` 随夏令时变化）。
+ *
+ * ── 用法边界（本模块**只**做呈现；不做时刻运算）
+ *   ✅ `isoLocal()` / `localDate()` / `localDateTime()` / `localHuman()` / `localFileStamp()`
+ *   ❌ 不要用它们做排序/比较/差值 —— 那些用 `Date.now()` / `Date.parse()` / epoch 运算。
+ *
+ * 出处：所有者 2026-09-17 令（统一当地时区 + 注入消息带当前时间）；设计判据见 S142 §0r。
+ */
+/**
+ * 该**时刻**的 UTC 偏移（`+08:00` / `-05:00`）。
+ * ⚠️ 必须传入要格式化的那个 date —— 偏移随夏令时变化，不能"取当前的偏移去格式化另一个时刻"。
+ */
+export declare function tzOffset(date?: Date): string;
+/**
+ * **RFC3339 当地时区**（带毫秒与偏移）：`2026-09-17T17:20:00.123+08:00`。
+ * 存储与会话间交换的**默认呈现**（可被 `Date.parse` 原样解析回同一时刻）。
+ */
+export declare function isoLocal(value?: Date | number): string;
+/** 当地日期 `YYYY-MM-DD`（目录名/日期前缀） */
+export declare function localDate(value?: Date | number): string;
+/** 当地 `YYYY-MM-DD HH:mm:ss`（人读；**不带偏移**，只用于已经明确"是本地时间"的展示位） */
+export declare function localDateTime(value?: Date | number): string;
+/** 当地 `YYYY-MM-DD HH:mm`（人读，到分钟） */
+export declare function localDateTimeMinutes(value?: Date | number): string;
+/**
+ * **人读 + 偏移**：`2026-09-17 17:20:00 +08:00`。
+ * 给"注入给 agent 的文本"用 —— 既要一眼看懂当地钟面，又不丢"这是哪一刻"。
+ */
+export declare function localHuman(value?: Date | number): string;
+/**
+ * 文件名/ID 用的紧凑当地戳：`2026-09-17T172000`（可排序、无冒号/点，跨平台安全）。
+ * 与 CCC 的文件命名底线一致（`<ISO8601 本地>-<短随机>`）。
+ */
+export declare function localFileStamp(value?: Date | number): string;
+/** 唤醒条目 id 的当地戳部分：`YYYYMMDD-HHmm`（`w-<stamp>-<hex>`） */
+export declare function localIdStamp(value?: Date | number): string;

package/lib/{trajectory-bound-CApZRbvx.js → trajectory-bound-B9o_4CMF.js}

@@ -1,6 +1,92 @@
 import { r as cccRootForCwd } from "./ccc-roots-Bd_SjEs7.js";
 import { basename, dirname, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "node:fs";
+//#region src/time.ts
+/**
+* time.ts — ACC **时间呈现的单一真相源**（S142 2026-09-17，所有者令：「统一 ACC 所有使用时间的地方使用当地时区」）
+*
+* ── 存在的理由：**把"时刻"与"呈现"分开**（R↓）
+*
+*  · **时刻（instant）** = epoch 毫秒（`Date.now()`）—— **与时区无关**。
+*    比较 / 差值 / TTL / 调度 / TOTP 一律照旧，**不得"本地化"**：
+*    把时刻换成"当地钟面"会让它**不可比**（跨偏移、跨夏令时都会错）。
+*  · **呈现（rendition）** = 给人看、或存给人看的字符串 —— **一律当地时区 + 显式偏移**，
+*    如 `2026-09-17T17:20:00.123+08:00`。
+*    ⚠️ **偏移不能省**（这是本模块最容易被"简化"掉的一点）：省了就丢掉"这是哪一刻"，
+*    而且**跨格式的字符串排序会错**（`...T09:00:00Z` 与 `...T17:00:00+08:00` 是同一刻，
+*    字典序却相反）。带偏移的 RFC3339 **同时**满足"当地钟面"与"可解析、可比较"。
+*  · **当地** = 运行机器的本地时区（node 在 `Asia/Shanghai` 即 `+08:00`）—— **不硬编码时区名**，
+*    否则换机器/换地区就错。偏移**按被格式化的那个时刻求**（`getTimezoneOffset` 随夏令时变化）。
+*
+* ── 用法边界（本模块**只**做呈现；不做时刻运算）
+*   ✅ `isoLocal()` / `localDate()` / `localDateTime()` / `localHuman()` / `localFileStamp()`
+*   ❌ 不要用它们做排序/比较/差值 —— 那些用 `Date.now()` / `Date.parse()` / epoch 运算。
+*
+* 出处：所有者 2026-09-17 令（统一当地时区 + 注入消息带当前时间）；设计判据见 S142 §0r。
+*/
+/** 两位补零（超两位按原样，用于毫秒 3 位） */
+function pad(n, width = 2) {
+	return String(n).padStart(width, "0");
+}
+/**
+* 该**时刻**的 UTC 偏移（`+08:00` / `-05:00`）。
+* ⚠️ 必须传入要格式化的那个 date —— 偏移随夏令时变化，不能"取当前的偏移去格式化另一个时刻"。
+*/
+function tzOffset(date = /* @__PURE__ */ new Date()) {
+	const minutesEast = -date.getTimezoneOffset();
+	const sign = minutesEast >= 0 ? "+" : "-";
+	const abs = Math.abs(minutesEast);
+	return `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+}
+/** 归一成 Date（接受 Date 或 epoch 毫秒） */
+function toDate(value = Date.now()) {
+	return value instanceof Date ? value : new Date(value);
+}
+/**
+* **RFC3339 当地时区**（带毫秒与偏移）：`2026-09-17T17:20:00.123+08:00`。
+* 存储与会话间交换的**默认呈现**（可被 `Date.parse` 原样解析回同一时刻）。
+*/
+function isoLocal(value = Date.now()) {
+	const d = toDate(value);
+	return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}` + tzOffset(d);
+}
+/** 当地日期 `YYYY-MM-DD`（目录名/日期前缀） */
+function localDate(value = Date.now()) {
+	const d = toDate(value);
+	return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+/** 当地 `YYYY-MM-DD HH:mm:ss`（人读；**不带偏移**，只用于已经明确"是本地时间"的展示位） */
+function localDateTime(value = Date.now()) {
+	const d = toDate(value);
+	return `${localDate(d)} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+/** 当地 `YYYY-MM-DD HH:mm`（人读，到分钟） */
+function localDateTimeMinutes(value = Date.now()) {
+	const d = toDate(value);
+	return `${localDate(d)} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+/**
+* **人读 + 偏移**：`2026-09-17 17:20:00 +08:00`。
+* 给"注入给 agent 的文本"用 —— 既要一眼看懂当地钟面，又不丢"这是哪一刻"。
+*/
+function localHuman(value = Date.now()) {
+	const d = toDate(value);
+	return `${localDateTime(d)} ${tzOffset(d)}`;
+}
+/**
+* 文件名/ID 用的紧凑当地戳：`2026-09-17T172000`（可排序、无冒号/点，跨平台安全）。
+* 与 CCC 的文件命名底线一致（`<ISO8601 本地>-<短随机>`）。
+*/
+function localFileStamp(value = Date.now()) {
+	const d = toDate(value);
+	return `${localDate(d)}T${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+/** 唤醒条目 id 的当地戳部分：`YYYYMMDD-HHmm`（`w-<stamp>-<hex>`） */
+function localIdStamp(value = Date.now()) {
+	const d = toDate(value);
+	return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}`;
+}
+//#endregion
 //#region src/trajectory-ops.ts
 /**
 * trajectory-ops.ts — 轨迹工具纯操作层（零 DSH 依赖，可独立单测）
@@ -142,7 +228,7 @@ function showSession(root, key) {
 }
 /** 生成 SESSION.md 模板（对齐 osp：goal 写入目标段，时间戳 YYYY-MM-DD HH:mm） */
 function sessionMdTemplate(title, id, goal, now) {
-	const ts = now.toISOString().slice(0, 16).replace("T", " ");
+	const ts = localDateTimeMinutes(now);
 	return `# SESSION: ${title}\n- ID: ${id}\n\n## 目标\n${goal ?? "（待补充）"}\n\n## 状态\n- [ ] 进行中\n\n## 关键决策\n| # | 决策 | 理由 |\n|---|------|------|\n| 1 | | |\n\n## 进度记录\n- ${ts} — 创建\n\n## 产出物\n- \n\n## 未解决的问题\n- \n`;
 }
 /** create 子命令（对齐 osp createSession：--desc/--issue 二选一 + dry-run + 长度限制） */
@@ -156,7 +242,7 @@ function createSession(opts) {
 	const { root, desc, issue, goal, dryRun } = opts;
 	const sessionsDir = sessionsRoot(root);
 	const now = /* @__PURE__ */ new Date();
-	const datePrefix = now.toISOString().slice(0, 10);
+	const datePrefix = localDate(now);
 	if (!desc && !issue) throw new Error("create requires either --desc or --issue");
 	if (desc && issue) throw new Error("--desc and --issue are mutually exclusive");
 	if (issue) {
@@ -558,6 +644,7 @@ function listBoundSessionIds(root, dirName) {
 	for (const [id, raw] of Object.entries(file.sessions)) {
 		const rec = asBoundRecord(raw);
 		if (!rec || rec.dirName !== dirName) continue;
+		if (rec.supersededAt !== void 0) continue;
 		hits.push({
 			id,
 			at: typeof rec.at === "number" ? rec.at : 0
@@ -566,6 +653,82 @@ function listBoundSessionIds(root, dirName) {
 	return hits.sort((a, b) => b.at - a.at).map((h) => h.id);
 }
 /**
+* **(b) 同一 trajectory 多 live 会话的机械守卫**（S142 §0y，所有者 2026-09-18 裁「b 做」）。
+*
+* 把绑定到 `dirName` 的**其它**会话 id 标记为 `supersededAt` —— **保留记录**（沿革/正向查询不丢），
+* 只切断"**唤醒还会找到它**"这条路。语义上即"解绑"，且**不动那个会话本身**（它仍可被人工使用）。
+*
+* 为什么必须有机制（R↓）：`.bindings.json` 的语义是"latest-wins 覆盖**本条会话记录**"，
+* 对**同一 trajectory 的其它会话**没有任何约束 ⇒ 多代会话自然堆积（实测 S142 4 代 / S185 2 代），
+* 而 `acquireWakeAgent` 是"遍历全部绑定 id、任一条 live 就用它"——**两条 live 都能被选中**。
+*
+* @param root CCC 根
+* @param dirName 目标 trajectory 目录名
+* @param keepIds 保留（不标记）的会话 id 集合——通常是"当前正在 use 的这条"
+* @returns **实际被标记**的会话 id（升序稳定；供调用方如实报告，未标记任何一条 → `[]`）
+*/
+function supersedeOtherBindings(root, dirName, keepIds) {
+	const path = join(root, BINDINGS_REL_PATH);
+	const file = readBindingsFile(path);
+	const marked = [];
+	const at = Date.now();
+	for (const [id, raw] of Object.entries(file.sessions)) {
+		const rec = asBoundRecord(raw);
+		if (!rec || rec.dirName !== dirName) continue;
+		if (keepIds.has(id) || rec.supersededAt !== void 0) continue;
+		rec.supersededAt = at;
+		file.sessions[id] = rec;
+		marked.push(id);
+	}
+	if (marked.length === 0) return [];
+	try {
+		writeBindingsFile(path, file);
+	} catch {
+		return [];
+	}
+	return marked.sort();
+}
+/**
+* **(c) 绑定一致性兜底**（S142 §0y，所有者 2026-09-18 裁「c 也算个兜底」）：
+* 删除指向**已不存在**的 dsh 会话的绑定记录。
+*
+* 为什么需要：`.bindings.json` **只增不清**，而 DSH 会话目录会被
+* `session-cleanup`（本仓既有机制）物理删除 ⇒ 表里必然残留**悬空 id**。
+* 悬空记录本身无害，但它会**污染反向索引**（`listBoundSessionIds` 是唤醒选人的唯一入口），
+* 让"这条轨迹到底还有没有可用会话"变得不可判。
+*
+* 🔴 **安全性由调用方的判据负责**（本函数是纯函数，不认识文件系统）：
+* `isMissing` 必须是 **fail-closed** 的（读不到 ⇒ 返回 false = "不当作缺失"），
+* 见 `hasSessionLogById`。判据写错会**清掉整张表**，故此处刻意不提供默认实现。
+*
+* @param root CCC 根
+* @param isMissing 判据：该会话 id 是否**确认**已不存在（false = 保留）
+* @returns 被删除的会话 id（升序稳定；未删任何一条 → `[]`）
+*/
+function pruneMissingBindings(root, isMissing) {
+	const path = join(root, BINDINGS_REL_PATH);
+	const file = readBindingsFile(path);
+	const removed = [];
+	for (const id of Object.keys(file.sessions)) {
+		let missing;
+		try {
+			missing = isMissing(id);
+		} catch {
+			continue;
+		}
+		if (!missing) continue;
+		delete file.sessions[id];
+		removed.push(id);
+	}
+	if (removed.length === 0) return [];
+	try {
+		writeBindingsFile(path, file);
+	} catch {
+		return [];
+	}
+	return removed.sort();
+}
+/**
 * 写入绑定（latest-wins 覆盖该会话记录）。
 *
 * 绑定持久化尽力而为：无法定位 CCC 根 / 无会话 id / 写盘失败 → 返回 false，不阻断主流程。
@@ -594,4 +757,4 @@ function appendBound(session, action, rec) {
 	}
 }
 //#endregion
-export { sessionsRoot as _, DEFAULT_SESSION_SCOPE as a, summarize as b, createSession as c, getActiveSessionInfo as d, listSessions as f, sessionEvents as g, resolveSessionByTitle as h, resolveSessionTrajectoryLabel as i, extractSessionMdPathFromText as l, readActiveSessionMd as m, listBoundSessionIds as n, TRAJECTORY_ACTIONS as o, parseSessionContextFromEvents as p, readLastBound as r, clearActiveSessionInfo as s, appendBound as t, findSession as u, setActiveSessionInfo as v, useSession as x, showSession as y };
+export { useSession as C, localIdStamp as D, localHuman as E, summarize as S, localFileStamp as T, resolveSessionByTitle as _, resolveSessionTrajectoryLabel as a, setActiveSessionInfo as b, TRAJECTORY_ACTIONS as c, extractSessionMdPathFromText as d, findSession as f, readActiveSessionMd as g, parseSessionContextFromEvents as h, readLastBound as i, clearActiveSessionInfo as l, listSessions as m, listBoundSessionIds as n, supersedeOtherBindings as o, getActiveSessionInfo as p, pruneMissingBindings as r, DEFAULT_SESSION_SCOPE as s, appendBound as t, createSession as u, sessionEvents as v, isoLocal as w, showSession as x, sessionsRoot as y };

package/lib/trajectory-bound.d.ts

@@ -31,6 +31,17 @@ interface SessionBoundRecord {
     action: SessionBoundAction;
     at: number;
     note?: string;
+    /**
+     * **(b) 已被取代标记**（S142 §0y，所有者 2026-09-18 裁「b 做」）。
+     *
+     * 语义：这条绑定**仍然存在**（沿革不丢、正向 `readLastBound` 仍能查到"我曾属于哪条轨迹"），
+     * 但**不再作为唤醒候选**（{@link listBoundSessionIds} 过滤掉）——这正是"解绑"的机械形态。
+     *
+     * 为什么需要（实证）：`.bindings.json` 只增不清——实测 S142 名下挂 **4 代**、S185 挂 **2 代**，
+     * 同一 trajectory 因此可以有**两条 live 会话**：各持一份完整上下文（内存翻倍）
+     * 且**都在写同一批文件**（双写者）。
+     */
+    supersededAt?: number;
 }
 /** 绑定文件相对 CCC 根的路径 */
 export declare const BINDINGS_REL_PATH = "AGENT_SESSIONS/.bindings.json";
@@ -73,6 +84,40 @@ export declare function resolveSessionTrajectoryLabel(session: unknown, scope: s
  * @returns 会话 id 列表（最新绑定在前）；无绑定 → `[]`
  */
 export declare function listBoundSessionIds(root: string, dirName: string): string[];
+/**
+ * **(b) 同一 trajectory 多 live 会话的机械守卫**（S142 §0y，所有者 2026-09-18 裁「b 做」）。
+ *
+ * 把绑定到 `dirName` 的**其它**会话 id 标记为 `supersededAt` —— **保留记录**（沿革/正向查询不丢），
+ * 只切断"**唤醒还会找到它**"这条路。语义上即"解绑"，且**不动那个会话本身**（它仍可被人工使用）。
+ *
+ * 为什么必须有机制（R↓）：`.bindings.json` 的语义是"latest-wins 覆盖**本条会话记录**"，
+ * 对**同一 trajectory 的其它会话**没有任何约束 ⇒ 多代会话自然堆积（实测 S142 4 代 / S185 2 代），
+ * 而 `acquireWakeAgent` 是"遍历全部绑定 id、任一条 live 就用它"——**两条 live 都能被选中**。
+ *
+ * @param root CCC 根
+ * @param dirName 目标 trajectory 目录名
+ * @param keepIds 保留（不标记）的会话 id 集合——通常是"当前正在 use 的这条"
+ * @returns **实际被标记**的会话 id（升序稳定；供调用方如实报告，未标记任何一条 → `[]`）
+ */
+export declare function supersedeOtherBindings(root: string, dirName: string, keepIds: ReadonlySet<string>): string[];
+/**
+ * **(c) 绑定一致性兜底**（S142 §0y，所有者 2026-09-18 裁「c 也算个兜底」）：
+ * 删除指向**已不存在**的 dsh 会话的绑定记录。
+ *
+ * 为什么需要：`.bindings.json` **只增不清**，而 DSH 会话目录会被
+ * `session-cleanup`（本仓既有机制）物理删除 ⇒ 表里必然残留**悬空 id**。
+ * 悬空记录本身无害，但它会**污染反向索引**（`listBoundSessionIds` 是唤醒选人的唯一入口），
+ * 让"这条轨迹到底还有没有可用会话"变得不可判。
+ *
+ * 🔴 **安全性由调用方的判据负责**（本函数是纯函数，不认识文件系统）：
+ * `isMissing` 必须是 **fail-closed** 的（读不到 ⇒ 返回 false = "不当作缺失"），
+ * 见 `hasSessionLogById`。判据写错会**清掉整张表**，故此处刻意不提供默认实现。
+ *
+ * @param root CCC 根
+ * @param isMissing 判据：该会话 id 是否**确认**已不存在（false = 保留）
+ * @returns 被删除的会话 id（升序稳定；未删任何一条 → `[]`）
+ */
+export declare function pruneMissingBindings(root: string, isMissing: (sessionId: string) => boolean): string[];
 /**
  * 写入绑定（latest-wins 覆盖该会话记录）。
  *

package/lib/wake-registry.d.ts

@@ -22,11 +22,11 @@ export declare const WAKE_CATCH_UP_MS: number;
 type WakeState = 'pending' | 'delivered' | 'missed' | 'cancelled';
 /** 一条唤醒条目 */
 export interface WakeEntry {
-    /** 稳定 id（不复用；`w-<UTC 到分钟>-<4 hex>`） */
+    /** 稳定 id（不复用；`w-<当地到分钟>-<4 hex>`） */
     id: string;
     /** 目标 trajectory：`S###` 或完整 AGENT_SESSIONS 目录名（编码无关，与绑定锚一致） */
     target: string;
-    /** 绝对时刻（UTC RFC3339，如 `2026-09-14T01:00:00.000Z`） */
+    /** 绝对时刻（当地 RFC3339 带偏移，如 `2026-09-14T09:00:00.000+08:00`） */
     at: string;
     /** 唤醒 message（投递给目标 trajectory 的正文） */
     message: string;
@@ -34,13 +34,13 @@ export interface WakeEntry {
     state: WakeState;
     /** 发起者（轨迹标识，如 `S142`；可见性/审计用） */
     createdBy: string;
-    /** 登记时刻（UTC RFC3339） */
+    /** 登记时刻（当地 RFC3339 带偏移） */
     createdAt: string;
     /** 已尝试投递次数 */
     attempts: number;
     /** 最近一次投递结果（人读；失败必须留痕——禁止静默） */
     lastResult: string | null;
-    /** 投递成功时刻（UTC RFC3339） */
+    /** 投递成功时刻（当地 RFC3339 带偏移） */
     deliveredAt: string | null;
 }
 /** 注册表文件形态 */
@@ -59,7 +59,7 @@ export declare function loadWakeRegistry(root: string): {
     registry: WakeRegistry;
     error: string | null;
 };
-/** 条目 id：`w-<UTC 到分钟>-<4 hex>`（可读 + 低碰撞；不复用由"物理移除"保证） */
+/** 条目 id：`w-<当地到分钟>-<4 hex>`（可读 + 低碰撞；不复用由"物理移除"保证） */
 export declare function newWakeId(nowMs: number, rand?: () => number): string;
 /**
  * 解析唤醒时刻。接受两种写法（设计文档 §7）：

package/lib/{wake-scheduler-B50eu0jb.js → wake-scheduler-CCpCk-7r.js}

@@ -1,6 +1,6 @@
 import { r as hostService, t as hostAgents } from "./access-fiehjxV6.js";
 import { o as listCccs } from "./ccc-roots-Bd_SjEs7.js";
-import { _ as sessionsRoot, n as listBoundSessionIds, u as findSession } from "./trajectory-bound-CApZRbvx.js";
+import { D as localIdStamp, E as localHuman, f as findSession, n as listBoundSessionIds, w as isoLocal, y as sessionsRoot } from "./trajectory-bound-B9o_4CMF.js";
 import { t as readSimpleSettings } from "./settings-section-DMDUoQum.js";
 import { basename, dirname, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
@@ -115,10 +115,9 @@ function saveWakeRegistry(root, registry) {
 		};
 	}
 }
-/** 条目 id：`w-<UTC 到分钟>-<4 hex>`（可读 + 低碰撞；不复用由"物理移除"保证） */
+/** 条目 id：`w-<当地到分钟>-<4 hex>`（可读 + 低碰撞；不复用由"物理移除"保证） */
 function newWakeId(nowMs, rand = Math.random) {
-	const iso = new Date(nowMs).toISOString();
-	return `w-${`${iso.slice(0, 10).replace(/-/g, "")}-${iso.slice(11, 16).replace(":", "")}`}-${Math.floor(rand() * 65536).toString(16).padStart(4, "0")}`;
+	return `w-${localIdStamp(nowMs)}-${Math.floor(rand() * 65536).toString(16).padStart(4, "0")}`;
 }
 /**
 * 解析唤醒时刻。接受两种写法（设计文档 §7）：
@@ -187,11 +186,11 @@ function addWake(root, input) {
 	const entry = {
 		id: newWakeId(input.nowMs),
 		target,
-		at: new Date(parsed.ms).toISOString(),
+		at: isoLocal(parsed.ms),
 		message,
 		state: "pending",
 		createdBy: input.createdBy,
-		createdAt: new Date(input.nowMs).toISOString(),
+		createdAt: isoLocal(input.nowMs),
 		attempts: 0,
 		lastResult: null,
 		deliveredAt: null
@@ -573,6 +572,7 @@ function wakeSchedulerState() {
 * @param root CCC 根
 * @param dirName 目标 trajectory 目录名
 * @returns 命中返回 agent 与取得方式（how 进 lastResult，便于诊断）；未命中返回原因
+*   （原因带 `notReady` = **环境未就绪**而非投递失败，调用方**不得**据此记一次失败）
 */
 async function acquireWakeAgent(ctx, root, dirName) {
 	const agents = hostAgents(ctx);
@@ -587,7 +587,10 @@ async function acquireWakeAgent(ctx, root, dirName) {
 	if (ids.length > 0) {
 		const sc = hostService(ctx, "sessionController");
 		const resolved = sc?.resolveAgent;
-		if (typeof resolved !== "function") return { error: `目标会话未加载且 sessionController 不可用（headless profile？）——绑定 id: ${ids[0]}` };
+		if (typeof resolved !== "function") return {
+			error: `宿主尚未就绪：目标会话未加载，且 sessionController 服务此刻不可用（重启后的启动窗口，或本进程确实无该服务）——绑定 id: ${ids[0]}`,
+			notReady: true
+		};
 		const id = ids[0];
 		try {
 			const out = await resolved.call(sc, id);
@@ -606,6 +609,7 @@ async function acquireWakeAgent(ctx, root, dirName) {
 function buildWakeText(entry, target) {
 	return [
 		`[trajectory 唤醒] 到点（登记于 ${entry.createdAt}，发起者 ${entry.createdBy || "未知"}，id ${entry.id}）。`,
+		`当前时间：${localHuman()}（当地时区）。`,
 		"",
 		`身份锚定：继续 ${target.dirName} 的 trajectory（SESSION.md: ${target.mdPath}）。`,
 		"",
@@ -631,7 +635,8 @@ async function deliverWake(ctx, root, entry) {
 	const acquired = await acquireWakeAgent(ctx, root, target.dirName);
 	if ("error" in acquired) return {
 		ok: false,
-		detail: acquired.error
+		detail: acquired.error,
+		notReady: acquired.notReady === true
 	};
 	try {
 		acquired.agent.followup(createUserMessage({
@@ -654,29 +659,33 @@ async function deliverWake(ctx, root, entry) {
 }
 /**
 * 即时消息正文（**刻意不复用** {@link buildWakeText}）：唤醒文本以「**到点**（登记于…）」开头，
-* 对即时投递那是**错的事实**。本函数显式区分"这是即时消息、不是到点唤醒"，
-* 并写明"消息已入队、若此前在跑轮次则本轮结束后生效"（防目标误判时序）。
+* 对即时投递那是**错的事实**。本函数显式区分"这是即时消息、不是到点唤醒"。
+*
+* ⚠️ **v1.39.2 起"已入队"这句话必须删掉**（S142 §0r，所有者令「不排队、直接即时注入」）：
+* 旧文案写"消息已进入你的队列；你此前若正在跑轮次，它在本轮结束后生效"——
+* 那是**旧的 followup 语义**；现在在跑的目标走 `steer`（当场注入当前轮），
+* 留着这句话就是**注入一条假陈述**（比没有更坏：目标会误判自己看到它的时机）。
 * @param target 目标轨迹（目录名 + SESSION.md）
 * @param message 递送正文
 * @param sender 发起者轨迹标识（供目标与人类识别来源）
 */
 function buildSendText(target, message, sender) {
 	return [
-		`[即时消息] 来自 ${sender || "未知轨迹"}。`,
+		`[即时消息] 来自 ${sender || "未知轨迹"}。当前时间：${localHuman()}（当地时区）。`,
 		"",
 		`身份锚定：继续 ${target.dirName} 的 trajectory（SESSION.md: ${target.mdPath}）。`,
 		"",
 		"消息：",
 		message,
 		"",
-		"说明：这是**即时投递**（不是到点唤醒）——消息已进入你的队列；你此前若正在跑轮次，它在本轮结束后生效。处理完照常把进展写入 SESSION.md。"
+		"说明：这是**即时投递**（不是到点唤醒）——它**不排队**：目标正在跑轮次就**当场注入当前轮**，目标空闲则立即起一轮。处理完照常把进展写入 SESSION.md。"
 	].join("\n");
 }
 /**
 * 即时投递（`container_trajectory send-now`）——与 `send-later`（预约）**共用取用通路**（`acquireWakeAgent`），
 * 区别只在**时刻**（现在 vs 未来）与**回执**（有 vs 无）：
 *   · `send-later`（原 `wake-later`）：未来时刻 + 一条 message → 落注册表 → 本文件的调度器到点投递（**fire-and-forget，无回执**）
-*   · `send-now`（原 `send-message`）：**此刻**把一条 message 递进目标队列 → **同步回执** → **不落注册表**
+*   · `send-now`（原 `send-message`）：**此刻**把一条 message 递给目标 → **同步回执** → **不落注册表**
 *
 * **为什么冷路径落在这里（R↓，2026-09-16 所有者裁决）**：`addWake` 显式拒绝 `at ≤ now`
 * （"时刻必须在未来"——那是"**预约**"语义的地基，不许放宽）⇒ 即时投递**不能**靠一条
@@ -684,10 +693,20 @@ function buildSendText(target, message, sender) {
 * 必须直接走 {@link acquireWakeAgent}（live 优先 → `sessionController.resolveAgent` 冷载入）。
 * 这正对应所有者要的「**会话不活跃则等效于直接 wake**」：**同一条冷载入通路**，只是**不等 tick**。
 *
-* ⚠️ **承诺边界（不许含糊）**：回执只到「**已入队**」（`followup` 未抛错），
-* **到不了**"目标已执行/已答复" —— 与 `deliverWake` 同一层。目标若正在跑轮次，
-* 消息**排在轮次边界**（**不打断当前轮**）。判"目标真的动了"必须用**文件级判据**
-* （它自己的 SESSION.md），**不得凭回执结案**（§12.B 的 `delivered ≠ 跑了一轮`）。
+* ⚠️ **承诺边界（不许含糊）**：回执只到「**已注入 / 已起轮**」（宿主调用未抛错），
+* **到不了**"目标已执行/已答复" —— 与 `deliverWake` 同一层。
+* 判"目标真的动了"必须用**文件级判据**（它自己的 SESSION.md），
+* **不得凭回执结案**（§12.B 的 `delivered ≠ 跑了一轮`）。
+*
+* 🔴 **v1.39.2 语义变更（S142 §0r，所有者 2026-09-17 令：「希望 send message 时不排队，
+* 可以直接作为提示词即时注入进去」）**：
+* 旧实现一律 `followup`（宿主注释：*Queue an ordinary follow-up turn*）⇒ 目标**正在跑轮次**时
+* 消息**排在轮次边界**（即旧文案的"不打断当前轮"）。现按宿主 `agent.status` 分流：
+*   · `status === 'idle'` ⇒ `followup`（宿主**同步**把 status 置 running ⇒ **立即起轮**，本就不排队）
+*   · 否则（在跑）      ⇒ **`steer`** —— **当场注入当前轮**，这才是"不排队"的关键路径
+* ⚠️ **fail-safe**：`steer` 抛错 ⇒ **退回 `followup`**：**宁可排队，不可静默丢消息**。
+* ⚠️ **只改 `send-now`**：`send-later`（{@link deliverWake}）**保持 `followup`** ——
+* 预约的本职是"到点唤起"，且在跑时排队不打断是它被实证验收过的行为，不顺手动它。
 *
 * **归属**：本函数放在调度器侧而非工具侧 —— "怎么把一句话送到一条轨迹"是**调度器的知识**，
 * 工具只该知道"有这个动作"。这样 `trajectory.ts` 完全不碰调度器内部（v1.35.0 硬约束①：
@@ -711,24 +730,48 @@ async function sendToTrajectory(ctx, root, target, message, sender) {
 		ok: false,
 		detail: acquired.error
 	};
+	const agent = acquired.agent;
+	const make = () => createUserMessage({
+		content: [{
+			type: "text",
+			text: buildSendText(t, message, sender)
+		}],
+		source: PLUGIN_SOURCE
+	});
+	if (agent.status === "idle") {
+		try {
+			agent.followup(make());
+		} catch (err) {
+			return {
+				ok: false,
+				detail: `投递失败（${acquired.how}）: ${String(err?.message ?? err)}`
+			};
+		}
+		return {
+			ok: true,
+			detail: `已即时投递 ${t.dirName}（${acquired.how}；目标空闲 ⇒ followup 立即起轮）`
+		};
+	}
 	try {
-		acquired.agent.followup(createUserMessage({
-			content: [{
-				type: "text",
-				text: buildSendText(t, message, sender)
-			}],
-			source: PLUGIN_SOURCE
-		}));
+		agent.steer(make());
+		return {
+			ok: true,
+			detail: `已即时注入 ${t.dirName}（${acquired.how}；目标在跑 ⇒ steer 当场注入当前轮）`
+		};
 	} catch (err) {
+		try {
+			agent.followup(make());
+		} catch (err2) {
+			return {
+				ok: false,
+				detail: `投递失败（${acquired.how}）: steer 与 followup 均失败: ${String(err?.message ?? err)} / ${String(err2?.message ?? err2)}`
+			};
+		}
 		return {
-			ok: false,
-			detail: `投递失败（${acquired.how}）: ${String(err?.message ?? err)}`
+			ok: true,
+			detail: `已投递 ${t.dirName}（${acquired.how}；steer 不可用 ⇒ 退回 followup）: ${String(err?.message ?? err)}`
 		};
 	}
-	return {
-		ok: true,
-		detail: `已即时投递 ${t.dirName}（${acquired.how}）`
-	};
 }
 /**
 * 本 tick 要扫的 CCC 根集合（**并集**）。
@@ -773,11 +816,15 @@ async function runWakeTick(ctx) {
 		}
 		for (const e of due) {
 			const res = await deliverWake(ctx, root, e);
+			if (res.notReady) {
+				log.push(`· ${root}: ${e.id} → 跳过（宿主服务未就绪，下个 tick 再试；不计失败）`);
+				continue;
+			}
 			updateWake(root, e.id, {
 				state: res.ok ? "delivered" : "pending",
 				attempts: e.attempts + 1,
 				lastResult: res.detail,
-				deliveredAt: res.ok ? (/* @__PURE__ */ new Date()).toISOString() : null
+				deliveredAt: res.ok ? isoLocal() : null
 			});
 			log.push(`· ${root}: ${e.id} → ${res.ok ? "delivered" : `重试（${res.detail}）`}`);
 		}

package/lib/wake-scheduler.d.ts

@@ -14,7 +14,8 @@
  *     → 回退：live 会话标题匹配
  *  3. agent：**live 优先**（`ctx.agents.get`）→ 冷会话走 `ctx.sessionController.resolveAgent`
  *     （宿主实现：live 优先 + resume 去重 + 由会话元数据恢复 preset）
- *     → `sessionController` 缺席（headless profile）⇒ 仅投递 live 目标，**不静默**
+ *     → `sessionController` 缺席 ⇒ 仅投递 live 目标，**不静默**（v1.39.3：**归为"环境未就绪"**
+ *       而非"投递失败"，见 `WakeDeliveryResult.notReady` —— 启动那一拍早于懒服务就绪是常态）
  *  4. 投递：`agent.followup(...)`（"Queue an ordinary follow-up turn and wake the driver"）
  *
  * 守卫（I-4 默认 + v1.34 S-1 解耦）：全局 `wakeSchedulerEnabled`（**缺省开**；**不再**回退旧键
@@ -28,6 +29,19 @@ import { type WakeEntry } from './wake-registry.js';
 interface WakeDeliveryResult {
     ok: boolean;
     detail: string;
+    /**
+     * 🔴 **环境未就绪**（不是投递失败）——只有一种情形：目标需要**冷载入**，而宿主此刻**还没把
+     * 懒服务 `sessionController` 供上来**（典型 = `dsh web` 刚重启：时钟武装时**立刻跑一次 tick**，
+     * 那一拍早于懒服务就绪、也早于会话恢复）。
+     *
+     * 为什么要把它和"真失败"分开（2026-09-17 实测，S142 §0t）：
+     * 旧实现把这一情形当成投递失败写进条目 ⇒ ① `attempts` 无端 +1 ② `lastResult` 留下一条
+     * **误导性错误**（原文猜"headless profile？"，而真因是**重启窗口**，属**假陈述**）
+     * ③ 注册表/面板里出现"失败的投递"，**每次 restart 都必然复现**——一个**假告警发生器**
+     * （所有者 2026-09-17 就是被它引来的）。而消息**从未丢失**：下一个 tick 就投成功了。
+     * ⇒ 判据：**"宿主服务还没起来"不是投递结果**，不得计入条目。
+     */
+    notReady?: boolean;
 }
 /**
  * 调度器**进程态**（诊断用，模块级 = 进程级，正是诊断对象）。
@@ -72,8 +86,12 @@ export declare function buildWakeText(entry: WakeEntry, target: WakeTarget): str
 export declare function deliverWake(ctx: Context, root: string, entry: WakeEntry): Promise<WakeDeliveryResult>;
 /**
  * 即时消息正文（**刻意不复用** {@link buildWakeText}）：唤醒文本以「**到点**（登记于…）」开头，
- * 对即时投递那是**错的事实**。本函数显式区分"这是即时消息、不是到点唤醒"，
- * 并写明"消息已入队、若此前在跑轮次则本轮结束后生效"（防目标误判时序）。
+ * 对即时投递那是**错的事实**。本函数显式区分"这是即时消息、不是到点唤醒"。
+ *
+ * ⚠️ **v1.39.2 起"已入队"这句话必须删掉**（S142 §0r，所有者令「不排队、直接即时注入」）：
+ * 旧文案写"消息已进入你的队列；你此前若正在跑轮次，它在本轮结束后生效"——
+ * 那是**旧的 followup 语义**；现在在跑的目标走 `steer`（当场注入当前轮），
+ * 留着这句话就是**注入一条假陈述**（比没有更坏：目标会误判自己看到它的时机）。
  * @param target 目标轨迹（目录名 + SESSION.md）
  * @param message 递送正文
  * @param sender 发起者轨迹标识（供目标与人类识别来源）
@@ -83,7 +101,7 @@ export declare function buildSendText(target: WakeTarget, message: string, sende
  * 即时投递（`container_trajectory send-now`）——与 `send-later`（预约）**共用取用通路**（`acquireWakeAgent`），
  * 区别只在**时刻**（现在 vs 未来）与**回执**（有 vs 无）：
  *   · `send-later`（原 `wake-later`）：未来时刻 + 一条 message → 落注册表 → 本文件的调度器到点投递（**fire-and-forget，无回执**）
- *   · `send-now`（原 `send-message`）：**此刻**把一条 message 递进目标队列 → **同步回执** → **不落注册表**
+ *   · `send-now`（原 `send-message`）：**此刻**把一条 message 递给目标 → **同步回执** → **不落注册表**
  *
  * **为什么冷路径落在这里（R↓，2026-09-16 所有者裁决）**：`addWake` 显式拒绝 `at ≤ now`
  * （"时刻必须在未来"——那是"**预约**"语义的地基，不许放宽）⇒ 即时投递**不能**靠一条
@@ -91,10 +109,20 @@ export declare function buildSendText(target: WakeTarget, message: string, sende
  * 必须直接走 {@link acquireWakeAgent}（live 优先 → `sessionController.resolveAgent` 冷载入）。
  * 这正对应所有者要的「**会话不活跃则等效于直接 wake**」：**同一条冷载入通路**，只是**不等 tick**。
  *
- * ⚠️ **承诺边界（不许含糊）**：回执只到「**已入队**」（`followup` 未抛错），
- * **到不了**"目标已执行/已答复" —— 与 `deliverWake` 同一层。目标若正在跑轮次，
- * 消息**排在轮次边界**（**不打断当前轮**）。判"目标真的动了"必须用**文件级判据**
- * （它自己的 SESSION.md），**不得凭回执结案**（§12.B 的 `delivered ≠ 跑了一轮`）。
+ * ⚠️ **承诺边界（不许含糊）**：回执只到「**已注入 / 已起轮**」（宿主调用未抛错），
+ * **到不了**"目标已执行/已答复" —— 与 `deliverWake` 同一层。
+ * 判"目标真的动了"必须用**文件级判据**（它自己的 SESSION.md），
+ * **不得凭回执结案**（§12.B 的 `delivered ≠ 跑了一轮`）。
+ *
+ * 🔴 **v1.39.2 语义变更（S142 §0r，所有者 2026-09-17 令：「希望 send message 时不排队，
+ * 可以直接作为提示词即时注入进去」）**：
+ * 旧实现一律 `followup`（宿主注释：*Queue an ordinary follow-up turn*）⇒ 目标**正在跑轮次**时
+ * 消息**排在轮次边界**（即旧文案的"不打断当前轮"）。现按宿主 `agent.status` 分流：
+ *   · `status === 'idle'` ⇒ `followup`（宿主**同步**把 status 置 running ⇒ **立即起轮**，本就不排队）
+ *   · 否则（在跑）      ⇒ **`steer`** —— **当场注入当前轮**，这才是"不排队"的关键路径
+ * ⚠️ **fail-safe**：`steer` 抛错 ⇒ **退回 `followup`**：**宁可排队，不可静默丢消息**。
+ * ⚠️ **只改 `send-now`**：`send-later`（{@link deliverWake}）**保持 `followup`** ——
+ * 预约的本职是"到点唤起"，且在跑时排队不打断是它被实证验收过的行为，不顺手动它。
  *
  * **归属**：本函数放在调度器侧而非工具侧 —— "怎么把一句话送到一条轨迹"是**调度器的知识**，
  * 工具只该知道"有这个动作"。这样 `trajectory.ts` 完全不碰调度器内部（v1.35.0 硬约束①：

package/package.json

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