@eddyskywalker/dsh-chatgpt-subscription 0.60.0 → 0.61.0

package/lib/entry-plan-mode-CLRKkgYG.js

@@ -0,0 +1,1787 @@
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { z } from "zod";
+import { Service } from "@deepseek-ai/cordis";
+//#region src/host/dispatch-execution-guard.ts
+/**
+* 「调度执行守卫」——在**执行期**拦住两类越界调用，并把主控自己提问时的畸形
+* 载荷挡在弹窗之前。
+*
+* ## 为什么需要它
+*
+* 调度模式（dispatch preset）里主控与子代理跑在同一进程、同一套工具注册面上，
+* 于是有三件事会悄悄坏掉：
+*
+* 1. **子代理越权调用主控专用工具**。`ask_user_question`、`exit_plan_mode`、
+*    `create_goal` 这些是**主控的**决定口：让子代理自己问用户、自己进/出计划模式、
+*    自己建目标，都会把「一个决定」拆成两个决定——子代理问完，用户答了，主控却
+*    不知道问过什么。子代理本来就该把未决问题**带回**主控，而不是自己去问。
+* 2. **等待子代理期间空等**。子代理还在跑的时候，主控用 `sleep` 空转，既烧 token
+*    又错过通知到达的那一刻。正确做法是**结束这一轮**，让内置的子代理完成通知把
+*    它叫醒（R-W）。
+* 3. **主控自己的提问载荷畸形**。模型会把一次「给候选方案」写成同一道题问三遍、
+*    把选项整段 JSON 糊进键名（`"options [{"`）、把 `id` 写成 `":"` 或空串——
+*    用户在弹窗里点完，回答却对不回任何问题。这种载荷必须在**弹窗之前**就退回给
+*    模型，让它下一轮自己改对（见 {@link validateAskUserQuestionArgs}）。
+*
+* ## 零 Kimi Code 缓存漂移
+*
+* 守卫**只**用 `ctx.tools.guard(exec => …)` 这一条执行期接缝：
+*
+* - 不包 `tools.definitions`，不包 `tools.register`，不听
+*   `system-prompt/assemble`——工具声明面（`tools:sdk` 段与顶层工具 schema）
+*   保持逐字节恒定，Kimi Code 的前缀缓存不会因为这个守卫重建一次。
+* - 拦截发生在**调用执行时**，模型看到的工具表完全没变，所以「看得见」与
+*   「叫得动」仍然被拆开：工具照常出现在表里，只是越界的调用被拒。
+*
+* ## 判定从哪来
+*
+* 两条判定都走**结构探测**，不 import 任何 harness 代次专属的类型：
+*
+* - 「你是不是子代理」：先看**持久会话血缘**（`session.header.origin ===
+*   'subagent'`），再看宿主活着的**存活根**（`agents.roots()`）。两条都是
+*   读得着的既有事实，不新增任何状态。
+* - 「你还有没有在跑的子代理」：依次问 `subagents.list` 与 `agents.list`，
+*   看有没有 `status === 'running'` 的直接子代。
+*
+* @module @eddyskywalker/dsh-chatgpt-subscription/host/dispatch-execution-guard
+*/
+/**
+* 子代理**不得**直接调用的主控专用工具。
+*
+* 这七个都是「决定口」或「交付口」，不是「干活口」：
+*
+* - `ask_user_question` / `exit_plan_mode` / `enter_plan_mode` /
+*   `leave_plan_mode`：计划与提问的决定权在主控；
+* - `create_goal` / `update_goal`：目标由主控持有；
+* - `present`：交付口由主控掌握。
+*
+* 子代理遇到需要决定的地方，正确动作是**把问题带回主控**，让主控去调这些工具。
+*/
+const DEFAULT_DELEGATED_BLOCKED_TOOLS = Object.freeze([
+	"ask_user_question",
+	"exit_plan_mode",
+	"enter_plan_mode",
+	"leave_plan_mode",
+	"create_goal",
+	"update_goal",
+	"present"
+]);
+/**
+* 承载「等待」语义的 shell 工具。
+*
+* 这三个是本包与宿主都会用到的 shell 入口：它们的 `command` 参数里可能藏着
+* `sleep`。空等只在**确实有在跑的子代理**时才是问题（有子代理时应当结束这一
+* 轮等通知），没有子代理时 `sleep 1` 只是普通命令，不该拦。
+*/
+const DEFAULT_SHELL_TOOLS = Object.freeze([
+	"bash",
+	"pwsh",
+	"win_bash"
+]);
+/** 一次执行里被判定为「纯等待」的命令形态。 */
+const SLEEP_COMMAND_PATTERN = /^(?:sleep\s+\d+(?:\.\d+)?[smhd]?|Start-Sleep\s+(?:-(?:Seconds|Milliseconds|s|m)\s+)?\d+(?:\.\d+)?|timeout(?:\.exe)?\s+(?:\/t\s+)?\d+(?:\s+\/nobreak)?|ping(?:\.exe)?\s+-(?:n|c)\s+\d+\s+(?:127\.0\.0\.1|localhost)(?:\s+>|\s*$).*)$/i;
+/** 无害的空转语句（回显、真、冒号）。 */
+const NOOP_COMMAND_PATTERN = /^(?:echo\b.*|Write-Host\b.*|Write-Output\b.*|true|:)$/;
+/** 注释行。 */
+const COMMENT_COMMAND_PATTERN = /^#/;
+/**
+* 读宿主上下文上「直接注入」的 running-child 判定回调。
+*
+* 这一步必须**try/catch**：真实 Cordis 的上下文代理对任何没有 inject 的属性直读
+* 都当场抛 `cannot get property "..." without inject`，一次读失败不该让守卫在
+* 每次工具调用上抛错。
+*
+* @param ctx - 宿主上下文。
+* @returns 注入的回调；没有时为 undefined。
+*/
+function injectedHasRunningChildren(ctx) {
+	if (!isRecord(ctx)) return void 0;
+	let injected;
+	try {
+		injected = ctx["hasRunningChildren"];
+	} catch {
+		return;
+	}
+	return typeof injected === "function" ? injected : void 0;
+}
+/**
+* 判断一个值是不是可读的记录对象。
+*
+* @param value - 候选值。
+* @returns 是记录对象时为 true。
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* 从宿主上下文里读一个**可选**服务。
+*
+* 一律走 `ctx.get()`：没写进 `inject` 的服务名不能当属性读，真实 Cordis 会当场
+* 抛 `cannot get property "..." without inject`，整个插件降级。读不到就是读不到，
+* 守卫据此放行，绝不因此让插件挂不上。
+*
+* @param ctx - 宿主上下文。
+* @param name - 服务名。
+* @returns 服务实例；不存在或读取抛错时为 undefined。
+*/
+function readService(ctx, name) {
+	const reader = ctx?.get;
+	if (typeof reader !== "function") return void 0;
+	try {
+		return reader.call(ctx, name);
+	} catch {
+		return;
+	}
+}
+/**
+* 读一个宿主上下文里的工具注册面。
+*
+* @param ctx - 宿主上下文。
+* @returns 带 `guard` 接缝的注册面；没有时为 undefined。
+*/
+function toolsOf(ctx) {
+	if (!isRecord(ctx)) return void 0;
+	let tools;
+	try {
+		tools = ctx["tools"];
+	} catch {
+		tools = void 0;
+	}
+	if (!isRecord(tools)) tools = readService(ctx, "tools");
+	return isRecord(tools) ? tools : void 0;
+}
+/**
+* 读一条记录的 `id`。
+*
+* @param value - 候选记录。
+* @returns id 字符串；没有时为 undefined。
+*/
+function idOf(value) {
+	if (!isRecord(value)) return void 0;
+	const id = value["id"];
+	return typeof id === "string" ? id : void 0;
+}
+/**
+* 读一条会话记录头里的 `id`。
+*
+* @param agent - 候选 agent。
+* @returns 会话 id；没有时为 undefined。
+*/
+function sessionIdOf(agent) {
+	if (!isRecord(agent)) return void 0;
+	const session = agent["session"];
+	if (!isRecord(session)) return void 0;
+	const header = session["header"];
+	return idOf(header);
+}
+/**
+* 这个调用方是不是**子代理**。
+*
+* 判定分两级，先看能独立成立的持久事实，再看宿主当前活着的存活根：
+*
+* 1. **持久会话血缘**：`session.header.origin === 'subagent'`。这是子代理会话
+*    创建时就写下的血缘，跨宿主代次都在，不依赖任何服务是否挂载。
+* 2. **存活根判定**：宿主提供 `agents.roots()` 时，一个**不在**存活根集合里的
+*    agent 就是别人的孩子。先核对**存活**（`agents.get(id) === agent`）：不是
+*    那个 id 当前登记的存活 agent，说明这个调用方已经过期或已被顶替——判它是不是
+*    子代理没有意义，放行。
+*
+* 宿主没有 `agents` 服务（或老代没有 `roots`）时，判不了就**放行**：把一个
+* 读不出来的身份当成子代理去拦，会拦掉主控自己的正常调用。
+*
+* @param agent - 调用方 agent。
+* @param ctx - 宿主上下文（可选；用于读 `agents` 服务）。
+* @returns 是子代理时为 true。
+*/
+function isDelegatedCaller(agent, ctx) {
+	if (!isRecord(agent)) return false;
+	const session = agent["session"];
+	if (isRecord(session)) {
+		const header = session["header"];
+		if (isRecord(header) && header["origin"] === "subagent") return true;
+	}
+	const agents = readService(ctx, "agents");
+	if (!isRecord(agents)) return false;
+	const roots = rootsOf(agents);
+	if (roots === void 0) return false;
+	const id = idOf(agent);
+	if (typeof id === "string" && typeof agents["get"] === "function") {
+		let live;
+		try {
+			live = agents["get"].call(agents, id);
+		} catch {
+			live = void 0;
+		}
+		if (live !== agent) return false;
+	}
+	return !roots.includes(agent);
+}
+/**
+* 读宿主存活根集合。
+*
+* @param agents - `agents` 服务。
+* @returns 存活根数组；服务没有 `roots` 或读取抛错时为 undefined。
+*/
+function rootsOf(agents) {
+	const roots = agents["roots"];
+	if (typeof roots !== "function") return void 0;
+	try {
+		const listed = roots.call(agents);
+		return Array.isArray(listed) ? listed : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* 判断一条命令是不是**纯等待**。
+*
+* 判据：整条命令**按分隔符切开后**，至少有一条是 sleep/wait，而**每一条**都是
+* sleep/wait 或者无害的空转（回显、真、冒号、注释）。只要有一条在做真事
+* （`sleep 1 && npm test`、`git status`、`node …`），整条命令就不是纯等待——
+* 这类命令**必须放行**，否则守卫会拦掉正当的后台工作。
+*
+* @param command - 候选命令。
+* @returns 是纯等待时为 true。
+*/
+function isPureSleepCommand(command) {
+	if (typeof command !== "string") return false;
+	const trimmed = command.trim();
+	if (trimmed.length === 0) return false;
+	const statements = trimmed.split(/;|&&|\n/).map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+	if (statements.length === 0) return false;
+	let sawWait = false;
+	for (const statement of statements) {
+		if (SLEEP_COMMAND_PATTERN.test(statement)) {
+			sawWait = true;
+			continue;
+		}
+		if (!isNoopStatement(statement)) return false;
+	}
+	return sawWait;
+}
+/**
+* 判断一条语句是不是无害的空转。
+*
+* @param statement - 候选语句。
+* @returns 是空转时为 true。
+*/
+function isNoopStatement(statement) {
+	return NOOP_COMMAND_PATTERN.test(statement) || COMMENT_COMMAND_PATTERN.test(statement);
+}
+/**
+* 这个调用方当前**还有没有在跑的子代理**。
+*
+* 两条宿主探测，任何一条给出答案就算数：
+*
+* 1. `subagents.list(agent, 'children')`（老代退化成 `subagents.list(agent)`）：
+*    直接子代里有没有 `status === 'running'` 的。
+* 2. `agents.list()`：活着且 `status === 'running'`、并且 `parent` 就是这个
+*    调用方的那些 agent。
+*
+* 宿主提供 `hasRunningChildren` 回调时以它为准（直接注入口，见
+* {@link DispatchExecutionGuardOptions.hasRunningChildren}）。
+*
+* @param agent - 调用方 agent。
+* @param ctx - 宿主上下文（可选；用于读 `subagents` / `agents` 服务）。
+* @returns 有在跑的子代理时为 true。
+*/
+function hasRunningChildSubagent(agent, ctx) {
+	if (!isRecord(agent)) return false;
+	const injected = injectedHasRunningChildren(ctx);
+	if (injected !== void 0) try {
+		return injected(agent) === true;
+	} catch {
+		return false;
+	}
+	const subagents = readService(ctx, "subagents");
+	if (isRecord(subagents) && typeof subagents["list"] === "function") {
+		if (entriesOf(callList(subagents["list"], subagents, agent)).some((entry) => entry["status"] === "running")) return true;
+	}
+	const agents = readService(ctx, "agents");
+	if (isRecord(agents) && typeof agents["list"] === "function") {
+		const listed = callList(agents["list"], agents, agent, false);
+		const parentIds = /* @__PURE__ */ new Set();
+		const ownId = idOf(agent);
+		if (ownId !== void 0) parentIds.add(ownId);
+		const headerId = sessionIdOf(agent);
+		if (headerId !== void 0) parentIds.add(headerId);
+		if (entriesOf(listed).some((entry) => entry["status"] === "running" && typeof entry["parent"] === "string" && parentIds.has(entry["parent"]))) return true;
+	}
+	return false;
+}
+/**
+* 调用一个「列出子代」的宿主方法。
+*
+* 先试带 scope 的形态（`list(agent, 'children')`），老代只认 `list(agent)`，
+* 再老一代的 `agents.list()` 不接参数——三种都试，谁先成功用谁。
+*
+* @param fn - 宿主方法。
+* @param self - 调用宿主。
+* @param agent - 调用方 agent。
+* @param scoped - 是否先试带 scope 的形态。
+* @returns 宿主返回值；全部失败时为 undefined。
+*/
+function callList(fn, self, agent, scoped = true) {
+	if (typeof fn !== "function") return void 0;
+	const call = fn;
+	const attempts = scoped ? [
+		[agent, "children"],
+		[agent],
+		[]
+	] : [
+		[],
+		[agent],
+		[agent, "children"]
+	];
+	for (const args of attempts) try {
+		const listed = call.apply(self, args);
+		if (listed !== void 0) return listed;
+	} catch {}
+}
+/**
+* 从宿主返回值里取出「条目数组」。
+*
+* 宿主可能直接给数组，也可能给一个包着数组的记录（`children` / `agents`）。
+*
+* @param listed - 宿主返回值。
+* @returns 条目数组；取不到时是空数组。
+*/
+function entriesOf(listed) {
+	if (Array.isArray(listed)) return listed.filter(isRecord);
+	if (!isRecord(listed)) return [];
+	const entries = [];
+	for (const key of [
+		"children",
+		"agents",
+		"entries",
+		"list"
+	]) {
+		const candidate = listed[key];
+		if (!Array.isArray(candidate)) continue;
+		for (const entry of candidate) if (isRecord(entry)) entries.push(entry);
+	}
+	return entries;
+}
+/**
+* 解析「调度执行守卫」当前是否启用。
+*
+* 沿 volatile 活引用取当前值，所以设置保存后立刻生效。缺省、非法值、读取抛错都
+* 按**开启**处理：守卫是保护，不是功能开关，读失败不该把保护关掉。
+*
+* @param config - 插件配置（活引用或普通值）。
+* @returns 是否启用。
+*/
+function resolveDispatchExecutionGuardEnabled(config) {
+	const field = config?.dispatchExecutionGuard;
+	if (field === void 0 || field === null) return true;
+	if (typeof field === "object" && typeof field.get === "function") try {
+		return field.get() !== false;
+	} catch {
+		return true;
+	}
+	return field !== false;
+}
+/**
+* 子代理越权调用时的拒绝文案。
+*
+* 文案要**可执行**：光说「不许调」模型只会换个花样再试一次，所以这里写清楚
+* 它该做什么——把未决问题带回主控，并带上报告状态。
+*
+* @param toolName - 被拦下的工具名。
+* @returns 拒绝理由。
+*/
+function delegatedDenial(toolName) {
+	return `DELEGATED_CALLER: "${toolName}" is a dispatch-level tool and a delegated subagent must not call it directly. Report back to the dispatcher instead: include status: "hand_back" or status: "blocked" and the unresolved question or decision in your report, and let the dispatcher act on it.`;
+}
+/**
+* 子代理还在跑时用 sleep 空等的拒绝文案。
+*
+* @returns 拒绝理由。
+*/
+function activeChildSleepDenial() {
+	return "ACTIVE_CHILD_SLEEP_FORBIDDEN: a child subagent is still running, so sleeping to wait for it is not allowed. End your turn now and let the built-in subagent completion notification wake you.";
+}
+/**
+* 主控可以向用户提问的那一个工具名。
+*/
+const ASK_USER_QUESTION_TOOL = "ask_user_question";
+/**
+* 一个问题条目上可以出现的键。
+*
+* 这份清单只用在**修正指引**里：错位键被拦下时把它抄给模型，模型才知道该
+* 把字段放回哪里。清单本身不做白名单校验——宿主往后加字段不该被守卫拦掉。
+*/
+const ASK_QUESTION_KEYS = Object.freeze([
+	"id",
+	"question",
+	"header",
+	"options",
+	"multi_select",
+	"multiSelect",
+	"detail",
+	"intent",
+	"timeout"
+]);
+/**
+* 合法 `id` 至少要含一个字母或数字（含 CJK）。
+*
+* 光有标点或空白的 id 不是 id：生产里见过 `""`、`":"`、`"---"`，用户看到的
+* 回答回执全变成同一个无名标签，主控也没法把回答对回问题。
+*/
+const READABLE_ID_PATTERN = /[\p{L}\p{N}]/u;
+/**
+* 判断一个键名是不是 `options` 系列。
+*
+* 生产里的畸形载荷把 options 整段 JSON 糊进了键名：`"options [{"`、`"options："`
+* 、`"options:"`。它们的共同特征是**去掉首尾空白、转小写后以 `options` 开头**，
+* 所以判据就取这个前缀——`options` 本身也落在其中，调用方另行放过。
+*
+* @param key - 候选键名。
+* @returns 是 options 系列键时为 true。
+*/
+function isOptionsKey(key) {
+	return key.trim().toLowerCase().startsWith("options");
+}
+/**
+* 找出问题条目上**本该嵌在 `options` 里**的错位键。
+*
+* 两类错位都见过：
+*
+* - `label` / `description` 直接摊在问题对象上（选项字段漏了一层嵌套）；
+* - 键名本身是 options 的碎片（`"options [{"`、`"options："`），值往往是空串。
+*
+* @param question - 候选问题条目。
+* @returns 第一个错位键名；没有时为 undefined。
+*/
+function misplacedQuestionKey(question) {
+	for (const key of Object.keys(question)) {
+		if (key === "options") continue;
+		if (key === "label" || key === "description") return key;
+		if (isOptionsKey(key)) return key;
+	}
+}
+/**
+* 找出选项条目上的错位键。
+*
+* 一个选项只该有 `label` / `description`；出现 `question` 说明调用方把整道题
+* 又抄进了选项里，出现 `options*` 说明嵌套被摊平过了。
+*
+* @param option - 候选选项条目。
+* @returns 第一个错位键名；没有时为 undefined。
+*/
+function misplacedOptionKey(option) {
+	for (const key of Object.keys(option)) if (key === "question" || isOptionsKey(key)) return key;
+}
+/**
+* 一段供拒绝文案引用的短摘录。
+*
+* @param value - 原始文本。
+* @param limit - 最多保留多少个字符。
+* @returns 单行摘录。
+*/
+function excerpt(value, limit = 60) {
+	const collapsed = value.trim().replace(/\s+/g, " ");
+	return JSON.stringify(collapsed.length > limit ? `${collapsed.slice(0, limit)}…` : collapsed);
+}
+/**
+* 生成一条「提问载荷畸形」的拒绝文案。
+*
+* @param detail - 具体坏在哪里、该怎么改。
+* @returns 带 `INVALID_USER_QUESTION:` 前缀的拒绝理由。
+*/
+function invalidAskUserQuestion(detail) {
+	return `INVALID_USER_QUESTION: ${detail}`;
+}
+/**
+* 校验主控 `ask_user_question` 的调用载荷。
+*
+* 这是**执行期**的结构校验：工具声明面一个字节不动（前缀缓存零漂移），但畸形
+* 的载荷在真正弹给用户之前就被挡回给模型，让模型下一步就能自己改对。
+*
+* 三类畸形各自能被模型自助修好：
+*
+* 1. **选项嵌套被摊平**——`"options [{"`、`"options："` 这类键名，或者把
+*    `label` / `description` 摊在问题对象上。指引它写成
+*    `{"id": …, "question": …, "options": [{"label": …, "description": …}]}`。
+* 2. **`id` / `question` 退化**——空串、`":"`、`"---"`、纯空白，或者在同一个
+*    批次里重复。重复的问题文本要并成**一道题多个选项**，而不是问两遍。
+* 3. **选项内部坏掉**——不是对象、缺 `label`、同一题里 `label` 重复。
+*
+* **开放题必须继续放行**：`options` 缺省就是一道开放题，`options: []`（适配层
+* 的空数组兜底）同样放行；只有数组里真有条目时才逐条校验。
+*
+* 非对象载荷、缺 `questions`、`questions` 不是数组或为空时一律返回 undefined：
+* 那几种形态归底层工具自己的 schema 与空检查管，守卫不重复判、也不抢它的文案。
+*
+* @param args - 已解析的工具参数。
+* @returns 合法时为 undefined；畸形时是 `INVALID_USER_QUESTION: …` 文案。
+*/
+function validateAskUserQuestionArgs(args) {
+	if (!isRecord(args)) return void 0;
+	const questions = args["questions"];
+	if (!Array.isArray(questions) || questions.length === 0) return void 0;
+	const seenIds = /* @__PURE__ */ new Set();
+	const seenQuestions = /* @__PURE__ */ new Set();
+	for (let index = 0; index < questions.length; index += 1) {
+		const question = questions[index];
+		const at = `questions[${index}]`;
+		if (!isRecord(question)) return invalidAskUserQuestion(`${at} must be a question object. Known question keys: ${ASK_QUESTION_KEYS.join(", ")}.`);
+		const misplaced = misplacedQuestionKey(question);
+		if (misplaced !== void 0) return invalidAskUserQuestion(`${at} carries the misplaced key ${JSON.stringify(misplaced)}: option fields collapsed into the question object. Build ONE question object and nest its choices inside it: {"id": "palette", "question": "Which palette?", "options": [{"label": "Warm", "description": "…"}]}. Known question keys: ${ASK_QUESTION_KEYS.join(", ")}.`);
+		const id = question["id"];
+		if (typeof id !== "string" || id.trim().length === 0 || !READABLE_ID_PATTERN.test(id)) return invalidAskUserQuestion(`${at} needs "id" to be a non-empty string with at least one letter or digit. A blank string, whitespace, ":" or "---" is not a usable id: the answer is echoed back against that id, so use a stable slug such as "palette-choice".`);
+		const trimmedId = id.trim();
+		if (seenIds.has(trimmedId)) return invalidAskUserQuestion(`${at}.id ${JSON.stringify(trimmedId)} is already used by an earlier question in this batch. Every question needs a distinct stable id so each answer maps back to one question.`);
+		seenIds.add(trimmedId);
+		const text = question["question"];
+		if (typeof text !== "string" || text.trim().length === 0) return invalidAskUserQuestion(`${at} needs "question" to be a non-empty string with the text the user reads.`);
+		const normalizedText = text.trim().replace(/\s+/g, " ");
+		if (seenQuestions.has(normalizedText)) return invalidAskUserQuestion(`${at} repeats the question text ${excerpt(text)} already asked earlier in this batch. To offer several candidate choices, put them into ONE question's "options" array instead of asking the same question again.`);
+		seenQuestions.add(normalizedText);
+		const options = question["options"];
+		if (options === void 0) continue;
+		if (!Array.isArray(options)) return invalidAskUserQuestion(`${at}.options must be an array of {"label": "…", "description": "…"} objects. Omit "options" entirely when the question is open-ended.`);
+		if (options.length === 0) continue;
+		const seenLabels = /* @__PURE__ */ new Set();
+		for (let optionIndex = 0; optionIndex < options.length; optionIndex += 1) {
+			const option = options[optionIndex];
+			const optionAt = `${at}.options[${optionIndex}]`;
+			if (!isRecord(option)) return invalidAskUserQuestion(`${optionAt} must be an object like {"label": "…", "description": "…"}.`);
+			const optionMisplaced = misplacedOptionKey(option);
+			if (optionMisplaced !== void 0) return invalidAskUserQuestion(`${optionAt} carries the misplaced key ${JSON.stringify(optionMisplaced)}: an option object holds only "label" and "description", while "question" and "options" belong to the question object.`);
+			const label = option["label"];
+			if (typeof label !== "string" || label.trim().length === 0) return invalidAskUserQuestion(`${optionAt} needs a non-empty "label" string: the label is what the user clicks.`);
+			const trimmedLabel = label.trim();
+			if (seenLabels.has(trimmedLabel)) return invalidAskUserQuestion(`${optionAt}.label ${JSON.stringify(trimmedLabel)} repeats inside ${at}. Every option of one question needs a distinct label.`);
+			seenLabels.add(trimmedLabel);
+		}
+	}
+}
+/**
+* 装一台「调度执行守卫」。
+*
+* 只用 `ctx.tools.guard()` 这一条执行期接缝：工具声明面（`tools:sdk` 段与顶层
+* 工具 schema）一个字节都不改，Kimi Code 的前缀缓存不会因为这个守卫重建。
+*
+* @param ctx - 宿主上下文。
+* @param options - 守卫选项。
+* @returns 注销守卫的函数；宿主没有 `guard` 接缝时是一个空操作。
+*/
+function installDispatchExecutionGuard(ctx, options = {}) {
+	const tools = toolsOf(ctx);
+	const register = tools?.guard;
+	if (typeof register !== "function") return () => void 0;
+	const enabled = options.enabled ?? (() => true);
+	const delegatedBlocked = new Set(DEFAULT_DELEGATED_BLOCKED_TOOLS);
+	const shellTools = new Set(DEFAULT_SHELL_TOOLS);
+	const hasRunningChildren = options.hasRunningChildren;
+	const guard = (execution) => {
+		if (!isEnabled(enabled)) return void 0;
+		const toolName = typeof execution?.name === "string" ? execution.name : void 0;
+		if (toolName === void 0) return void 0;
+		const agent = execution?.agent;
+		if (delegatedBlocked.has(toolName) && isDelegatedCaller(agent, ctx)) return delegatedDenial(toolName);
+		if (toolName === ASK_USER_QUESTION_TOOL) {
+			const malformed = validateAskUserQuestionArgs(execution?.arguments);
+			if (malformed !== void 0) return malformed;
+		}
+		if (shellTools.has(toolName)) {
+			const args = isRecord(execution?.arguments) ? execution.arguments : void 0;
+			if (!(args?.["run_in_background"] === true) && isPureSleepCommand(args?.["command"])) {
+				if (hasRunningChildren !== void 0 ? hasRunningChildren(agent) === true : hasRunningChildSubagent(agent, ctx)) return activeChildSleepDenial();
+			}
+		}
+	};
+	const dispose = register.call(tools, guard);
+	return typeof dispose === "function" ? dispose : () => void 0;
+}
+/**
+* 读一次开关。读失败按**开启**处理：保护不该因为一次读失败而失效。
+*
+* @param enabled - 开关读取函数。
+* @returns 是否启用。
+*/
+function isEnabled(enabled) {
+	try {
+		return enabled() !== false;
+	} catch {
+		return true;
+	}
+}
+//#endregion
+//#region src/entry-plan-mode.ts
+/**
+* 「计划模式」服务 —— ctx.planMode 的 **fork**（本包在 dispatch preset 里替换
+* harness 官方的 @deepseek-ai/dsh-plan-mode）。
+*
+* ## 为什么必须 fork
+*
+* 官方实现的动态 plan:policy 段在进入/离开计划模式时翻转；exit_plan_mode 也带
+* { when } 逐步准入。0.2.2 起工具在首次进入后会持续保留，减少了后续切换的工具表
+* 变化，但首次准入与 system 段变化仍会重建 native tools 与 PTC tools:sdk 的前缀缓存。
+*
+* Kimi 线路按内容前缀命中，这两次重建是**计划模式必经**的固定税。这个 fork 把税
+* 取消掉，靠的是同一个观察：**末尾追加不破坏前缀**。
+*
+* ## 三个决定（每一个都对应上面一处重建）
+*
+* 1. **不注册任何动态 system 段。** system 段在整个会话里逐字节恒定。
+* 2. **exit_plan_mode 无条件注册。** 没有 { when }，它从会话第一步就在工具表里，
+*    进出计划模式都不改工具表；「只在计划模式可用」由 execute 里的 loggedActive
+*    判定执行（报错文案与官方一致）。代价是每一步多带一个工具声明，收益是
+*    native / PTC 两侧零重建。
+* 3. **部署方的 section 走尾部用户消息**（agent/pre-step 的 decision.messages，
+*    无回合时走 agent.inject），一次进入只投一次。手册性指引留在 enter_plan_mode
+*    的工具返回里（见 entry-plan-mode-pipeline.ts）。
+*
+* ## 第四件事：回合结束时的提醒（也不进前缀缓存）
+*
+* 计划模式里模型讲完一段话就收尾（`finish: stop`、零工具调用）时，宿主不会替它做任何
+* 事：那一回合就停在那里，直到人去催「确认呢」。`installPlanModeExitReminder` 在
+* `llm/stream` 上认一次**已完成、只有可见文本、零工具调用**的对话请求，在 agent 空闲
+* 之后补一条尾部消息（`createPlanNotice`），让模型自己选 `exit_plan_mode` /
+* `ask_user_question` / `leave_plan_mode`。它同样不注册 system 段、不动工具表，所以和
+* 上面三个决定一样零缓存漂移；cap 是每条连续收尾一条。
+*
+* ## 与官方实现的其余差别一律是「代次协商」，不是功能裁剪
+*
+* - plan 投影的 stateVersion 在 0.2.1-rc.5 及更早是 3（无 entered），0.2.2-alpha
+*   起是 4（含 entered）。sessionProjections.register 对同一个 key 的版本不一致是
+*   **硬失败**，而同一个宿主里另一个 preset 可能已经注册过它，所以这里先按 4 注册，
+*   失败时读错误里的 already registered at stateVersion N 用那个版本重试一次。
+* - register() 在旧代是同步的、状态要经 ctx.sessionProjections.stateOf() 读；新代
+*   返回可 await 的 ProjectionHandle。两种形状都在下面接住。
+* - 没有 sessionProjections（老代宿主）时退回进程内 WeakMap：计划模式照常可用，
+*   只是不随会话日志持久化。
+*
+* ## 不能 import 的东西
+*
+* @deepseek-ai/dsh-plan-mode / dsh-agent / dsh-session / dsh-commands /
+* dsh-user-questions / dsh-session-projection 都不在本包 peerDependencies 里，所以
+* 顶层**不 import 它们**，只按结构探测：ctx.get('sessionProjections')、
+* ctx.get('userQuestions')、ctx.get('tools')、ctx.get('agents')、ctx.get('commands')。
+*
+* @module @eddyskywalker/dsh-chatgpt-subscription/plan-mode
+*/
+/** 组件行名；preset 里的行 id 与模块说明符另由 preset 文件决定。 */
+const name = "dsh-chatgpt-subscription-plan-mode";
+/** 模型侧审批出口的工具名。冻结契约的一部分，不要改动。 */
+const EXIT_PLAN_MODE = "exit_plan_mode";
+/** 官方实现用来承载计划指引的 prompt 段名（这个 fork 刻意**不注册**它）。 */
+const PLAN_POLICY_SECTION = "plan:policy";
+/** plan 投影的 key。跨 preset 共享，不能改名。 */
+const PLAN_PROJECTION_KEY = "plan";
+/** 会话日志里记录计划模式开关的事件类型（与官方同名，投影可互换折叠）。 */
+const PLAN_MODE_EVENT = "plan/mode";
+/** 最新一代的投影状态版本（0.2.2-alpha 起：含 entered）。 */
+const PLAN_STATE_VERSION = 4;
+/** 旧一代（≤0.2.1-rc.5）的投影状态版本：没有 entered。 */
+const LEGACY_PLAN_STATE_VERSION = 3;
+/** 审批问题在答案里的 id。 */
+const REVIEW_ID = "plan-review";
+/** 审批问题「批准」选项的文案。 */
+const APPROVE_LABEL = "Approve";
+/** 审批问题「继续规划」选项的文案。 */
+const KEEP_PLANNING_LABEL = "Keep planning";
+/** 尾部通知消息的来源 kind（本包自有，见下方 MessageSourceMap 增补）。 */
+const PLAN_NOTICE_SOURCE_KIND = "plan-mode-notice";
+/**
+* 校验部署方配置。缺失、空白、类型不符与未知字段都在**挂载时**失败，而不是被忽略。
+* @param config - 原始插件配置。
+* @returns 一份脱离入参的校验后配置。
+* @throws {Error} 判定与文案与官方一致，便于既有部署配置与测试直接迁移。
+*/
+function resolveConfig(config) {
+	const section = config?.section;
+	if (typeof section !== "string") throw new Error("PlanModeConfig needs a string `section`");
+	if (section.trim() === "") throw new Error("PlanModeConfig needs a non-empty `section`");
+	const unknown = Object.keys(config ?? {}).filter((key) => key !== "section");
+	if (unknown.length > 0) throw new Error("PlanModeConfig has unknown key(s) " + unknown.join(", ") + " — config is { section }");
+	return { section };
+}
+/**
+* 投影状态 schema。
+*
+* 刻意**不用 strict()、并给 entered 一个默认值**：同一个 key 可能被按 v3 注册的
+* 另一份定义（≤0.2.1-rc.5，没有 entered 字段）写进持久化缓存，严格的 schema 会让
+* 那份缓存整行作废，进而把服务从「共享」变成「冲突」。
+*/
+const planUnitStateSchema = z.object({
+	active: z.boolean(),
+	wanted: z.boolean().nullable(),
+	running: z.object({
+		commandId: z.string(),
+		wanted: z.boolean()
+	}).nullable(),
+	activeAtLastHeader: z.boolean().nullable(),
+	entered: z.boolean().default(false)
+});
+/** 线上视图 schema。 */
+const planProjectionViewSchema = z.object({
+	active: z.boolean(),
+	pending: z.boolean()
+});
+/**
+* 造一份 plan 投影定义。
+*
+* 折叠逻辑与官方逐句等价：/plan 命令的生命周期（command/run -> command/done）、
+* plan/mode 整值记录、request/header 记下「上一次告诉模型的模式」。等价是硬要求：
+* 同一个宿主里另一份定义可能已经按别的 stateVersion 注册了同一个 key，两边折叠出的
+* 状态必须是同一个东西，共享才安全。
+* @param stateVersion - 投影状态版本，默认最新一代（4）。冲突时用冲突方的版本重试。
+* @returns 投影定义。
+*/
+function createPlanProjectionDefinition(stateVersion = 4) {
+	return {
+		key: PLAN_PROJECTION_KEY,
+		stateVersion,
+		stateSchema: planUnitStateSchema,
+		init: () => ({
+			active: false,
+			wanted: null,
+			running: null,
+			activeAtLastHeader: null,
+			entered: false
+		}),
+		apply: (state, event) => {
+			const data = event.data ?? {};
+			if (event.type === "command/run" && data.name === "plan") {
+				if (data.args === void 0) return state;
+				const wanted = typeof data.args === "string" ? data.args.trim() !== "off" : false;
+				return {
+					...state,
+					running: {
+						commandId: String(data.commandId ?? ""),
+						wanted
+					}
+				};
+			}
+			if (event.type === "command/done" && state.running !== null && data.commandId === state.running.commandId) {
+				const wanted = data.kind === "success" && state.running.wanted !== state.active ? state.running.wanted : null;
+				return {
+					...state,
+					wanted,
+					running: null
+				};
+			}
+			if (event.type === "plan/mode") {
+				const active = data.active === true;
+				return {
+					...state,
+					active,
+					wanted: null,
+					entered: state.entered || active
+				};
+			}
+			if (event.type === "request/header") return {
+				...state,
+				activeAtLastHeader: state.active
+			};
+			return state;
+		},
+		wire: {
+			viewSchema: planProjectionViewSchema,
+			view: (state) => {
+				const wanted = state.running?.wanted ?? state.wanted;
+				return {
+					active: state.active,
+					pending: wanted !== null && wanted !== state.active
+				};
+			}
+		}
+	};
+}
+/** 最新一代（stateVersion 4）的 plan 投影定义。 */
+const planProjectionDefinition = createPlanProjectionDefinition();
+/** 什么读不到时的空状态。 */
+const EMPTY_PLAN_STATE = Object.freeze({
+	active: false,
+	wanted: null,
+	running: null,
+	activeAtLastHeader: null,
+	entered: false
+});
+/**
+* 调用时读一个可选服务。服务缺席或读取抛错一律 undefined —— 这一行不该因为
+* 某个服务不在而挂不上。
+* @param ctx - 宿主上下文（结构类型：老代的 ctx 也认）。
+* @param service - 服务名。
+* @returns 服务实例；不存在或读取抛错时 undefined。
+*/
+function serviceOf(ctx, service) {
+	const read = ctx?.get;
+	if (typeof read !== "function") return void 0;
+	try {
+		return read.call(ctx, service);
+	} catch {
+		return;
+	}
+}
+/**
+* 记一条日志。日志服务缺席时安静跳过。
+* @param ctx - 宿主上下文。
+* @param level - 级别。
+* @param message - 正文。
+*/
+function log(ctx, level, message) {
+	const logger = ctx?.logger;
+	try {
+		if (level === "warn") logger?.warn(message);
+		else logger?.info(message);
+	} catch {}
+}
+/**
+* 会话对象作为 WeakMap 键。
+* @param session - 任意值。
+* @returns 是对象时原样返回，否则 undefined（没有会话就等于没有状态）。
+*/
+function objectKey(session) {
+	return typeof session === "object" && session !== null ? session : void 0;
+}
+/**
+* 从版本冲突错误里读冲突方的 stateVersion。
+* @param error - register 抛出的错误。
+* @returns 冲突方版本；不是版本冲突时 undefined。
+*/
+function conflictingStateVersion(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	const match = /already registered at stateVersion (\d+)/.exec(message);
+	if (match === null) return void 0;
+	const version = Number.parseInt(match[1], 10);
+	return Number.isSafeInteger(version) && version >= 0 ? version : void 0;
+}
+/**
+* 把 register() 的返回值接成句柄。
+*
+* 三种形状：可 await 的 ProjectionHandle（新代）、同步 disposer 函数（旧代，状态要
+* 经 ctx.sessionProjections.stateOf 读）、以及两者都不是（这一代没有投影注册面）。
+* @param ready - register 的返回值。
+* @param projections - 投影服务本身（旧代读状态的兜底）。
+* @returns 句柄；接不住时 undefined。
+*/
+async function handleOf(ready, projections) {
+	if (typeof ready?.then === "function") {
+		const handle = await ready;
+		return typeof handle?.stateOf === "function" ? handle : legacyHandle(projections);
+	}
+	return legacyHandle(projections);
+}
+/**
+* 旧代的读法：按 key 读。
+* @param projections - 投影服务。
+* @returns 句柄；服务没有按 key 读的能力时 undefined。
+*/
+function legacyHandle(projections) {
+	if (typeof projections.stateOf !== "function") return void 0;
+	return { stateOf: (session) => projections.stateOf?.(session, PLAN_PROJECTION_KEY) };
+}
+/**
+* 订阅一个事件；这一代没有事件总线时安静跳过。
+* @param ctx - 宿主上下文。
+* @param event - 事件名。
+* @param listener - 监听器。
+* @param options - cordis 订阅选项（`{ global: true }` 只看全局事件）。省略时按两参数订阅。
+* @returns 解绑函数；订不上时 undefined。
+*/
+function subscribe(ctx, event, listener, options) {
+	const on = ctx?.on;
+	if (typeof on !== "function") return void 0;
+	if (options !== void 0) try {
+		return on.call(ctx, event, listener, options);
+	} catch {}
+	try {
+		return on.call(ctx, event, listener);
+	} catch {
+		return;
+	}
+}
+/**
+* ctx.planMode 的实现。
+*
+* 一个会话一份（agent plane），所以内部所有状态都按会话/agent 分桶：待投递选择按
+* 会话 WeakMap，投影句柄一份（投影本身按会话折叠），内存兜底状态按会话 WeakMap。
+*/
+var PlanModeController = class extends Service {
+	/**
+	* 依赖：tools 注册审批出口，sessionProjections 折叠状态，agents 读回合边界。
+	*
+	* **故意不含 systemPrompt** —— 这个 fork 一个 prompt 段都不注册，system 段在
+	* 整个会话里逐字节恒定，进出计划模式都不重建前缀缓存。
+	*/
+	static inject = [
+		"tools",
+		"sessionProjections",
+		"agents"
+	];
+	/** 校验后的部署指引，只经尾部消息投递。 */
+	section;
+	/** plan 投影的读面；没有投影服务时 undefined。 */
+	planProjectionHandle;
+	/** 尚未落到日志的选择，按会话。 */
+	pendingIntents = /* @__PURE__ */ new WeakMap();
+	/** 没有投影服务时的内存状态兜底（计划模式照常可用，只是不持久化）。 */
+	memoryStates = /* @__PURE__ */ new WeakMap();
+	/** 服务在自己脚下被卸载：此时批过的计划不能再被追加，必须让模型重新呈交。 */
+	disposed = false;
+	/**
+	* @param ctx - 宿主上下文。
+	* @param config - 部署配置（默认空 section，会在挂载时被 resolveConfig 拒绝）。
+	*/
+	constructor(ctx, config = { section: "" }) {
+		super(ctx, "planMode");
+		this.section = resolveConfig(config).section;
+	}
+	/**
+	* 挂载主体：注册投影、订阅 pre-step、注册审批出口与 /plan 命令。
+	*
+	* 顺序有讲究：投影先就位，pre-step 与 exit_plan_mode 才能读到状态。
+	* @returns 挂载完成（投影注册可能是异步的）。
+	*/
+	async [Service.init]() {
+		const ctx = this.ctx;
+		this.planProjectionHandle = await this.acquirePlanProjection();
+		const effect = ctx?.effect;
+		if (typeof effect === "function") try {
+			effect.call(ctx, () => () => {
+				this.disposed = true;
+			}, "dsh-chatgpt-subscription: close plan-mode service");
+		} catch {}
+		this.subscribePreStep();
+		this.subscribeExitReminder();
+		this.registerExitTool();
+		this.registerPlanCommand();
+	}
+	/**
+	* 订阅「回合以纯文本收尾」的提醒。
+	*
+	* 读法是 {@link PlanModeController.selectedActive}：它含未决选择，所以
+	* `exit_plan_mode` 刚排进 `{ active: false }`、日志还没落的那一刻不会误提醒。
+	* 宿主里同时装着 `installPlanModeCacheGuard` 时，进程级登记册保证一条
+	* `llm/stream` 只被一条监听器接手，两处不会各提醒一次。
+	*/
+	subscribeExitReminder() {
+		const controller = this;
+		const dispose = installPlanModeExitReminder(this.ctx, { isActive: (agent) => controller.selectedActive(agent?.session) });
+		if (dispose === void 0) return;
+		const effect = this.ctx?.effect;
+		if (typeof effect !== "function") return;
+		try {
+			effect.call(this.ctx, () => dispose, "dsh-chatgpt-subscription: close the plan-mode exit reminder");
+		} catch {
+			dispose();
+		}
+	}
+	/**
+	* 注册 plan 投影，并在版本冲突时按冲突方的 stateVersion 重试一次。
+	*
+	* 冲突本身是「同一个宿主里另一个 preset 已经注册了 plan」：那不是错误，而是
+	* 共享同一个折叠单元的前提。所以只读错误里的版本号，不按 harness 版本猜。
+	* @returns 投影读面；这一代没有投影注册面时 undefined。
+	*/
+	async acquirePlanProjection() {
+		const projections = serviceOf(this.ctx, "sessionProjections");
+		if (projections === void 0 || typeof projections.register !== "function") {
+			log(this.ctx, "info", "[dsh-chatgpt-subscription] plan mode has no sessionProjections service: plan mode works but its state is not persisted in this host");
+			return;
+		}
+		let stateVersion = 4;
+		for (let attempt = 0; attempt < 2; attempt += 1) {
+			const definition = createPlanProjectionDefinition(stateVersion);
+			try {
+				return await handleOf(projections.register(definition), projections);
+			} catch (error) {
+				const reported = conflictingStateVersion(error);
+				if (reported === void 0 || reported === stateVersion) {
+					log(this.ctx, "warn", "[dsh-chatgpt-subscription] plan mode could not register the plan projection: " + (error instanceof Error ? error.message : String(error)));
+					return;
+				}
+				stateVersion = reported;
+			}
+		}
+	}
+	/**
+	* 服务是否已在自己脚下被卸载。
+	*
+	* 登记册（{@link registeredPlanControllerActive}）用它把「已经不算数的控制器」
+	* 摘出判定：卸载之后残留的登记不能让宿主继续按老状态提醒。
+	* @returns true 表示已卸载。
+	*/
+	isDisposed() {
+		return this.disposed;
+	}
+	/**
+	* 把会话对象绑进进程级登记册，让**宿主根作用域**也能读到本控制器的判定。
+	*
+	* 挂载点不止一个（`installPlanModeCacheGuard` 在根作用域、本控制器可能在
+	* `isolate: { planMode: true }` 的子 realm），而 `ctx.get()` 看不见子 realm。
+	* 控制器每观察到一个会话就登记一次，登记册跨 realm 共享，于是两边读到同一份
+	* 判定。已卸载就不再登记。
+	* @param session - 会话对象。
+	*/
+	bindSession(session) {
+		if (this.disposed) return;
+		const key = objectKey(session);
+		if (key === void 0) return;
+		exitReminderRegistry().controllers.set(key, this);
+	}
+	/**
+	* 已记录的计划状态。
+	* @param session - 会话。
+	* @returns 状态；读不到时是空状态（绝不抛错 —— 一个读失败不该打断整步）。
+	*/
+	planState(session) {
+		this.bindSession(session);
+		const handle = this.planProjectionHandle;
+		if (handle !== void 0) try {
+			const state = handle.stateOf(session);
+			if (typeof state === "object" && state !== null && typeof state.active === "boolean") return state;
+		} catch {}
+		const key = objectKey(session);
+		return key === void 0 ? EMPTY_PLAN_STATE : this.memoryStates.get(key) ?? EMPTY_PLAN_STATE;
+	}
+	/**
+	* 已记录的计划模式开关。
+	* @param session - 会话。
+	* @returns 是否在计划模式。
+	*/
+	loggedActive(session) {
+		return this.planState(session).active;
+	}
+	/**
+	* 本步会呈现给模型的状态：未决选择优先，否则是已记录状态。
+	* @param session - 会话。
+	* @returns 是否生效。
+	*/
+	selectedActive(session) {
+		const key = objectKey(session);
+		return (key === void 0 ? void 0 : this.pendingIntents.get(key))?.active ?? this.loggedActive(session);
+	}
+	/**
+	* 上一次告诉模型的模式；还没发过请求时 undefined。
+	* @param session - 会话。
+	* @returns true / false / undefined。
+	*/
+	loggedActiveAtLastHeader(session) {
+		return this.planState(session).activeAtLastHeader ?? void 0;
+	}
+	/**
+	* 会话是否处在打开的回合里（决定「立刻落日志」还是「等下一个被接受的 pre-step」）。
+	*
+	* 三级降级，与官方等价：agents.turnBoundaryOf（新代）> 投影里的 turnBoundary
+	* 状态（旧代）> 判定为没有打开回合（无从判定时按回合结束处理，与官方的
+	* 「回合之外立刻提交」一致）。
+	* @param session - 会话。
+	* @returns 是否有打开回合。
+	*/
+	hasOpenTurn(session) {
+		const agents = serviceOf(this.ctx, "agents");
+		if (typeof agents?.turnBoundaryOf === "function") try {
+			const boundary = agents.turnBoundaryOf(session);
+			if (boundary !== void 0) return boundary?.openTurnStartSeq !== null;
+		} catch {}
+		const projections = serviceOf(this.ctx, "sessionProjections");
+		if (typeof projections?.stateOf === "function") try {
+			const boundary = projections.stateOf(session, "turnBoundary");
+			if (boundary !== void 0) return boundary?.openTurnStartSeq !== null;
+		} catch {}
+		return false;
+	}
+	/**
+	* 读当前计划模式（已记录 + 未决选择），供调用方展示。
+	* @param agent - 要读的 agent。
+	* @returns 已记录状态，以及在果有未决选择时的目标。
+	*/
+	get(agent) {
+		const session = agent?.session;
+		const active = this.loggedActive(session);
+		const key = objectKey(session);
+		const pending = key === void 0 ? void 0 : this.pendingIntents.get(key);
+		return pending === void 0 ? { active } : {
+			active,
+			pending: pending.active
+		};
+	}
+	/**
+	* 选择计划模式是否生效。
+	*
+	* 回合之外立刻落日志并补一句说明；回合之内留作未决选择，等下一个被接受的
+	* pre-step（那时才写日志、才补说明）。重复选择当前值或已未决的同值是 no-op。
+	* @param agent - 要切换的 agent。
+	* @param active - 目标状态。
+	* @param options - 可选：narrate=false 表示调用方的工具结果已经把话说完了。
+	* @returns 发生了什么。
+	*/
+	set(agent, active, options = {}) {
+		const session = agent?.session;
+		const key = objectKey(session);
+		if (key === void 0) return "noop";
+		this.bindSession(session);
+		const narrate = options.narrate !== false;
+		if (active === (this.pendingIntents.get(key)?.active ?? this.loggedActive(session))) return "noop";
+		if (this.hasOpenTurn(session)) {
+			this.pendingIntents.set(key, {
+				active,
+				narrate
+			});
+			return this.loggedActive(session) === active ? "cancelled" : "queued";
+		}
+		if (active === this.loggedActive(session)) {
+			this.pendingIntents.delete(key);
+			return "cancelled";
+		}
+		this.appendMode(session, active);
+		this.pendingIntents.delete(key);
+		const narration = this.narration(session, active);
+		if (narration !== void 0) this.injectMessage(agent, narration);
+		return "committed";
+	}
+	/**
+	* 把一个未决选择落进日志。
+	* @param session - 会话。
+	*/
+	onBoundary(session) {
+		const key = objectKey(session);
+		if (key === void 0) return;
+		const pending = this.pendingIntents.get(key);
+		if (pending === void 0) return;
+		const target = pending.active;
+		if (target === this.loggedActive(session)) {
+			this.pendingIntents.delete(key);
+			return;
+		}
+		this.appendMode(session, target);
+		this.pendingIntents.delete(key);
+	}
+	/**
+	* 追加一条 plan/mode 事件，并同步内存兜底状态。
+	*
+	* 只在 append 成功后更新内存：写失败要留下可重试的选择，而不是一个假状态。
+	* @param session - 会话。
+	* @param active - 目标状态。
+	*/
+	appendMode(session, active) {
+		const append = session?.append;
+		if (typeof append === "function") append.call(session, PLAN_MODE_EVENT, { active });
+		const key = objectKey(session);
+		if (key === void 0) return;
+		const current = this.memoryStates.get(key) ?? EMPTY_PLAN_STATE;
+		this.memoryStates.set(key, {
+			...current,
+			active,
+			wanted: null,
+			entered: current.entered || active
+		});
+	}
+	/**
+	* 把一条尾部消息塞进当前会话。
+	* @param agent - 调用方 agent。
+	* @param message - 用户角色消息。
+	*/
+	injectMessage(agent, message) {
+		const inject = agent?.inject;
+		if (typeof inject === "function") {
+			inject.call(agent, message);
+			return;
+		}
+		const steer = agent?.steer;
+		if (typeof steer === "function") steer.call(agent, message);
+	}
+	/**
+	* 造一条「用户切换了模式」的尾部通知。
+	*
+	* 与官方的差别只有一处：进入时的通知**携带部署指引**（section）。官方把指引放在
+	* 动态 system 段里，那正是前缀重建的来源；改成一次性尾部消息后，指引只付一次
+	* 输入费，而且之后每一步都还在历史里（末尾追加不破坏前缀）。
+	*
+	* 触发条件也放宽了一点：官方只在「上一次请求头告诉过模型另一种模式」时才讲；
+	* 这里在进入方向还接受 told === undefined（用户在第一发请求之前就 /plan）。
+	* @param session - 会话。
+	* @param target - 目标状态。
+	* @returns 通知消息；不需要讲时 undefined。
+	*/
+	narration(session, target) {
+		const told = this.loggedActiveAtLastHeader(session);
+		if (target) {
+			if (told === true) return void 0;
+			return createPlanNotice("The user switched this session to plan mode.", this.section);
+		}
+		if (told !== true) return void 0;
+		return createPlanNotice("The user switched this session back to the default mode.");
+	}
+	/**
+	* 订阅 agent/pre-step：先 await next()，只对已经落定的决策动手。
+	*
+	* 三件事：把未决选择落进日志；在需要时把通知**追加到消息末尾**（末尾追加不改变
+	* 已发前缀，这是这个 fork 的全部意义所在）。
+	*/
+	subscribePreStep() {
+		const listener = async (payload, next) => {
+			const decision = await next();
+			const session = (payload?.agent)?.session;
+			const key = objectKey(session);
+			if (decision === void 0 || decision.kind === "reject" || key === void 0) return decision;
+			if (payload?.signal?.aborted === true) return decision;
+			if (!this.disposed) this.bindSession(session);
+			const pending = this.pendingIntents.get(key);
+			if (pending === void 0) return decision;
+			const narration = this.narration(session, pending.active);
+			try {
+				this.onBoundary(session);
+			} catch (error) {
+				log(this.ctx, "warn", "[dsh-chatgpt-subscription] failed to append the selected plan mode at step start: " + (error instanceof Error ? error.message : String(error)));
+				return decision;
+			}
+			if (pending.narrate === false || narration === void 0) return decision;
+			const messages = Array.isArray(decision.messages) ? decision.messages : [];
+			return {
+				...decision,
+				messages: [...messages, narration]
+			};
+		};
+		subscribe(this.ctx, "agent/pre-step", listener);
+	}
+	/**
+	* 注册 exit_plan_mode —— **不带 { when }**。
+	*
+	* 这是与官方唯一的工具面差别，也是 tools / tools:sdk 两边零重建的全部原因：
+	* 条件准入会让工具表在进入那一步变大，PTC 的 run_code 绑定与 native 声明同时重发。
+	* 无条件注册后，「只在计划模式可用」由 execute 里的 loggedActive 判定执行，报错
+	* 文案与官方一致。
+	*/
+	registerExitTool() {
+		const tools = serviceOf(this.ctx, "tools");
+		if (tools === void 0 || typeof tools.register !== "function") {
+			log(this.ctx, "info", "[dsh-chatgpt-subscription] plan mode has no tools service: exit_plan_mode was not registered, so the plan can only be left through /plan off");
+			return;
+		}
+		try {
+			tools.register(this.exitDefinition());
+		} catch (error) {
+			log(this.ctx, "warn", "[dsh-chatgpt-subscription] plan mode could not register exit_plan_mode: " + (error instanceof Error ? error.message : String(error)));
+		}
+	}
+	/**
+	* 造 exit_plan_mode 的定义。
+	* @returns 工具定义。
+	*/
+	exitDefinition() {
+		const ctx = this.ctx;
+		const controller = this;
+		return defineTool({
+			name: EXIT_PLAN_MODE,
+			description: "Use only in plan mode. Present your plan for the user's review and, on approval, leave plan mode. The user may approve (carry out the plan from your next step) or keep planning — their feedback comes back in the tool result; revise and present again.",
+			parameters: { plan: {
+				type: "string",
+				required: true,
+				description: "The complete plan, as markdown, starting with a # heading that names it."
+			} },
+			output: {
+				schema: {
+					type: "object",
+					additionalProperties: false,
+					properties: { approved: {
+						type: "boolean",
+						required: true
+					} }
+				},
+				render: (_args, value) => {
+					return [{
+						type: "text",
+						text: value?.approved === true ? "Plan approved — plan mode exited; carry out the plan starting with your next step." : "The user dismissed the plan review to reply in their own words; plan mode remains active."
+					}];
+				}
+			},
+			async execute(args, exec) {
+				const execution = exec;
+				const agent = execution.agent;
+				if (agent === void 0 || agent === null || !controller.loggedActive(agent.session)) throw new Error("exit_plan_mode is only available in plan mode");
+				const plan = typeof args.plan === "string" ? args.plan : "";
+				if (!/^#\s+\S/.test(plan.trim())) throw new Error("exit_plan_mode requires a non-empty markdown plan starting with a # heading");
+				const interaction = serviceOf(ctx, "userQuestions");
+				if (interaction === void 0 || typeof interaction.ask !== "function") throw new Error("no user-questions channel is available to review the plan; ask the user to switch the session mode instead");
+				let answer;
+				try {
+					answer = await interaction.ask({
+						questions: [{
+							id: REVIEW_ID,
+							header: "Plan review",
+							question: "Approve this plan and leave plan mode?",
+							detail: plan,
+							options: [{
+								label: APPROVE_LABEL,
+								description: "Leave plan mode; the plan is carried out from the next step."
+							}, {
+								label: KEEP_PLANNING_LABEL,
+								description: "Stay in plan mode; feedback goes back to the model."
+							}],
+							intent: {
+								kind: "plan-review",
+								approve: APPROVE_LABEL,
+								callId: execution.callId
+							}
+						}],
+						agent,
+						signal: execution.signal
+					});
+				} catch (cause) {
+					if (cause?.code === "ASK_CANCELLED") {
+						if (typeof execution.concludeTurn === "function") {
+							execution.concludeTurn();
+							return { approved: false };
+						}
+						throw new Error("the user dismissed the plan review and this harness generation cannot conclude the turn from a tool; present the plan again or switch the session mode instead");
+					}
+					throw cause;
+				}
+				if (controller.disposed) throw new Error("the plan-mode service was reloaded while the plan was under review; present the plan again");
+				const items = (answer?.answers ?? []).filter((entry) => entry.id === REVIEW_ID);
+				const item = items.length === 1 ? items[0] : void 0;
+				if (item?.selected.length !== 1 || item.selected[0] !== "Approve" || item.custom !== void 0) {
+					const feedback = typeof item?.custom === "string" ? item.custom : "";
+					throw new Error(feedback === "" ? "The user chose to keep planning; revise the plan and present it again." : "The user chose to keep planning; their feedback: " + feedback);
+				}
+				const key = objectKey(agent.session);
+				if (key !== void 0) controller.pendingIntents.set(key, {
+					active: false,
+					narrate: false
+				});
+				return { approved: true };
+			}
+		});
+	}
+	/**
+	* 注册 /plan 命令（手动进入/离开计划模式的入口）。
+	*
+	* 命令面板在部分宿主里不存在，所以这里用运行时注入：有 commands 才注册，
+	* 没有就安静跳过 —— 缺一个可选服务不该让计划模式整体挂不上。
+	*/
+	registerPlanCommand() {
+		const ctx = this.ctx;
+		const inject = ctx.inject;
+		if (typeof inject !== "function") return;
+		try {
+			inject.call(ctx, ["commands"], (scope) => {
+				const commands = serviceOf(scope, "commands");
+				if (commands === void 0 || typeof commands.register !== "function") return;
+				try {
+					commands.register({
+						definitionId: name,
+						name: "plan",
+						description: "Enter or leave plan mode",
+						input: {
+							hint: "[off|message]",
+							attachments: true
+						},
+						handler: (payload) => {
+							const raw = typeof payload?.rawInput === "string" ? payload.rawInput.trim() : "";
+							const attachments = Array.isArray(payload?.attachments) ? payload.attachments : [];
+							if (raw === "off" && attachments.length > 0) return {
+								kind: "error",
+								text: "Attachments cannot accompany /plan off."
+							};
+							if (raw === "off") switch (this.set(payload.agent, false)) {
+								case "committed": return {
+									kind: "success",
+									text: "Plan mode off."
+								};
+								case "queued": return {
+									kind: "success",
+									text: "Leaving plan mode (applies from the next step)."
+								};
+								case "cancelled": return {
+									kind: "success",
+									text: "Plan mode entry cancelled."
+								};
+								case "noop": return this.loggedActive(payload.agent?.session) ? {
+									kind: "success",
+									text: "Leaving plan mode (applies from the next step)."
+								} : {
+									kind: "success",
+									text: "Plan mode is already inactive."
+								};
+							}
+							const outcome = this.set(payload.agent, true);
+							if (raw !== "" || attachments.length > 0) {
+								const steer = payload.agent?.steer;
+								if (typeof steer === "function") steer.call(payload.agent, createUserMessage({
+									content: [...attachments, ...raw === "" ? [] : [{
+										type: "text",
+										text: raw
+									}]],
+									source: { kind: "user" }
+								}));
+							}
+							return {
+								kind: "success",
+								text: outcome === "committed" ? "Plan mode on. Use /plan off to leave." : "Entering plan mode (applies from the next step). Use /plan off to leave."
+							};
+						}
+					});
+				} catch {}
+			});
+		} catch {}
+	}
+};
+/**
+* 计划模式下「只用纯文本收尾」时投给模型的提醒正文。
+*
+* 冻结契约的一部分：只经 {@link createPlanNotice} 的尾部用户消息投递，**不进 system
+* 段、不动工具表**，所以它不会让任何前端前缀缓存重建。
+*/
+const PLAN_EXIT_REMINDER_TEXT = "Plan mode is still active, and the previous response ended in plain text without calling a tool. If the plan is ready, call exit_plan_mode now with the complete markdown plan (starting with a # heading) as the sole tool call. If an unsettled user decision blocks planning, call ask_user_question instead. If the user explicitly asked to abandon planning, call leave_plan_mode.";
+/** 登记册在 `globalThis` 上的键。跨模块实例共享，值本身只由本模块写入。 */
+const EXIT_REMINDER_KEY = Symbol.for("dsh-chatgpt-subscription.plan-mode.exit-reminder.claimed");
+/**
+* 取（或建）进程级登记册。
+*
+* 用 `Symbol.for` 而不是模块级常量：同一个进程里可能有两份本包实例（宿主插件与
+* preset 行分别加载），它们必须看到同一份 `claimed` / `states`。
+* @returns 登记册。
+*/
+function exitReminderRegistry() {
+	const holder = globalThis;
+	const existing = holder[EXIT_REMINDER_KEY];
+	if (existing !== void 0 && existing.claimed instanceof WeakSet && existing.states instanceof WeakMap && existing.controllers instanceof WeakMap) return existing;
+	const created = {
+		claimed: /* @__PURE__ */ new WeakSet(),
+		states: /* @__PURE__ */ new WeakMap(),
+		controllers: /* @__PURE__ */ new WeakMap()
+	};
+	holder[EXIT_REMINDER_KEY] = created;
+	return created;
+}
+/**
+* 用会话对象问本包的 {@link PlanModeController}：此刻算不算在计划模式。
+*
+* 与 `ctx.get('planMode')` 的区别是**看不见 realm 边界**：登记册挂在
+* `globalThis` 上，控制器往里面登记的是「这个会话由我负责」，所以宿主根作用域
+* 也能读到 preset 里 `isolate: { planMode: true }` 那个子 realm 的判定 —— 含未决
+* 选择（`exit_plan_mode` 刚排进 `{ active: false }`、日志还没落的那一刻）。
+*
+* 未登记（不是本包的控制器，比如内置 preset 挂的官方服务）、已卸载、或读法抛错
+* 时返回 undefined，由调用方自己退回投影。
+* @param session - 会话对象。
+* @returns true / false / undefined。
+*/
+function registeredPlanControllerActive(session) {
+	const key = objectKey(session);
+	if (key === void 0) return void 0;
+	const controller = exitReminderRegistry().controllers.get(key);
+	if (controller === void 0 || controller.isDisposed()) return void 0;
+	try {
+		const active = controller.selectedActive(session);
+		return typeof active === "boolean" ? active : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* 一个 agent 的提醒桶键：优先会话对象（同一会话换一个 agent 也还是同一桶），
+* 否则退回 agent 自己。
+* @param agent - 任意值。
+* @returns 桶键；两者都不是对象时 undefined。
+*/
+function reminderBucket(agent) {
+	const session = agent?.session;
+	return objectKey(session) ?? objectKey(agent);
+}
+/**
+* 取（或建）一个桶的提醒状态。
+* @param registry - 登记册。
+* @param bucket - 桶键。
+* @returns 状态（就地可变）。
+*/
+function reminderStateOf(registry, bucket) {
+	let state = registry.states.get(bucket);
+	if (state === void 0) {
+		state = {
+			consecutive: 0,
+			pending: false
+		};
+		registry.states.set(bucket, state);
+	}
+	return state;
+}
+/**
+* 读宿主的 Agent 登记表，两条路线都试（`ctx.get('agents')` 与结构化属性）。
+* @param ctx - 宿主上下文。
+* @returns 登记表；读不到时 undefined。
+*/
+function agentRegistryOf(ctx) {
+	const viaGetter = serviceOf(ctx, "agents");
+	if (typeof viaGetter?.get === "function") return viaGetter;
+	let direct;
+	try {
+		direct = ctx?.agents;
+	} catch {
+		return;
+	}
+	return typeof direct?.get === "function" ? direct : void 0;
+}
+/**
+* 这个块是不是一段可见文本。
+*
+* 空白一律 trim：只有空白的文本等于没说话，那种回合归 `no-answer-resume` 管，不该
+* 在这里被当成「讲完了话」。
+* @param chunk - 候选块。
+* @returns 是可见文本时为 true。
+*/
+function isVisibleTextChunk(chunk) {
+	return chunk?.type === "text-delta" && typeof chunk.text === "string" && chunk.text.trim() !== "";
+}
+/**
+* 这个块是不是工具调用的开始。
+* @param chunk - 候选块。
+* @returns 是工具调用时为 true。
+*/
+function isToolCallChunk(chunk) {
+	if (chunk?.type === "tool-call-delta") return true;
+	return chunk?.type === "block-start" && chunk.blockType === "tool-call";
+}
+/**
+* 这个块是不是「模型自己讲完了」的终结块。
+* @param chunk - 候选块。
+* @returns `finish` 且原因为 `stop` 时为 true。
+*/
+function isStopFinish(chunk) {
+	return chunk?.type === "finish" && chunk.reason?.kind === "stop";
+}
+/**
+* 把一条订阅句柄解掉（cordis 两代形状：函数或带 dispose 的对象）。
+* @param handle - `subscribe` 的返回值。
+*/
+function releaseSubscription(handle) {
+	if (typeof handle === "function") {
+		handle();
+		return;
+	}
+	const disposable = handle;
+	try {
+		disposable?.dispose?.();
+	} catch {}
+}
+/**
+* 装一台「计划模式回合结束提醒」。
+*
+* ## 它解决什么
+*
+* 计划模式里模型讲完一段话就收尾（`finish: stop`、零工具调用）时，宿主不会替它做
+* 任何事：那一回合就停在那里，直到人去催「确认呢」。这里在 `llm/stream` 上观察一
+* 次已完成、只有文本、没有工具调用的对话请求，然后在 agent 空闲之后补一条尾部通知，
+* 让模型自己选三条出路（`exit_plan_mode` / `ask_user_question` / `leave_plan_mode`）。
+*
+* ## 为什么零缓存漂移
+*
+* 一条 `agent.steer(createPlanNotice(...))` 的尾部用户消息：不注册 system 段、不动
+* `tools.definitions`、不改任何工具 schema。末尾追加不破坏已发前缀。
+*
+* ## 为什么不会重复提醒
+*
+* 同一进程里两个挂载点共享 {@link PlanModeExitReminderRegistry}：`claimed` 让一条
+* `llm/stream` 只被一条监听器接手（另一条原样透传），`states` 让两处读同一个计数。
+*
+* @param ctx - 宿主上下文（结构化：老代 ctx 也认）。
+* @param options - 见 {@link PlanModeExitReminderOptions}。
+* @returns 摘掉全部订阅的 disposer；这一代没有事件总线、或一条都没订上时 undefined。
+*/
+function installPlanModeExitReminder(ctx, options = {}) {
+	if (typeof ctx?.on !== "function") return void 0;
+	const registry = exitReminderRegistry();
+	let closed = false;
+	/**
+	* 读「此刻还在计划模式吗」。读法抛错等于读不出来。
+	* @param agent - 调用方 agent。
+	* @returns true / false / undefined。
+	*/
+	const activeOf = (agent) => {
+		if (typeof options.isActive !== "function") return void 0;
+		try {
+			return options.isActive(agent);
+		} catch {
+			return;
+		}
+	};
+	/**
+	* 用会话 id 反查活着的 agent。每次现读：这个插件可能比 agents 服务先加载。
+	* @param sessionId - 请求上的会话 id。
+	* @returns agent；读不到时 undefined。
+	*/
+	const resolveAgent = (sessionId) => {
+		if (typeof sessionId !== "string") return void 0;
+		let resolved;
+		try {
+			resolved = agentRegistryOf(ctx)?.get(sessionId);
+		} catch {
+			return;
+		}
+		return objectKey(resolved) === void 0 ? void 0 : resolved;
+	};
+	/**
+	* 空闲之后真正投递。排队期间插件可能已经卸载、会话可能已经关掉、计划模式可能
+	* 已经退出、子代理可能还在跑 —— 这些都要在**投递那一刻**重新判断。
+	* @param state - 本会话的提醒状态。
+	* @param agent - 调用方 agent。
+	*/
+	const fire = (state, agent) => {
+		state.pending = false;
+		if (closed) return;
+		if (isDelegatedCaller(agent, ctx)) return;
+		const active = activeOf(agent);
+		if (active !== true) {
+			if (active === false) state.consecutive = 0;
+			return;
+		}
+		if (hasRunningChildSubagent(agent, ctx)) {
+			state.consecutive = 0;
+			return;
+		}
+		if (state.consecutive >= 1) return;
+		state.consecutive += 1;
+		const message = createPlanNotice(PLAN_EXIT_REMINDER_TEXT, void 0, "Plan mode exit reminder");
+		try {
+			if (typeof agent.steer === "function") agent.steer(message);
+			else if (typeof agent.inject === "function") agent.inject(message);
+		} catch (error) {
+			log(ctx, "warn", "[dsh-chatgpt-subscription] could not queue the plan-mode exit reminder: " + (error instanceof Error ? error.message : String(error)));
+		}
+	};
+	/**
+	* 等 agent 空闲，再投递。
+	*
+	* `whenIdle` 是整件事的前提：回合还在跑的时候 `steer` 只会被塞进收件箱而没有
+	* 唤醒跟着，那条消息永远不会被读到。这一代没有 `whenIdle` 时退成微任务，投递
+	* 仍会发生，只是取件时机由宿主决定。
+	* @param state - 本会话的提醒状态。
+	* @param agent - 调用方 agent。
+	*/
+	const queue = (state, agent) => {
+		const whenIdle = agent.whenIdle;
+		let idle;
+		if (typeof whenIdle === "function") try {
+			idle = whenIdle.call(agent);
+		} catch {
+			idle = void 0;
+		}
+		if (idle === void 0 || idle === null) {
+			queueMicrotask(() => fire(state, agent));
+			return;
+		}
+		Promise.resolve(idle).then(() => fire(state, agent), () => fire(state, agent));
+	};
+	/**
+	* 一次已完成的对话流落定之后做什么。
+	* @param request - `llm/stream` 的请求对象。
+	* @param observed - 这次流里观察到的事实。
+	*/
+	const settleTurn = (request, observed) => {
+		const call = request;
+		const agent = resolveAgent(call?.sessionId);
+		const bucket = reminderBucket(agent);
+		if (observed.toolCall) {
+			if (bucket !== void 0) reminderStateOf(registry, bucket).consecutive = 0;
+			return;
+		}
+		if (call?.purpose !== void 0) return;
+		if (!observed.visibleText || !observed.stopped) return;
+		if (agent === void 0 || bucket === void 0) return;
+		if (typeof agent.steer !== "function" && typeof agent.inject !== "function") return;
+		if (closed) return;
+		const state = reminderStateOf(registry, bucket);
+		if (state.pending || state.consecutive >= 1) return;
+		if (activeOf(agent) === false) {
+			state.consecutive = 0;
+			return;
+		}
+		state.pending = true;
+		queue(state, agent);
+	};
+	/**
+	* 包住下游流：原样透传每个块，只记下判定需要的三件事。
+	*
+	* `finally` 在每条退出路径上都会跑，而其中两条什么都没证明：消费者中途放弃
+	* （用户按了停止），或下游抛错。两者都没有交付终结块，所以都不落定。
+	* @param request - `llm/stream` 的请求对象。
+	* @param next - 下一棒。
+	* @returns 透传流。
+	*/
+	const watch = (request, next) => {
+		return (async function* () {
+			let visibleText = false;
+			let toolCall = false;
+			let stopped = false;
+			let completed = false;
+			try {
+				for await (const chunk of next()) {
+					const seen = chunk;
+					if (isVisibleTextChunk(seen)) visibleText = true;
+					else if (isToolCallChunk(seen)) toolCall = true;
+					else if (isStopFinish(seen)) stopped = true;
+					yield chunk;
+				}
+				completed = true;
+			} finally {
+				if (completed) settleTurn(request, {
+					visibleText,
+					toolCall,
+					stopped
+				});
+			}
+		})();
+	};
+	/**
+	* `llm/stream` 的监听器：接手一条流，或原样透传。
+	* @param request - 请求对象。
+	* @param next - 下一棒。
+	* @returns 流。
+	*/
+	const onStream = (request, next) => {
+		const claim = objectKey(request);
+		if (claim !== void 0) {
+			if (registry.claimed.has(claim)) return next();
+			registry.claimed.add(claim);
+		}
+		return watch(request, next);
+	};
+	/**
+	* 会话关掉时丢掉它的计数：连续收尾的账属于那个会话，不该活过它。
+	* @param payload - `agent/disposed` 的载荷。
+	*/
+	const onAgentDisposed = (payload) => {
+		const bucket = reminderBucket(payload?.agent);
+		if (bucket === void 0) return;
+		registry.states.delete(bucket);
+	};
+	const offStream = subscribe(ctx, "llm/stream", onStream, { global: true });
+	const offDisposed = subscribe(ctx, "agent/disposed", onAgentDisposed);
+	if (offStream === void 0 && offDisposed === void 0) return void 0;
+	return () => {
+		closed = true;
+		releaseSubscription(offStream);
+		releaseSubscription(offDisposed);
+	};
+}
+/**
+* 造一条计划模式尾部通知。
+*
+* 用 createUserMessage 而不是手写消息字面量：DSH 对每条被接纳的消息都校验 id 与
+* source，手写字面量会在第一次 steer 时同步抛错（见 SKILL 的陷阱清单）。
+* @param text - 通知正文；指引会接在它后面。
+* @param section - 计划模式指引正文，接在通知之后。
+* @returns 用户角色消息。
+*/
+function createPlanNotice(text, section, summary) {
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text: section === void 0 || section.trim() === "" ? text : text + "\n\n" + section
+		}],
+		source: {
+			kind: PLAN_NOTICE_SOURCE_KIND,
+			form: "notice",
+			summary: summary ?? text
+		}
+	});
+}
+//#endregion
+export { planProjectionDefinition as _, PLAN_EXIT_REMINDER_TEXT as a, installDispatchExecutionGuard as b, PLAN_POLICY_SECTION as c, PlanModeController as d, REVIEW_ID as f, name as g, installPlanModeExitReminder as h, LEGACY_PLAN_STATE_VERSION as i, PLAN_PROJECTION_KEY as l, createPlanProjectionDefinition as m, EXIT_PLAN_MODE as n, PLAN_MODE_EVENT as o, createPlanNotice as p, KEEP_PLANNING_LABEL as r, PLAN_NOTICE_SOURCE_KIND as s, APPROVE_LABEL as t, PLAN_STATE_VERSION as u, registeredPlanControllerActive as v, resolveDispatchExecutionGuardEnabled as x, resolveConfig as y };