dsh-agent-toolkit 0.2.7 → 0.2.9

package/lib/index.js

@@ -5,14 +5,15 @@ import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import yaml from "js-yaml";
 import { expandHomePath, resolveDshHome } from "@deepseek-ai/dsh-home-paths";
-import { defineTool } from "@deepseek-ai/dsh-tools";
+import { RUN_CODE_NAME, defineTool } from "@deepseek-ai/dsh-tools";
+import { bindScopeParent, createScope, scopeOf } from "@deepseek-ai/dsh-scope";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { existsSync } from "node:fs";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import * as lark from "@larksuiteoapi/node-sdk";
 import { randomBytes, randomUUID } from "node:crypto";
-import { bindScopeParent, createScope, scopeOf } from "@deepseek-ai/dsh-scope";
+import { Cron } from "croner";
 import { setupUsage } from "@dsh-agent-toolkit/token-usage";
 //#region src/agents/store.ts
 /** agents 注册表存储域声明：记录 schema + domain 布局的单一来源。 */
@@ -34,7 +35,8 @@ const AgentRecordSchema = z$1.object({
 		model: z$1.string()
 	}).optional(),
 	tools: z$1.object({ allow: z$1.array(z$1.string()).min(1) }).optional(),
-	builtin: z$1.boolean().optional()
+	builtin: z$1.boolean().optional(),
+	visibleInTeam: z$1.boolean().optional()
 });
 /** domain 名/表名受 UNIT_NAME_RE 约束（^[a-z][a-z0-9_]*$），不允许连字符。 */
 const agentToolkitDomain = defineDomain({
@@ -60,12 +62,16 @@ function migrateAgentRecord(record) {
 		persona
 	} : rest;
 }
+/** 团队可见性判定：缺省（undefined）与 true 均可见；仅显式 false 隐藏。 */
+function isTeamVisible(role) {
+	return role.visibleInTeam !== false;
+}
 //#endregion
 //#region src/channels/basic-tools.ts
 const BASIC_TOOLS = [
 	{
 		id: "@deepseek-ai/dsh-persona",
-		config: { text: "You are a coding agent powered by the {{model}} model. Your working directory is {{cwd}}." }
+		config: { text: "You are a coding agent powered by the {{model}} model. Your working directory is {{cwd}}. If you need information or a decision from the user, ask directly in your reply and wait for their next message." }
 	},
 	{
 		id: "@deepseek-ai/dsh-agent-instructions",
@@ -78,10 +84,10 @@ const BASIC_TOOLS = [
 		config: { sampleOverCapGlobResults: false }
 	}
 ];
-/** 原生工具名（白名单 UI 与存量迁移用）：与 BASIC_TOOLS 挂载插件注册的工具名一一对应。
-*  名字来源（摘自 deepseek-harness 源码）：dsh-tool-pwsh/dsh-tool-bash → 'pwsh'/'bash'（平台互斥）；
-*  dsh-tool-fs → 'read'/'write'/'edit'/'read_image'；dsh-tool-fs-search → 'glob'/'grep'。
-*  这些工具 scoped 挂载在 agentCtx，不出现在顶层 ctx.tools.schemas()，故需显式常量。 */
+/** 内置工具名常量（兜底名单）：agentPresets 缺席或 standing 枚举失败时，Agents 面板名册
+*  与存量迁移回退到这份常量。语义已降级为"兜底"，不再承诺是完整原生工具面——完整面 =
+*  团队 preset 动态枚举（agents/tool-catalog.ts）。explorer 只读白名单仍从本常量派生
+*  （刻意的最小集，不追求完整）。 */
 const NATIVE_TOOL_NAMES = [
 	process.platform === "win32" ? "pwsh" : "bash",
 	"read",
@@ -93,10 +99,50 @@ const NATIVE_TOOL_NAMES = [
 ];
 //#endregion
 //#region src/agents/builtin.ts
-/** 内置保底 Agent 记录：main + explorer（只读白名单）/ general（不限制）。 */
-/** explorer 默认白名单：原生工具去掉写类（write/edit）。shell 名平台互斥（win32=pwsh、其余=bash），
-*  必须从 NATIVE_TOOL_NAMES 派生不可写死——宿主 tools.restrict 对未知名响亮失败。 */
-const EXPLORER_READONLY_ALLOW = NATIVE_TOOL_NAMES.filter((n) => n !== "write" && n !== "edit");
+/** 内置保底 Agent 记录：main + explorer（只读白名单 10 个）/ general（preset 面全量 20 个、禁二级委派）。 */
+const SHELL_NAME = process.platform === "win32" ? "pwsh" : "bash";
+/** 旧版 explorer 默认白名单（5 个）：存量条件式迁移的等值比对基准。
+*  独立于 EXPLORER_READONLY_ALLOW 保留旧派生式——比对基准不可随新名单漂移。
+*  shell 名平台互斥（win32=pwsh、其余=bash），必须从 NATIVE_TOOL_NAMES 派生不可写死。 */
+const LEGACY_EXPLORER_ALLOW = NATIVE_TOOL_NAMES.filter((n) => n !== "write" && n !== "edit");
+/** explorer 默认白名单（10 个）：只读基础五件（shell/read/read_image/glob/grep，旧派生不变）
+*  + preset 面只读安全五件（web_search/todo_write/job_list/job_output/skill——skill 加载的是
+*  指令文本，本身只读，用户决策默认可用）。
+*  编排类（ralph/workflow）、写文件类（write/edit）、job_kill、ask_user_question、
+*  goal 三件套、exit_plan_mode 不进只读名单。 */
+const EXPLORER_READONLY_ALLOW = [
+	...LEGACY_EXPLORER_ALLOW,
+	"web_search",
+	"todo_write",
+	"job_list",
+	"job_output",
+	"skill"
+];
+/** general 默认白名单（20 个）：agent-team preset standing 面全量（2026-09-08 实测枚举），
+*  不含 team_delegate（禁二级委派）与 run_code（宿主 Code Mode 保留名，restrict 拒收）。
+*  静态名单：preset 面日后新增工具不自动进入，需人工再梳理（见 spec 非目标）。 */
+const GENERAL_ALLOW = [
+	SHELL_NAME,
+	"read",
+	"write",
+	"edit",
+	"read_image",
+	"glob",
+	"grep",
+	"todo_write",
+	"web_search",
+	"ask_user_question",
+	"skill",
+	"exit_plan_mode",
+	"job_list",
+	"job_output",
+	"job_kill",
+	"create_goal",
+	"get_goal",
+	"update_goal",
+	"ralph",
+	"workflow"
+];
 const BUILTIN_AGENTS = [
 	{
 		id: "main",
@@ -120,7 +166,8 @@ const BUILTIN_AGENTS = [
 		persona: `你是通用执行员。按任务书独立完成多步骤工作，可以读写文件、运行命令。
 动手前先阅读相关 AGENTS.md 并遵循项目约定；完成后运行与改动相关的检查
 （测试/类型检查）验证改动，并在最终输出中报告验证结果。`,
-		builtin: true
+		builtin: true,
+		tools: { allow: [...GENERAL_ALLOW] }
 	}
 ];
 //#endregion
@@ -237,11 +284,15 @@ async function markImported(ctx) {
 const TOOLS_NATIVE_MIGRATED_KEY = "tools_native_migrated";
 /** explorer 只读白名单一次性并入的 meta 表标记键。 */
 const EXPLORER_READONLY_MIGRATED_KEY = "explorer_readonly_migrated";
+/** tools.allow 一次性并入「preset 面 − 原生常量」差集的 meta 表标记键。 */
+const TOOLS_PRESET_MIGRATED_KEY = "tools_preset_catalog_migrated";
+/** 内置角色工具名单重选（explorer 5→10 / general 无→20）一次性迁移的 meta 表标记键。 */
+const BUILTIN_TOOLS_RECATALOG_MIGRATED_KEY = "builtin_tools_recatalog_migrated";
 /**
-* 打开 dsh_agent_toolkit 域 → 首启 YAML 导入 → 旧记录迁移（promptLayers/原生并入/explorer 只读）→
+* 打开 dsh_agent_toolkit 域 → 首启 YAML 导入 → 旧记录迁移（promptLayers/原生并入/preset 差集并入/explorer 只读/内置名单重选）→
 * 缺 main/explorer/general 时种入内置 → 构建内存缓存。域由 apply 统一 open（storage-domain 同名单开），此处只消费表句柄。
 */
-async function createRegistry(warn, tables) {
+async function createRegistry(warn, tables, listPresetTools) {
 	const { agents, meta } = tables;
 	await importRolesYaml({
 		agents,
@@ -262,6 +313,25 @@ async function createRegistry(warn, tables) {
 		if (next !== record) await agents.put(id, next);
 	}
 	if (!nativeMigrated) await meta.put(TOOLS_NATIVE_MIGRATED_KEY, { value: "1" });
+	if (meta.get("tools_preset_catalog_migrated") === void 0 && listPresetTools !== void 0) {
+		let extra;
+		try {
+			extra = (await listPresetTools()).filter((n) => !NATIVE_TOOL_NAMES.includes(n));
+		} catch {
+			extra = void 0;
+		}
+		if (extra !== void 0 && extra.length > 0) {
+			for (const [id, record] of agents.entries()) {
+				if (record.builtin === true || record.tools === void 0) continue;
+				const missing = extra.filter((n) => !record.tools.allow.includes(n));
+				if (missing.length > 0) await agents.put(id, {
+					...record,
+					tools: { allow: [...record.tools.allow, ...missing] }
+				});
+			}
+			await meta.put(TOOLS_PRESET_MIGRATED_KEY, { value: "1" });
+		}
+	}
 	if (!(meta.get("explorer_readonly_migrated") !== void 0)) {
 		const explorer = agents.get("explorer");
 		if (explorer !== void 0 && explorer.tools === void 0) await agents.put("explorer", {
@@ -270,6 +340,24 @@ async function createRegistry(warn, tables) {
 		});
 		await meta.put(EXPLORER_READONLY_MIGRATED_KEY, { value: "1" });
 	}
+	if (meta.get("builtin_tools_recatalog_migrated") === void 0) {
+		const explorer = agents.get("explorer");
+		const legacyShapes = [LEGACY_EXPLORER_ALLOW, [
+			...LEGACY_EXPLORER_ALLOW,
+			"write",
+			"edit"
+		]];
+		if (explorer?.builtin === true && explorer.tools !== void 0 && legacyShapes.some((shape) => explorer.tools.allow.length === shape.length && explorer.tools.allow.every((n, i) => n === shape[i]))) await agents.put("explorer", {
+			...explorer,
+			tools: { allow: [...EXPLORER_READONLY_ALLOW] }
+		});
+		const general = agents.get("general");
+		if (general?.builtin === true && general.tools === void 0) await agents.put("general", {
+			...general,
+			tools: { allow: [...GENERAL_ALLOW] }
+		});
+		await meta.put(BUILTIN_TOOLS_RECATALOG_MIGRATED_KEY, { value: "1" });
+	}
 	await seedBuiltins(agents);
 	const cache = /* @__PURE__ */ new Map();
 	for (const [id, record] of agents.entries()) cache.set(id, record);
@@ -319,6 +407,27 @@ async function seedBuiltins(agents) {
 	for (const builtin of BUILTIN_AGENTS) if (agents.get(builtin.id) === void 0) await agents.put(builtin.id, builtin);
 }
 //#endregion
+//#region src/agents/tool-catalog.ts
+function createToolCatalog(ctx, presetId) {
+	return {
+		async listPresetTools() {
+			const presets = ctx.get("agentPresets", false);
+			if (presets === void 0) return [...NATIVE_TOOL_NAMES];
+			try {
+				const key = await presets.standingKeyFor(presetId);
+				const global = new Set(ctx.tools.schemas().map((s) => s.name));
+				return ctx.tools.schemas(key).map((s) => s.name).filter((n) => !global.has(n) && n !== RUN_CODE_NAME).sort();
+			} catch (error) {
+				ctx.logger.warn(`dsh-agent-toolkit: 枚举 preset "${presetId}" 工具面失败，回退内置常量：${error instanceof Error ? error.message : String(error)}`);
+				return [...NATIVE_TOOL_NAMES];
+			}
+		},
+		listGlobalTools() {
+			return ctx.tools.schemas().map((s) => s.name).filter((n) => n !== RUN_CODE_NAME);
+		}
+	};
+}
+//#endregion
 //#region src/shared/storage.ts
 function openDomainSafely(ctx, domain, warn, beforeClose) {
 	const ready = ctx.storageDomain.open(domain);
@@ -1313,10 +1422,19 @@ function createDelegateTool(toolName, deps) {
 		async execute(args, exec) {
 			const parent = exec.agent;
 			if (!parent) throw new Error("team_delegate 需要调用方 agent（exec.agent 为空）");
-			const roster = deps.roster().filter((r) => r.id !== "main");
+			const roster = deps.roster().filter((r) => r.id !== "main" && isTeamVisible(r));
 			const role = roster.find((r) => r.id === args.role);
 			if (!role) throw new Error(`未知角色 "${args.role}"。可用角色：${roster.map((r) => r.id).join(", ")}`);
 			const persona = deps.buildPersona(role);
+			let toolFilter;
+			if (role.tools !== void 0) {
+				const visible = new Set(deps.visibleSurface(parent).filter((n) => n !== RUN_CODE_NAME));
+				const effective = role.tools.allow.filter((n) => visible.has(n));
+				const dropped = role.tools.allow.filter((n) => !visible.has(n));
+				if (dropped.length > 0) deps.warn(`dsh-agent-toolkit: 角色 ${role.id} 白名单含本会话不可见工具，委派时忽略：${dropped.join(", ")}`);
+				if (effective.length === 0) throw new Error(`dsh-agent-toolkit: 角色 ${role.id} 工具白名单求交后为空（原 ${role.tools.allow.length} 个均不可见）：${role.tools.allow.join(", ")}`);
+				toolFilter = { allow: effective };
+			}
 			const request = {
 				label: `role:${role.id}: ${args.description}`,
 				prompt: [{
@@ -1331,7 +1449,7 @@ function createDelegateTool(toolName, deps) {
 					provider: role.model.provider,
 					model: role.model.model
 				} } : {},
-				...role.tools !== void 0 ? { toolFilter: { allow: [...role.tools.allow] } } : {}
+				...toolFilter !== void 0 ? { toolFilter } : {}
 			};
 			const route = (role.model !== void 0 && role.model.provider !== "" && role.model.model !== "" ? role.model : void 0) ?? (typeof parent.options.provider === "string" && parent.options.provider !== "" && typeof parent.options.model === "string" && parent.options.model !== "" ? {
 				provider: parent.options.provider,
@@ -1360,7 +1478,7 @@ const TEAM_SECTION_ORDER = 116.6;
 */
 function teamSectionText(toolName, roles, toolVisible) {
 	if (!toolVisible) return "";
-	return `你有一组可委派的成员：用 ${toolName} 把自包含的子任务委派给合适的成员，成员结果会作为工具返回值回到本对话。\n可用成员：\n${roles.filter((r) => r.id !== "main").map((r) => `${r.id}: ${r.description ?? r.name}`).join("\n")}`;
+	return `你有一组可委派的成员：用 ${toolName} 把自包含的子任务委派给合适的成员，成员结果会作为工具返回值回到本对话。\n可用成员：\n${roles.filter((r) => r.id !== "main" && isTeamVisible(r)).map((r) => `${r.id}: ${r.description ?? r.name}`).join("\n")}`;
 }
 /**
 * 挂载 team_delegate 工具与函数式团队提示段。
@@ -1383,7 +1501,11 @@ function setupDelegate(ctx, config, registry, channels) {
 			buildPersona: (role) => buildAgentPersona({ rules: config.rules }, role, role.model),
 			startRun: (pr, request) => ctx.subagents.start(pr, request),
 			active: channels.active,
-			recordRoute: channels.recordRoute
+			recordRoute: channels.recordRoute,
+			visibleSurface: (agent) => agent.ctx.tools.schemas(scopeOf(agent.ctx)).map((s) => s.name),
+			warn: (msg) => {
+				ctx.logger.warn(msg);
+			}
 		}));
 	};
 	ctx.on("subagent/provider-added", (p) => {
@@ -1504,7 +1626,7 @@ function createAgentsApiHandler(deps) {
 		}
 		if (sub === "/tools" && method === "GET") {
 			json$1(res, 200, {
-				native: [...NATIVE_TOOL_NAMES],
+				preset: await deps.listPresetTools(),
 				global: deps.listTools()
 			});
 			return;
@@ -1631,7 +1753,7 @@ function buildCreateAgentGuidance(input) {
 		"3. 迭代：用户有修改意见时按意见修订名称、描述、个性和工具后再次确认，直到用户明确确认。"
 	];
 	if (input.requirement !== "") lines.push("", "## 用户初始需求", `用户已在命令中提供初始需求：「${input.requirement}」。请据此减少提问轮次，仅就不明确的点提问。`);
-	lines.push("", "## 现有 Agent id（不可复用）", input.agentIds.join(", "), "id 规则：小写字母开头，仅含小写字母/数字/连字符（[a-z0-9-]），最长 32 字符。", "", "## 可用工具清单", `原生工具：${NATIVE_TOOL_NAMES.join(", ")}`, `全局工具：${input.globalTools.join(", ")}`, "省略 tools 字段表示不限制（Agent 可使用全部工具）。一旦给出白名单，该 Agent 只有列出的工具可用：通常应保留原生工具，否则失去读文件/搜索/执行命令等基本能力（最终取舍按需求判断，如只读角色可去掉 write/edit）。");
+	lines.push("", "## 现有 Agent id（不可复用）", input.agentIds.join(", "), "id 规则：小写字母开头，仅含小写字母/数字/连字符（[a-z0-9-]），最长 32 字符。", "", "## 可用工具清单", `团队 preset 工具：${input.presetTools.join(", ")}`, `全局工具：${input.globalTools.join(", ")}`, "省略 tools 字段表示不限制（Agent 可使用全部工具）。一旦给出白名单，该 Agent 只有列出的工具可用：通常应保留 read/glob/grep/shell 等基础工具，否则失去读文件/搜索/执行命令等基本能力（最终取舍按需求判断，如只读角色可去掉 write/edit）。");
 	if (input.origin === void 0) lines.push("", "## 落库", "当前宿主无 web 服务，无法自动落库。用户确认推荐后，请把最终配置完整输出给用户，并提示其打开 Agents 面板按推荐内容手动创建。");
 	else lines.push("", "## 落库（用户明确确认后执行）", "用你的 shell 工具调用 Agents 面板同一 HTTP 端点完成创建：", `1. 先 GET ${input.origin}/dsh-agent-toolkit/api/agents 复核所选 id 仍未被占用；`, `2. 再 PUT ${input.origin}/dsh-agent-toolkit/api/agents/<id>，请求体为 JSON（不要在 body 中携带 id 或 builtin 字段）：`, "   {\"name\":\"...\",\"description\":\"...\",\"persona\":\"...\",\"tools\":{\"allow\":[\"...\"]}}", "   （description/persona/tools 均可省略；省略 tools 表示不限制）", "3. curl 示例（Windows 的 pwsh 里用 curl.exe）：", `   curl.exe -s -X PUT "${input.origin}/dsh-agent-toolkit/api/agents/<id>" -H "Content-Type: application/json" -d "{\\"name\\":\\"...\\"}"`, `4. 返回 200 后必须再 GET ${input.origin}/dsh-agent-toolkit/api/agents，在返回列表中找到该 id 的记录，把它的 name/description/persona/tools 关键字段展示给用户，作为落库证据；`, "5. 落库成功后告知用户可在 Agents 面板查看、并可被 team_delegate 委派；任一步返回 4xx 则把错误信息展示给用户，修正后重试。");
 	return lines.join("\n");
@@ -1648,12 +1770,13 @@ function setupCreateAgentCommand(ctx, deps) {
 		name: "create-agent",
 		description: "交互式创建 Agent 团队成员：访谈澄清需求 → 推荐配置 → 确认后经面板 API 落库",
 		input: { hint: "初始需求描述，可空" },
-		handler: ({ rawInput, agent }) => {
+		handler: async ({ rawInput, agent }) => {
 			const webServer = ctx.get("webServer");
 			const origin = webServer === void 0 ? void 0 : `http://127.0.0.1:${webServer.port}`;
 			const text = buildCreateAgentGuidance({
 				requirement: rawInput.trim(),
 				agentIds: deps.registry.list().map((agent) => agent.id),
+				presetTools: await deps.listPresetTools(),
 				globalTools: deps.listTools(),
 				origin
 			});
@@ -1682,8 +1805,8 @@ const TOOLKIT_PERSONA_SECTION = "prompt-stack:persona";
 * （global + 祖先 scope 层），own 层（agentCtx 直接挂载）的名字既不可 restrict 也
 * 不受 restrict 影响，直接挂进 agentCtx 的白名单会抛 unknown global tools。
 */
-async function setupAgentScope(agentCtx, hooks, toolsScope) {
-	await toolsScope.join(agentCtx);
+async function setupAgentScope(agentCtx, hooks, joiner) {
+	await joiner.join(agentCtx);
 	if (hooks.persona !== void 0) agentCtx.systemPrompt.section({
 		name: TOOLKIT_PERSONA_SECTION,
 		order: 10,
@@ -1694,10 +1817,56 @@ async function setupAgentScope(agentCtx, hooks, toolsScope) {
 		order: section.order,
 		text: section.text
 	});
-	if (hooks.tools !== void 0) agentCtx.tools.restrict({ allow: hooks.tools });
+	if (hooks.tools !== void 0) {
+		const visible = new Set(agentCtx.tools.schemas(scopeOf(agentCtx)).map((s) => s.name).filter((n) => n !== RUN_CODE_NAME));
+		const effective = hooks.tools.filter((n) => visible.has(n));
+		const dropped = hooks.tools.filter((n) => !visible.has(n));
+		if (dropped.length > 0) agentCtx.logger.warn(`dsh-agent-toolkit: 工具白名单含本会话不可见工具，已忽略：${dropped.join(", ")}`);
+		if (effective.length === 0) throw new Error(`dsh-agent-toolkit: 工具白名单求交后为空（原 ${hooks.tools.length} 个均不可见）：${hooks.tools.join(", ")}`);
+		agentCtx.tools.restrict({ allow: effective });
+	}
+}
+//#endregion
+//#region src/channels/agents-port.ts
+function createAgentsPort(ctx, joiner, ownedSessions) {
+	function adaptAgent(handle) {
+		const { agent } = handle;
+		return {
+			sessionId: String(agent.id),
+			followup: (message) => agent.followup(message),
+			cancel: () => agent.cancel({ kind: "user" }),
+			whenIdle: () => agent.whenIdle()
+		};
+	}
+	return {
+		async create(input) {
+			ownedSessions?.add(input.sessionId);
+			return adaptAgent(await ctx.agents.create({
+				sessionId: SessionId(input.sessionId),
+				meta: { cwd: input.cwd },
+				...input.agentOptions !== void 0 ? { agentOptions: input.agentOptions } : {},
+				setup: (agentCtx) => setupAgentScope(agentCtx, input.hooks, joiner)
+			}));
+		},
+		async resume(input) {
+			ownedSessions?.add(input.sessionId);
+			return adaptAgent(await ctx.agents.resume({
+				resumeSessionId: SessionId(input.sessionId),
+				...input.agentOptions !== void 0 ? { agentOptions: input.agentOptions } : {},
+				setup: (agentCtx) => setupAgentScope(agentCtx, input.hooks, joiner)
+			}));
+		}
+	};
 }
 //#endregion
 //#region src/channels/feishu/api.ts
+/** 从 lark SDK 抛出的 axios 错误提取飞书业务错误码（无则 undefined）。 */
+function feishuErrorCode(error) {
+	const data = error?.response?.data;
+	if (typeof data !== "object" || data === null) return void 0;
+	const code = data.code;
+	return typeof code === "number" ? code : void 0;
+}
 /** 附件服务接受的图片媒体类型（与宿主 attachment v1 一致）。 */
 const IMAGE_MEDIA_TYPES = [
 	"image/png",
@@ -1835,6 +2004,15 @@ function createFeishuApi(client) {
 				data,
 				mediaType
 			};
+		},
+		async getBotOpenId() {
+			const res = await client.request({
+				method: "GET",
+				url: "https://open.feishu.cn/open-apis/bot/v3/info"
+			});
+			const openId = res.bot?.open_id;
+			if (typeof openId !== "string" || openId.length === 0) throw new Error(`获取机器人信息失败：code=${res.code} msg=${res.msg}`);
+			return openId;
 		}
 	};
 }
@@ -1888,8 +2066,10 @@ function parsePostContent(content) {
 * SDK handler 收到的 data 即事件体（README 示例 `data.message` 直接解构）；
 * 兼容包一层 { event } 的形态。过滤：机器人消息、非 text/post/image 类型、
 * 群内未 @机器人、无文本且无图片。
+* 群消息 @ 校验身份：mention 的 open_id 必须等于本机器人（应用若持全部群消息权限，
+* 会收到 @ 其他机器人的消息，不能误触发）。
 */
-function parseMessageEvent(data) {
+function parseMessageEvent(data, botOpenId) {
 	const wrapped = data;
 	const event = wrapped.event ?? wrapped;
 	if (event.sender?.sender_type !== "user") return null;
@@ -1900,7 +2080,7 @@ function parseMessageEvent(data) {
 	if (typeof msg.content !== "string") return null;
 	if (typeof msg.message_id !== "string" || typeof msg.chat_id !== "string") return null;
 	if (msg.chat_type !== "p2p" && msg.chat_type !== "group") return null;
-	if (msg.chat_type === "group" && !(msg.mentions ?? []).some((m) => m.mentioned_type === "bot")) return null;
+	if (msg.chat_type === "group" && !(msg.mentions ?? []).some((m) => m.mentioned_type === "bot" && m.id?.open_id === botOpenId)) return null;
 	let text = "";
 	let imageKeys = [];
 	if (msg.message_type === "text") try {
@@ -1962,27 +2142,10 @@ const STATUS_FINAL = {
 	error: "❌ 输出出错",
 	cancelled: "⏹ 已取消"
 };
-/** 新卡固定开销字节数（状态行 + 结构，粗算进预算）。 */
-const CARD_FIXED_BYTES = 64;
+/** 拆卡定格状态行文案（旧卡内容已接续到下一张卡片）。 */
+const STATUS_CONTINUED = "📦 内容较长，已接续到下一张卡片";
 /** 单卡组件数安全上限（飞书硬上限 200；面板按 2 计：面板 + 内嵌 markdown）。 */
 const CARD_ELEMENT_LIMIT = 190;
-/** 按 UTF-8 字节上限截头（保留头部），不劈开多字节字符与代理对。 */
-function sliceByBytes(text, maxBytes) {
-	if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
-	let lo = 0;
-	let hi = text.length;
-	while (lo < hi) {
-		const mid = Math.ceil((lo + hi) / 2);
-		if (Buffer.byteLength(text.slice(0, mid), "utf8") <= maxBytes) lo = mid;
-		else hi = mid - 1;
-	}
-	let cut = lo;
-	if (cut > 0) {
-		const code = text.charCodeAt(cut - 1);
-		if (code >= 55296 && code <= 56319) cut -= 1;
-	}
-	return text.slice(0, cut);
-}
 /** 按 UTF-8 字节上限截尾（保留尾部），不劈开多字节字符与代理对；截断时头部加省略标记。 */
 function sliceTailByBytes(text, maxBytes) {
 	if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
@@ -2002,8 +2165,29 @@ function sliceTailByBytes(text, maxBytes) {
 	}
 	return PROCESS_OMITTED + text.slice(cut);
 }
+/** JSON 串内内容的转义后字节数（去首尾引号）；卡片 DSL 真实字节记账用。 */
+function escapedLen(s) {
+	return Buffer.byteLength(JSON.stringify(s), "utf8") - 2;
+}
+/** 按转义后字节上限截头（保留头部），不劈开多字节字符与代理对。 */
+function sliceByEscapedBytes(text, maxBytes) {
+	if (escapedLen(text) <= maxBytes) return text;
+	let lo = 0;
+	let hi = text.length;
+	while (lo < hi) {
+		const mid = Math.ceil((lo + hi) / 2);
+		if (escapedLen(text.slice(0, mid)) <= maxBytes) lo = mid;
+		else hi = mid - 1;
+	}
+	let cut = lo;
+	if (cut > 0) {
+		const code = text.charCodeAt(cut - 1);
+		if (code >= 55296 && code <= 56319) cut -= 1;
+	}
+	return text.slice(0, cut);
+}
 /** 新卡：仅状态行的流式卡；段后续经插入组件 API 动态加入。 */
-function buildCardJson() {
+function buildCardJson(printStep) {
 	return JSON.stringify({
 		schema: "2.0",
 		config: {
@@ -2011,7 +2195,7 @@ function buildCardJson() {
 			summary: { content: "生成中…" },
 			streaming_config: {
 				print_frequency_ms: { default: 70 },
-				print_step: { default: 1 },
+				print_step: { default: printStep },
 				print_strategy: "fast"
 			}
 		},
@@ -2054,30 +2238,56 @@ const initialStreamState = () => ({
 	carry: void 0
 });
 /** 把段序列的新增部分同步到卡片；新段 insert 到状态行之前，尾段增长走元素 update，满卡关流开续卡。 */
-function planSync(state, segments, maxBytes, processMaxBytes) {
+function planSync(state, segments, maxBytes, processMaxBytes, printStep) {
 	const ops = [];
 	let { cardId, seq, cardBytes, cardElements, segCounter, closedSegCount, tail, carry } = state;
-	const ensureCard = () => {
-		if (cardId !== null) return;
+	/** 约定：先改规划局部变量再 push——commit 捕获该 op 完成后的状态快照。 */
+	const push = (op) => {
+		const snap = {
+			cardId,
+			seq,
+			cardBytes,
+			cardElements,
+			segCounter,
+			closedSegCount,
+			tail,
+			carry
+		};
 		ops.push({
-			type: "create",
-			cardJson: buildCardJson()
+			op,
+			commit: () => ({ ...snap })
 		});
-		ops.push({ type: "send" });
+	};
+	const ensureCard = () => {
+		if (cardId !== null) return;
+		const cardJson = buildCardJson(printStep);
 		cardId = PENDING_CARD_ID;
 		seq = 0;
-		cardBytes = CARD_FIXED_BYTES;
+		cardBytes = Buffer.byteLength(cardJson, "utf8");
 		cardElements = 1;
+		push({
+			type: "create",
+			cardJson
+		});
+		push({ type: "send" });
 	};
 	const closeCard = () => {
 		seq += 1;
-		ops.push({
-			type: "settings",
-			streaming: false,
+		push({
+			type: "update",
+			elementId: STATUS_ELEMENT_ID,
+			content: STATUS_CONTINUED,
 			sequence: seq
 		});
+		seq += 1;
 		cardId = null;
 		tail = void 0;
+		push({
+			type: "settings",
+			streaming: false,
+			sequence: seq,
+			summary: STATUS_CONTINUED
+		});
 	};
 	let i = tail?.segIndex ?? closedSegCount;
 	while (i < segments.length) {
@@ -2087,35 +2297,35 @@ function planSync(state, segments, maxBytes, processMaxBytes) {
 		const elementContent = seg.kind === "text" ? content.slice(base) : content;
 		if (tail !== void 0 && tail.segIndex === i) {
 			if (elementContent !== tail.shownText) {
-				const delta = Buffer.byteLength(elementContent, "utf8") - Buffer.byteLength(tail.shownText, "utf8");
+				const delta = escapedLen(elementContent) - escapedLen(tail.shownText);
 				if (cardBytes + delta <= maxBytes) {
 					seq += 1;
-					ops.push({
-						type: "update",
-						elementId: tail.elementId,
-						content: elementContent,
-						sequence: seq
-					});
 					cardBytes += delta;
 					tail = {
 						...tail,
 						shownText: elementContent
 					};
+					push({
+						type: "update",
+						elementId: tail.elementId,
+						content: elementContent,
+						sequence: seq
+					});
 				} else if (seg.kind === "text") {
-					const piece = sliceByBytes(elementContent, Buffer.byteLength(tail.shownText, "utf8") + (maxBytes - cardBytes));
+					const piece = sliceByEscapedBytes(elementContent, escapedLen(tail.shownText) + (maxBytes - cardBytes));
 					if (piece.length > tail.shownText.length) {
 						seq += 1;
-						ops.push({
+						cardBytes += escapedLen(piece) - escapedLen(tail.shownText);
+						tail = {
+							...tail,
+							shownText: piece
+						};
+						push({
 							type: "update",
 							elementId: tail.elementId,
 							content: piece,
 							sequence: seq
 						});
-						cardBytes += Buffer.byteLength(piece, "utf8") - Buffer.byteLength(tail.shownText, "utf8");
-						tail = {
-							...tail,
-							shownText: piece
-						};
 					}
 					carry = {
 						segIndex: i,
@@ -2136,21 +2346,17 @@ function planSync(state, segments, maxBytes, processMaxBytes) {
 			continue;
 		}
 		if (seg.kind === "process") {
-			const windowBytes = Buffer.byteLength(elementContent, "utf8");
-			if (cardId !== null && (cardBytes + windowBytes > maxBytes || cardElements + 2 > CARD_ELEMENT_LIMIT)) {
+			const elementId = `seg_${segCounter + 1}`;
+			const elementJson = buildSegmentJson("process", elementId, elementContent);
+			const elBytes = Buffer.byteLength(elementJson, "utf8");
+			if (cardId !== null && (cardBytes + elBytes > maxBytes || cardElements + 2 > CARD_ELEMENT_LIMIT)) {
 				closeCard();
 				continue;
 			}
 			ensureCard();
 			segCounter += 1;
-			const elementId = `seg_${segCounter}`;
 			seq += 1;
-			ops.push({
-				type: "insert",
-				elementJson: buildSegmentJson("process", elementId, elementContent),
-				sequence: seq
-			});
-			cardBytes += windowBytes;
+			cardBytes += elBytes;
 			cardElements += 2;
 			tail = {
 				segIndex: i,
@@ -2158,6 +2364,11 @@ function planSync(state, segments, maxBytes, processMaxBytes) {
 				base: 0,
 				shownText: elementContent
 			};
+			push({
+				type: "insert",
+				elementJson,
+				sequence: seq
+			});
 		} else {
 			if (elementContent.length === 0) {
 				closedSegCount = i + 1;
@@ -2170,17 +2381,14 @@ function planSync(state, segments, maxBytes, processMaxBytes) {
 				continue;
 			}
 			ensureCard();
-			const piece = sliceByBytes(elementContent, maxBytes - cardBytes);
-			if (piece.length === 0) throw new Error(`cardMaxBytes=${maxBytes} 过小，扣固定开销后连一个字符都容纳不了`);
+			const elementId = `seg_${segCounter + 1}`;
+			const overhead = Buffer.byteLength(buildSegmentJson("text", elementId, ""), "utf8");
+			const piece = sliceByEscapedBytes(elementContent, maxBytes - cardBytes - overhead);
+			if (piece.length === 0) throw new Error(`cardMaxBytes=${maxBytes} 过小，扣基础卡与元素开销后连一个字符都容纳不了`);
 			segCounter += 1;
-			const elementId = `seg_${segCounter}`;
+			const elementJson = buildSegmentJson("text", elementId, piece);
 			seq += 1;
-			ops.push({
-				type: "insert",
-				elementJson: buildSegmentJson("text", elementId, piece),
-				sequence: seq
-			});
-			cardBytes += Buffer.byteLength(piece, "utf8");
+			cardBytes += Buffer.byteLength(elementJson, "utf8");
 			cardElements += 1;
 			tail = {
 				segIndex: i,
@@ -2188,6 +2396,11 @@ function planSync(state, segments, maxBytes, processMaxBytes) {
 				base,
 				shownText: piece
 			};
+			push({
+				type: "insert",
+				elementJson,
+				sequence: seq
+			});
 			if (piece.length < elementContent.length) {
 				carry = {
 					segIndex: i,
@@ -2203,19 +2416,21 @@ function planSync(state, segments, maxBytes, processMaxBytes) {
 		closedSegCount = i + 1;
 		i += 1;
 	}
-	return {
-		state: {
-			cardId,
-			seq,
-			cardBytes,
-			cardElements,
-			segCounter,
-			closedSegCount,
-			tail,
-			carry
-		},
-		ops
+	const snap = {
+		cardId,
+		seq,
+		cardBytes,
+		cardElements,
+		segCounter,
+		closedSegCount,
+		tail,
+		carry
 	};
+	ops.push({
+		op: { type: "noop" },
+		commit: () => ({ ...snap })
+	});
+	return { ops };
 }
 /** 定格：先 update 状态行（流式还开着），再关闭 + summary。 */
 function planFinalize(state, status) {
@@ -2245,6 +2460,10 @@ async function withRetry(fn, attempts = 3, baseDelayMs = 300) {
 	}
 	throw lastError;
 }
+/** 卡片输出异常时的用户提示（仅真实废弃一张已发卡时发送）。 */
+const ABANDON_NOTICE = "⚠️ 卡片输出异常，已在新卡片继续；如有内容缺失请重发。";
+/** 单次 flush 内连续废弃换卡的上限（防异常死循环；超限抛给出站链日志）。 */
+const MAX_ABANDON_PER_FLUSH = 3;
 var FeishuReplyHandle = class {
 	api;
 	chatId;
@@ -2254,6 +2473,7 @@ var FeishuReplyHandle = class {
 	segments = [];
 	tail = Promise.resolve();
 	timer;
+	planQueued = false;
 	finalized = false;
 	constructor(api, chatId, tunables, log) {
 		this.api = api;
@@ -2261,7 +2481,6 @@ var FeishuReplyHandle = class {
 		this.tunables = tunables;
 		this.log = log;
 	}
-	/** 惰性建卡：无文本输出的 turn 不产生空卡片。 */
 	beginTurn() {
 		return Promise.resolve();
 	}
@@ -2286,49 +2505,204 @@ var FeishuReplyHandle = class {
 		}
 		this.flush();
 		await this.tail;
+		const hadCard = this.state.cardId !== null;
 		const { ops } = planFinalize(this.state, status);
-		this.enqueue(() => this.exec(ops));
-		if (this.state.cardId === null && detail !== void 0) this.enqueue(() => withRetry(() => this.api.sendText(this.chatId, detail)).then(() => void 0));
+		this.enqueue(async () => {
+			for (const op of ops) if (await this.execOne({
+				op,
+				commit: (s) => s
+			}) === "abandoned") return;
+		});
+		if (!hadCard && detail !== void 0) this.enqueue(() => withRetry(() => this.api.sendText(this.chatId, detail)).then(() => void 0));
 		await this.tail;
 	}
 	notice(text) {
 		this.enqueue(() => withRetry(() => this.api.sendText(this.chatId, text)).then(() => void 0));
 		return this.tail.then(() => void 0);
 	}
+	/**
+	* 规划入串行链：planSync 在执行点读最新已确认状态与最新 segments，
+	* 在飞期间到达的 flush 只标位不重复规划（杜绝重复建卡/重复 insert）。
+	*/
 	flush() {
-		const planned = planSync(this.state, this.segments, this.tunables.cardMaxBytes, this.tunables.processMaxBytes);
-		if (planned.ops.length === 0) return;
-		this.state = planned.state;
-		this.enqueue(() => this.exec(planned.ops));
+		if (this.planQueued) return;
+		this.planQueued = true;
+		this.enqueue(async () => {
+			this.planQueued = false;
+			const { ops } = planSync(this.state, this.segments, this.tunables.cardMaxBytes, this.tunables.processMaxBytes, this.tunables.cardPrintStep);
+			await this.exec(ops);
+		});
+	}
+	/** 逐 op 确认执行；遇废弃从已确认状态重新规划续写（上限 MAX_ABANDON_PER_FLUSH 次）。 */
+	async exec(ops) {
+		let pending = ops;
+		for (let attempts = 0;; attempts++) {
+			let abandoned = false;
+			for (const planned of pending) if (await this.execOne(planned) === "abandoned") {
+				abandoned = true;
+				break;
+			}
+			if (!abandoned) return;
+			if (attempts >= MAX_ABANDON_PER_FLUSH) throw new Error("卡片连续废弃超限，本批输出放弃（下一 flush 继续）");
+			pending = planSync(this.state, this.segments, this.tunables.cardMaxBytes, this.tunables.processMaxBytes, this.tunables.cardPrintStep).ops;
+		}
+	}
+	/**
+	* 单个 op：成功（或 insert 300301 视同成功）才 commit；
+	* 失败按错误码分类：流式超时重激活重放 / 200860 废弃续写 / 未知错误 seq+2 重放一次。
+	*/
+	async execOne(planned) {
+		const { op } = planned;
+		if (op.type === "noop") {
+			this.commit(planned);
+			return "ok";
+		}
+		const liveCard = this.state.cardId !== null && this.state.cardId !== "__pending__";
+		try {
+			await this.invokeThenCommit(planned);
+			return "ok";
+		} catch (error) {
+			if (!liveCard) throw error;
+			const code = feishuErrorCode(error);
+			if (op.type === "insert" && code === 300301) {
+				this.commit(planned);
+				return "ok";
+			}
+			if (code === 200850 || code === 200510) {
+				if (await this.reactivate()) try {
+					await this.invokeThenCommit(planned, this.state.seq + 1);
+					return "ok";
+				} catch {
+					return this.abandon("流式超时重激活后重放失败", true);
+				}
+				return this.abandon("流式超时且重激活失败", true);
+			}
+			if (code === 200860) return this.abandon("卡片超出平台大小上限", false);
+			try {
+				const retrySeq = (op.type === "insert" || op.type === "update" || op.type === "settings" ? op.sequence : this.state.seq) + 2;
+				await this.invokeThenCommit(planned, retrySeq);
+				return "ok";
+			} catch (retryError) {
+				if (op.type === "insert" && feishuErrorCode(retryError) === 300301) {
+					this.commit(planned);
+					return "ok";
+				}
+				return this.abandon("卡片操作重放失败", true);
+			}
+		}
+	}
+	/**
+	* 执行 API 并在成功后 commit；seqOverride 用于重放（create 的真实 cardId 在此覆盖进状态）。
+	* 带序号 op 的发送/提交序号一律取 max(本次序号, 已确认 seq+1)：重放/重激活会推高已确认 seq，
+	* 批内后续 op 的规划序号可能落后，照发会以非递增序号碰撞（平台可能视作幂等 no-op 静默丢 op →
+	* 定格/关流 op 消失 → 卡死「输出中」）。
+	*/
+	async invokeThenCommit(planned, seqOverride) {
+		const effectiveSeq = effectiveSeqOf(planned.op, seqOverride, this.state.seq);
+		const op = withSeq(planned.op, effectiveSeq);
+		if (op.type === "create") {
+			const id = await withRetry(() => this.api.createCard(op.cardJson));
+			this.state = {
+				...planned.commit(this.state),
+				cardId: id
+			};
+			return;
+		}
+		if (op.type === "send") await withRetry(() => this.api.sendCardMessage(this.chatId, this.state.cardId));
+		else if (op.type === "insert") await this.api.insertElement(this.state.cardId, op.elementJson, STATUS_ELEMENT_ID, op.sequence);
+		else if (op.type === "update") await this.api.updateCardElement(this.state.cardId, op.elementId, op.content, op.sequence);
+		else if (op.type === "settings") await this.api.setCardStreaming(this.state.cardId, op.streaming, op.sequence, op.summary);
+		this.commit(planned, effectiveSeq);
+	}
+	commit(planned, seqOverride) {
+		const next = planned.commit(this.state);
+		const current = this.state.cardId;
+		const cardId = next.cardId === "__pending__" && current !== null && current !== "__pending__" ? current : next.cardId;
+		this.state = seqOverride !== void 0 ? {
+			...next,
+			seq: seqOverride,
+			cardId
+		} : {
+			...next,
+			seq: Math.max(next.seq, this.state.seq),
+			cardId
+		};
+	}
+	/** 流式超时后的官方恢复路径：settings 重设 streaming_mode:true（占一个 sequence）。 */
+	async reactivate() {
+		const { cardId, seq } = this.state;
+		if (cardId === null || cardId === "__pending__") return false;
+		try {
+			await this.api.setCardStreaming(cardId, true, seq + 1);
+			this.state = {
+				...this.state,
+				seq: seq + 1
+			};
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* 废弃当前卡：尽力关流 → cardId 归零、尾段回卷为 carry → 调用方重新规划续写。
+	* reshowTail=true（未知失败，op 可能已执行）时从尾段 base 重演（少量重复优于丢失）；
+	* reshowTail=false（200860 确定性未应用）时跳过已显示部分（零重复）。
+	*/
+	async abandon(reason, reshowTail) {
+		const { cardId, tail, seq } = this.state;
+		const hadRealCard = cardId !== null && cardId !== "__pending__";
+		if (hadRealCard) await this.api.setCardStreaming(cardId, false, seq + 1).catch(() => void 0);
+		if (tail !== void 0) {
+			const base = this.segments[tail.segIndex]?.kind === "process" ? 0 : reshowTail ? tail.base : tail.base + tail.shownText.length;
+			this.state = {
+				...this.state,
+				cardId: null,
+				tail: void 0,
+				closedSegCount: tail.segIndex,
+				carry: {
+					segIndex: tail.segIndex,
+					base
+				}
+			};
+		} else this.state = {
+			...this.state,
+			cardId: null
+		};
+		this.log(`[project-bot] 卡片输出异常（${reason}），已废弃当前卡并在新卡继续`);
+		if (hadRealCard) await withRetry(() => this.api.sendText(this.chatId, ABANDON_NOTICE)).catch(() => void 0);
+		return "abandoned";
 	}
 	enqueue(task) {
 		this.tail = this.tail.then(task).catch((error) => {
-			if (this.state.cardId === "__pending__") {
-				const t = this.state.tail;
-				this.state = {
-					...this.state,
-					cardId: null,
-					...t !== void 0 ? {
-						tail: void 0,
-						carry: {
-							segIndex: t.segIndex,
-							base: t.base
-						},
-						closedSegCount: t.segIndex
-					} : {}
-				};
-			}
 			this.log(`[project-bot] 卡片操作失败：${error instanceof Error ? error.message : String(error)}`);
 		});
 	}
-	async exec(ops) {
-		for (const op of ops) if (op.type === "create") this.state.cardId = await withRetry(() => this.api.createCard(op.cardJson));
-		else if (op.type === "send") await withRetry(() => this.api.sendCardMessage(this.chatId, this.state.cardId));
-		else if (op.type === "insert") await withRetry(() => this.api.insertElement(this.state.cardId, op.elementJson, STATUS_ELEMENT_ID, op.sequence));
-		else if (op.type === "update") await withRetry(() => this.api.updateCardElement(this.state.cardId, op.elementId, op.content, op.sequence));
-		else await withRetry(() => this.api.setCardStreaming(this.state.cardId, op.streaming, op.sequence, op.summary));
-	}
 };
+/** 重放用：仅带 sequence 语义的 op 替换序号（create/send 无序号）。 */
+function withSeq(op, sequence) {
+	if (sequence === void 0) return op;
+	if (op.type === "insert") return {
+		...op,
+		sequence
+	};
+	if (op.type === "update") return {
+		...op,
+		sequence
+	};
+	if (op.type === "settings") return {
+		...op,
+		sequence
+	};
+	return op;
+}
+/**
+* 带序号 op 的生效 sequence（create/send 返回 undefined = 不占序号）：
+* 重放/重激活推高已确认 seq 后，规划或重放序号落后时抬升到已确认 seq+1，保证单调不碰撞。
+*/
+function effectiveSeqOf(op, override, confirmedSeq) {
+	if (op.type !== "insert" && op.type !== "update" && op.type !== "settings") return void 0;
+	return Math.max(override ?? op.sequence, confirmedSeq + 1);
+}
 /** 「处理中」表情：加上后返回删除 disposer；加/删失败都静默（表情残留无害）。 */
 function makeAck(api, messageId, emojiType) {
 	return async () => {
@@ -2343,52 +2717,173 @@ function makeAck(api, messageId, emojiType) {
 	};
 }
 //#endregion
-//#region src/channels/feishu/index.ts
-/** 飞书渠道：WSClient 长连接收事件 → 解析 → 核心；出站走 FeishuReplyHandle。 */
-const feishuChannel = {
-	type: "feishu",
-	async start(bot, io, tunables, log) {
-		const { appId } = bot.record.feishu;
-		const api = createFeishuApi(new lark.Client({
-			appId,
-			appSecret: bot.secret
-		}));
-		const dedup = new MessageDedup();
-		const dispatcher = new lark.EventDispatcher({}).register({
-			"im.message.message_read_v1": async () => void 0,
-			"im.message.receive_v1": async (data) => {
-				const parsed = parseMessageEvent(data);
-				if (parsed === null || !dedup.check(parsed.messageId)) return;
-				const reply = new FeishuReplyHandle(api, parsed.chatId, tunables, log);
-				const loadImages = parsed.imageKeys.length > 0 ? async () => Promise.all(parsed.imageKeys.map(async (key) => api.downloadImage(parsed.messageId, key))) : void 0;
-				io.onMessage({
-					botId: bot.record.id,
-					chatId: parsed.chatId,
-					userId: parsed.userId,
-					messageId: parsed.messageId,
-					text: parsed.text,
-					...loadImages !== void 0 ? { loadImages } : {},
-					reply,
-					ackProcessing: makeAck(api, parsed.messageId, tunables.processingReactionEmoji)
-				});
-			}
-		});
-		const ws = new lark.WSClient({
-			appId,
-			appSecret: bot.secret,
-			loggerLevel: lark.LoggerLevel.warn
-		});
-		await ws.start({ eventDispatcher: dispatcher });
-		return {
-			close: () => {
-				ws.close({ force: true });
-				return Promise.resolve();
-			},
-			status: () => ws.getConnectionStatus().state
-		};
-	}
+//#region src/channels/approval/feishu.ts
+const STATUS_TEXT = {
+	allowed: "✅ 已允许",
+	rejected: "❌ 已拒绝",
+	cancelled: "⏹ 已取消"
 };
-//#endregion
+function bodyMarkdown(prompt) {
+	const lines = [`**Bot**：${prompt.botName}`, `**工具**：\`${prompt.toolName}\``];
+	if (prompt.reason !== void 0) lines.push(`**理由**：${prompt.reason}`);
+	return lines.join("\n");
+}
+function button(text, type, key, decision) {
+	return {
+		tag: "button",
+		text: {
+			tag: "plain_text",
+			content: text
+		},
+		type,
+		behaviors: [{
+			type: "callback",
+			value: {
+				key,
+				decision
+			}
+		}]
+	};
+}
+/** 审批卡（带按钮）；summary 供会话列表/推送预览。 */
+function buildApprovalCardJson(prompt) {
+	return JSON.stringify({
+		schema: "2.0",
+		config: { summary: { content: `权限申请：${prompt.toolName}` } },
+		header: {
+			title: {
+				tag: "plain_text",
+				content: "权限申请"
+			},
+			template: "orange"
+		},
+		body: { elements: [{
+			tag: "markdown",
+			content: bodyMarkdown(prompt)
+		}, {
+			tag: "action",
+			actions: [button("允许", "primary", prompt.key, "allow"), button("拒绝", "danger", prompt.key, "reject")]
+		}] }
+	});
+}
+/** 终态卡（无按钮）：定格审批结果；operatorName 仅允许/拒绝时有。 */
+function buildApprovalFinalCardJson(prompt, status, operatorName) {
+	const statusLine = STATUS_TEXT[status] + (operatorName !== void 0 ? ` · ${operatorName}` : "");
+	const template = status === "allowed" ? "green" : status === "rejected" ? "red" : "grey";
+	return JSON.stringify({
+		schema: "2.0",
+		config: { summary: { content: `权限申请${STATUS_TEXT[status].slice(2).trim()}：${prompt.toolName}` } },
+		header: {
+			title: {
+				tag: "plain_text",
+				content: `权限申请 · ${statusLine}`
+			},
+			template
+		},
+		body: { elements: [{
+			tag: "markdown",
+			content: bodyMarkdown(prompt)
+		}] }
+	});
+}
+/** 飞书审批能力：present = 建卡 + 发消息；finalize = replaceCard 定格（sequence 从 1 起，create/send 不占）。 */
+var FeishuApprovalPresenter = class {
+	api;
+	log;
+	constructor(api, log) {
+		this.api = api;
+		this.log = log;
+	}
+	async present(prompt) {
+		const cardId = await withRetry(() => this.api.createCard(buildApprovalCardJson(prompt)));
+		await withRetry(() => this.api.sendCardMessage(prompt.chatId, cardId));
+		return { finalize: async (status, operatorName) => {
+			try {
+				await withRetry(() => this.api.replaceCard(cardId, buildApprovalFinalCardJson(prompt, status, operatorName), 1));
+			} catch (error) {
+				this.log(`[project-bot] 审批卡片定格失败（card ${cardId}）：${error instanceof Error ? error.message : String(error)}`);
+			}
+		} };
+	}
+};
+//#endregion
+//#region src/channels/feishu/card-action.ts
+/** card.action.trigger 回调解析：SDK normalizeCardAction → 渠道无关 CardActionInput；toast 应答帧负载。 */
+/** raw → CardActionInput；normalize 失败（畸形/缺字段）→ undefined。 */
+function toCardActionInput(raw) {
+	if (raw === null || typeof raw !== "object") return void 0;
+	const evt = lark.normalizeCardAction(raw);
+	if (evt === null) return void 0;
+	return {
+		chatId: evt.chatId,
+		operatorOpenId: evt.operator.openId,
+		...evt.operator.name !== void 0 ? { operatorName: evt.operator.name } : {},
+		value: evt.action.value
+	};
+}
+/** WS 应答帧负载：handler 返回值经 WSClient 回传（lib/index.js handleEventData：truthy result → respPayload.data）。 */
+function toastResponse(ack) {
+	if (ack?.toast === void 0) return void 0;
+	return { toast: {
+		type: "info",
+		content: ack.toast
+	} };
+}
+//#endregion
+//#region src/channels/feishu/index.ts
+/** 飞书渠道：WSClient 长连接收事件 → 解析 → 核心；出站走 FeishuReplyHandle。 */
+const feishuChannel = {
+	type: "feishu",
+	async start(bot, io, tunables, log) {
+		const { appId } = bot.record.feishu;
+		const api = createFeishuApi(new lark.Client({
+			appId,
+			appSecret: bot.secret
+		}));
+		const botOpenId = await api.getBotOpenId();
+		const dedup = new MessageDedup();
+		const dispatcher = new lark.EventDispatcher({}).register({
+			"im.message.message_read_v1": async () => void 0,
+			"im.message.receive_v1": async (data) => {
+				const parsed = parseMessageEvent(data, botOpenId);
+				if (parsed === null || !dedup.check(parsed.messageId)) return;
+				const reply = new FeishuReplyHandle(api, parsed.chatId, tunables, log);
+				const loadImages = parsed.imageKeys.length > 0 ? async () => Promise.all(parsed.imageKeys.map(async (key) => api.downloadImage(parsed.messageId, key))) : void 0;
+				io.onMessage({
+					botId: bot.record.id,
+					chatId: parsed.chatId,
+					userId: parsed.userId,
+					messageId: parsed.messageId,
+					text: parsed.text,
+					...loadImages !== void 0 ? { loadImages } : {},
+					reply,
+					ackProcessing: makeAck(api, parsed.messageId, tunables.processingReactionEmoji)
+				});
+			},
+			"card.action.trigger": (raw) => {
+				if (io.onCardAction === void 0) return void 0;
+				const action = toCardActionInput(raw);
+				if (action === void 0) return void 0;
+				return toastResponse(io.onCardAction(action)) ?? void 0;
+			}
+		});
+		const ws = new lark.WSClient({
+			appId,
+			appSecret: bot.secret,
+			loggerLevel: lark.LoggerLevel.warn
+		});
+		await ws.start({ eventDispatcher: dispatcher });
+		return {
+			approval: new FeishuApprovalPresenter(api, log),
+			close: () => {
+				ws.close({ force: true });
+				return Promise.resolve();
+			},
+			status: () => ws.getConnectionStatus().state
+		};
+	}
+};
+//#endregion
 //#region src/bots/store.ts
 /** project-bot 存储域声明：身份、版本、记录 zod schema 的单一来源。 */
 /** 飞书自建应用 appId 形态（WSClient 同款校验）。 */
@@ -2595,6 +3090,7 @@ var Inbound = class {
 			return;
 		}
 		rt.inflight = { ack: void 0 };
+		rt.reply = msg.reply;
 		rt.inflight.ack = await msg.ackProcessing().catch(() => void 0) ?? void 0;
 		const imageRefs = [];
 		if (msg.loadImages !== void 0) {
@@ -2635,6 +3131,26 @@ function hooksOf(bot) {
 	};
 }
 //#endregion
+//#region src/channels/role-assembly.ts
+/** 角色 persona 的 scoped 段名（与 Router 既有产出一致，逐字段不可改）。 */
+const ROLE_PERSONA_SECTION = "dsh-agent-toolkit:agent:persona";
+/** 角色形态创作期注入：persona 非空 → 单 section（order 0）；tools 白名单存在 → 带上（由 setupAgentScope restrict）。 */
+function roleHooks(role) {
+	const sections = role.persona === void 0 || role.persona.trim().length === 0 ? [] : [{
+		name: ROLE_PERSONA_SECTION,
+		order: 0,
+		text: role.persona
+	}];
+	return {
+		...sections.length > 0 ? { sections } : {},
+		...role.tools !== void 0 ? { tools: role.tools.allow } : {}
+	};
+}
+/** 角色模型：自配优先，缺省回退宿主默认模型（与 Router 语义一致）。 */
+function roleAgentOptions(role, defaultModel) {
+	return role.model ?? defaultModel();
+}
+//#endregion
 //#region src/channels/router.ts
 /** 绑定路由：(botId, chatId) → 长期会话；create / resume / reset。 */
 /** 发起人提示段名：bot 会话声明来源渠道与发起人 open_id。 */
@@ -2662,21 +3178,22 @@ var Router = class {
 		this.registry = registry;
 		this.injectSender = injectSender;
 	}
-	/** 取（或建/恢复）该 chat 的会话 runtime；reply 刷新为最近一次入站携带的句柄。 */
+	/**
+	* 取（或建/恢复）该 chat 的会话 runtime。存量活跃会话保持其 reply——运行中 turn 的出站
+	* 必须留在原句柄收尾，reply 刷新由 Inbound 在 in-flight 准入通过后执行；
+	* retiring（已 cancel、收尾中）的会话不可复用，重绑窗口内恢复时 resume + adopt 重建。
+	*/
 	async ensure(bot, chatId, reply, userId) {
 		const bound = this.bindings.get(bot.id, chatId);
 		if (bound !== void 0) {
 			const existing = this.sessions.get(bound);
-			if (existing !== void 0) {
-				existing.reply = reply;
-				return existing;
-			}
+			if (existing !== void 0 && !existing.retiring) return existing;
 			const agent = await this.agents.resume({
 				sessionId: bound,
 				...this.resolveSession(bot, userId)
 			});
 			await this.attach(bot.project, bound);
-			return this.adopt(bot.id, chatId, bound, agent, reply);
+			return this.adopt(bot.id, chatId, userId, bound, agent, reply);
 		}
 		const sessionId = randomUUID();
 		const agent = await this.agents.create({
@@ -2686,7 +3203,7 @@ var Router = class {
 		});
 		await this.bindings.set(bot.id, chatId, sessionId);
 		await this.attach(bot.project, sessionId);
-		return this.adopt(bot.id, chatId, sessionId, agent, reply);
+		return this.adopt(bot.id, chatId, userId, sessionId, agent, reply);
 	}
 	/** attach 失败仅告警（会话降级为未分组），不阻塞消息处理。 */
 	async attach(cwd, sessionId) {
@@ -2696,10 +3213,6 @@ var Router = class {
 			this.onWarn(`[project-bot] 会话 ${sessionId} 挂载 workspace 失败：${error instanceof Error ? error.message : String(error)}`);
 		}
 	}
-	/** 有 agentOptions 原样透传；无则回退宿主默认模型（存量 bot 不抛 no provider/model）。 */
-	resolveOptions(bot) {
-		return bot.agentOptions ?? this.defaultModel();
-	}
 	/** injectSender 开启时向 hooks.sections 末尾追加 sender 段（主/角色形态通用）。 */
 	withSenderSection(hooks, bot, userId) {
 		if (!this.injectSender) return hooks;
@@ -2715,7 +3228,7 @@ var Router = class {
 	}
 	/**
 	* 按 bot.agentRef 解析会话组装（agentOptions + 创作期 hooks）：
-	* - 缺省/指向 main → 主 Agent 形态：bot 自带 persona/tools + 默认模型回退；
+	* - 缺省/指向 main → 主 Agent 形态：bot 自带 persona/tools + 模型（自配 agentOptions 优先，缺省回退宿主默认模型）；
 	* - 指向角色 → 角色形态：persona 单 section + tools.restrict + role.model；
 	* - 指向不存在角色 → warn 并降级为主 Agent 形态。
 	*/
@@ -2725,53 +3238,134 @@ var Router = class {
 		if (role === void 0 || ref === "main") {
 			if (role === void 0 && ref !== "main") this.onWarn(`[project-bot] bot "${bot.id}" 的 agentRef "${ref}" 不存在，降级绑定主 Agent`);
 			return {
-				agentOptions: this.resolveOptions(bot),
+				agentOptions: bot.agentOptions ?? this.defaultModel(),
 				hooks: this.withSenderSection(hooksOf(bot), bot, userId)
 			};
 		}
-		const sections = role.persona === void 0 || role.persona.trim().length === 0 ? [] : [{
-			name: "dsh-agent-toolkit:agent:persona",
-			order: 0,
-			text: role.persona
-		}];
 		return {
-			agentOptions: role.model ?? this.resolveOptions(bot),
-			hooks: this.withSenderSection({
-				...sections.length > 0 ? { sections } : {},
-				...role.tools !== void 0 ? { tools: role.tools.allow } : {}
-			}, bot, userId)
+			agentOptions: roleAgentOptions(role, this.defaultModel),
+			hooks: this.withSenderSection(roleHooks(role), bot, userId)
 		};
 	}
-	/** /new：取消旧会话、清绑定、开新会话。 */
+	/** /new：取消旧会话；等 turn/end 落定（旧卡在旧句柄 finalize）后再摘出 sessions。 */
 	async reset(bot, chatId, reply, userId) {
 		const bound = this.bindings.get(bot.id, chatId);
 		if (bound !== void 0) {
-			this.sessions.get(bound)?.agent.cancel();
-			this.sessions.delete(bound);
+			const old = this.sessions.get(bound);
+			if (old !== void 0) this.retire(bound, old);
 			await this.bindings.delete(bot.id, chatId);
 		}
 		return this.ensure(bot, chatId, reply, userId);
 	}
+	/** 取消会话并等出站链落定后摘出 sessions（让在飞 turn 的 turn/end 正常 finalize 旧卡）。 */
+	retire(sessionId, rt) {
+		rt.retiring = true;
+		rt.agent.cancel();
+		(async () => {
+			await rt.agent.whenIdle().catch(() => void 0);
+			await rt.tail.catch(() => void 0);
+			if (this.sessions.get(sessionId) === rt) this.sessions.delete(sessionId);
+		})();
+	}
 	lookup(botId, chatId) {
 		const bound = this.bindings.get(botId, chatId);
 		return bound === void 0 ? void 0 : this.sessions.get(bound);
 	}
-	adopt(botId, chatId, sessionId, agent, reply) {
+	adopt(botId, chatId, userId, sessionId, agent, reply) {
 		const rt = {
 			botId,
 			chatId,
 			sessionId,
+			initiatorOpenId: userId,
 			agent,
 			reply,
 			inflight: void 0,
 			tail: Promise.resolve(),
-			turn: void 0
+			turn: void 0,
+			retiring: false
 		};
 		this.sessions.set(sessionId, rt);
 		return rt;
 	}
 };
 //#endregion
+//#region src/channels/approval/center.ts
+/** 审批中心（渠道无关）：自有 bot 会话的 approval ask → 渠道审批卡片挂起 → 卡片回调 resolve。
+*  spec: docs/superpowers/specs/2026-09-08-feishu-approval-card-design.md（飞书独占 / 仅发起人 / 不超时）。 */
+var ApprovalCenter = class {
+	sessions;
+	channelFor;
+	warn;
+	newId;
+	pending = /* @__PURE__ */ new Map();
+	constructor(sessions, channelFor, warn, newId = randomUUID) {
+		this.sessions = sessions;
+		this.channelFor = channelFor;
+		this.warn = warn;
+		this.newId = newId;
+	}
+	async handleRequest(req) {
+		const sessionId = String(req.agent.session.id);
+		const rt = this.sessions.get(sessionId);
+		if (rt === void 0) return void 0;
+		if (req.signal?.aborted === true) return "cancelled";
+		const channel = this.channelFor(rt.botId);
+		if (channel === void 0) {
+			this.warn(`[project-bot] bot "${rt.botId}" 的渠道无审批能力，回退其他审批通道`);
+			return;
+		}
+		const key = this.newId();
+		let presentation;
+		try {
+			presentation = await channel.presenter.present({
+				key,
+				chatId: rt.chatId,
+				botName: channel.botName,
+				toolName: req.toolName,
+				...req.reason !== void 0 ? { reason: req.reason } : {}
+			});
+		} catch (error) {
+			this.warn(`[project-bot] 审批卡片发送失败，回退其他审批通道：${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		return new Promise((resolve) => {
+			const entry = {
+				sessionId,
+				resolve,
+				presentation,
+				signal: req.signal,
+				onAbort: () => this.settle(key, "cancelled")
+			};
+			this.pending.set(key, entry);
+			req.signal?.addEventListener("abort", entry.onAbort, { once: true });
+		});
+	}
+	handleCardAction(action) {
+		const value = action.value;
+		if (value === null || typeof value !== "object" || typeof value.key !== "string" || value.decision !== "allow" && value.decision !== "reject") return void 0;
+		const entry = this.pending.get(value.key);
+		if (entry === void 0) return { toast: "该申请已处理或已失效" };
+		const rt = this.sessions.get(entry.sessionId);
+		if (rt === void 0 || rt.initiatorOpenId !== action.operatorOpenId) return { toast: "仅会话发起人可审批" };
+		this.settle(value.key, value.decision === "allow" ? "allowed-once" : "rejected", action.operatorName);
+		return { toast: value.decision === "allow" ? "已允许" : "已拒绝" };
+	}
+	dispose() {
+		for (const key of [...this.pending.keys()]) this.settle(key, "cancelled");
+	}
+	settle(key, outcome, operatorName) {
+		const entry = this.pending.get(key);
+		if (entry === void 0) return;
+		this.pending.delete(key);
+		entry.signal?.removeEventListener("abort", entry.onAbort);
+		entry.resolve(outcome);
+		const status = outcome === "allowed-once" ? "allowed" : outcome === "rejected" ? "rejected" : "cancelled";
+		entry.presentation.finalize(status, operatorName).catch((error) => {
+			this.warn(`[project-bot] 审批卡片定格失败：${error instanceof Error ? error.message : String(error)}`);
+		});
+	}
+};
+//#endregion
 //#region src/channels/runtime.ts
 var BotRuntime = class {
 	deps;
@@ -2779,6 +3373,7 @@ var BotRuntime = class {
 	router;
 	inbound;
 	outbound;
+	approval;
 	handles = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		this.deps = deps;
@@ -2792,6 +3387,14 @@ var BotRuntime = class {
 			onError: (m) => deps.log.warn(m)
 		});
 		this.outbound = new Outbound(this.sessions, (m) => deps.log.warn(m), deps.maxErrorDetailChars);
+		this.approval = new ApprovalCenter(this.sessions, (botId) => {
+			const presenter = this.handles.get(botId)?.approval;
+			if (presenter === void 0) return void 0;
+			return {
+				presenter,
+				botName: this.deps.bots.get(botId)?.name ?? botId
+			};
+		}, (m) => deps.log.warn(m));
 	}
 	async startAll() {
 		for (const botId of [...this.deps.bots.keys()]) await this.reconcile(botId);
@@ -2820,7 +3423,10 @@ var BotRuntime = class {
 			const handle = await channel.start({
 				record,
 				secret
-			}, { onMessage: (msg) => this.inbound.onMessage(msg) }, this.deps.tunables, (m) => this.deps.log.warn(m));
+			}, {
+				onMessage: (msg) => this.inbound.onMessage(msg),
+				onCardAction: (action) => this.approval.handleCardAction(action)
+			}, this.deps.tunables, (m) => this.deps.log.warn(m));
 			this.handles.set(botId, handle);
 		} catch (error) {
 			this.deps.log.warn(`[project-bot] bot "${botId}" 渠道启动失败：${error instanceof Error ? error.message : String(error)}`);
@@ -2829,19 +3435,23 @@ var BotRuntime = class {
 	/** 删除 bot：停渠道、取消会话、清绑定。 */
 	async stopBot(botId) {
 		await this.stopChannel(botId);
-		for (const [sessionId, rt] of [...this.sessions]) if (rt.botId === botId) {
-			rt.agent.cancel();
-			this.sessions.delete(sessionId);
-		}
+		for (const [sessionId, rt] of [...this.sessions]) if (rt.botId === botId) this.retire(sessionId, rt);
 		await this.bindingStore().deleteBot(botId);
 	}
 	/** 解绑渠道：停渠道、取消在飞会话；绑定表与持久会话保留（重绑后 resume 接续）。 */
 	async unbindBot(botId) {
 		await this.stopChannel(botId);
-		for (const [sessionId, rt] of [...this.sessions]) if (rt.botId === botId) {
-			rt.agent.cancel();
-			this.sessions.delete(sessionId);
-		}
+		for (const [sessionId, rt] of [...this.sessions]) if (rt.botId === botId) this.retire(sessionId, rt);
+	}
+	/** 取消会话并等出站链落定后摘出 sessions（让在飞 turn 的 turn/end 正常 finalize 旧卡）。 */
+	retire(sessionId, rt) {
+		rt.retiring = true;
+		rt.agent.cancel();
+		(async () => {
+			await rt.agent.whenIdle().catch(() => void 0);
+			await rt.tail.catch(() => void 0);
+			if (this.sessions.get(sessionId) === rt) this.sessions.delete(sessionId);
+		})();
 	}
 	statusOf(botId) {
 		const record = this.deps.bots.get(botId);
@@ -2857,6 +3467,7 @@ var BotRuntime = class {
 		}));
 		await Promise.allSettled([...this.handles.values()].map((h) => h.close()));
 		this.handles.clear();
+		this.approval.dispose();
 	}
 	async stopChannel(botId) {
 		const handle = this.handles.get(botId);
@@ -2883,6 +3494,20 @@ var BotRuntime = class {
 	}
 };
 //#endregion
+//#region src/channels/scope-joiner.ts
+function createScopeJoiner(ctx, presetId, fallback, warn) {
+	return { async join(agentCtx) {
+		const agentPresets = ctx.get("agentPresets", false);
+		if (agentPresets !== void 0) try {
+			await agentPresets.mount(agentCtx, presetId);
+			return;
+		} catch (error) {
+			warn(`dsh-agent-toolkit: bot 会话挂载 preset "${presetId}" 失败，回退基础工具 standing scope（此后该会话委派子会话将看不到基础工具）：${error instanceof Error ? error.message : String(error)}`);
+		}
+		await fallback.join(agentCtx);
+	} };
+}
+//#endregion
 //#region src/channels/tool-scope.ts
 /** 默认加载器：复刻 preset mount 的模块解析——loader 的 unwrapExports 取 `default ?? 命名导出模块`。 */
 async function loadToolModule(specifier) {
@@ -2932,10 +3557,17 @@ function createToolsScope(ctx, loadTool = loadToolModule) {
 	};
 }
 //#endregion
+//#region src/channels/approval/answerer.ts
+function createApprovalAnswerer(centerOf) {
+	return async (req, next) => {
+		return await centerOf()?.handleRequest(req) ?? next();
+	};
+}
+//#endregion
 //#region src/bots/api.ts
 /** 浏览器半 RPC：单前缀路由 /dsh-agent-toolkit/api/bots + 内部路径分发。 */
 const MAX_BODY_BYTES = 65536;
-const CreateBodySchema = z$1.object({
+const CreateBodySchema$1 = z$1.object({
 	/** 缺省时后端自动生成（bot-<8 位随机小写字母数字>）。 */
 	id: z$1.string().regex(BOT_ID_RE).optional(),
 	name: z$1.string().min(1).max(64),
@@ -2956,7 +3588,7 @@ const CreateBodySchema = z$1.object({
 		appSecretRef: z$1.string().regex(CREDENTIAL_REF_RE).optional()
 	})
 });
-const UpdateBodySchema = z$1.object({
+const UpdateBodySchema$1 = z$1.object({
 	name: z$1.string().min(1).max(64).optional(),
 	project: z$1.string().min(1).optional(),
 	persona: z$1.string().max(8e3).nullable().optional(),
@@ -3022,7 +3654,7 @@ function createApiHandler(deps) {
 		if (sub === "/bots" && method === "POST") {
 			const body = await readJsonBody(req, res);
 			if (body === void 0) return;
-			const parsed = CreateBodySchema.safeParse(body);
+			const parsed = CreateBodySchema$1.safeParse(body);
 			if (!parsed.success) {
 				json(res, 400, { error: parsed.error.issues[0]?.message ?? "invalid body" });
 				return;
@@ -3082,7 +3714,7 @@ function createApiHandler(deps) {
 			}
 			const body = await readJsonBody(req, res);
 			if (body === void 0) return;
-			const parsed = UpdateBodySchema.safeParse(body);
+			const parsed = UpdateBodySchema$1.safeParse(body);
 			if (!parsed.success) {
 				json(res, 400, { error: parsed.error.issues[0]?.message ?? "invalid body" });
 				return;
@@ -3201,7 +3833,7 @@ function createApiHandler(deps) {
 //#endregion
 //#region src/bots/register-app.ts
 /** 扫码一键创建飞书应用：lark.registerApp（OAuth 2.0 Device Authorization Grant）的状态机封装。 */
-/** 扫码创建应用时申请的权限/事件（流式卡片 + 收发消息 + 表情 + 通讯录基础信息）。
+/** 扫码创建应用时申请的权限/事件/回调（流式卡片 + 收发消息 + 表情 + 通讯录基础信息 + 审批卡片回传）。
 * 故意不加 as const：readonly 元组不可赋值给 SDK AppAddons 的 mutable string[]，
 * 否则 bots/index.ts 的 lark.registerApp(options) 透传会 typecheck 失败。 */
 const FEISHU_REGISTER_APP_ADDONS = {
@@ -3211,7 +3843,8 @@ const FEISHU_REGISTER_APP_ADDONS = {
 		"cardkit:card:write",
 		"contact:user.base:readonly"
 	] },
-	events: { items: { tenant: ["im.message.receive_v1"] } }
+	events: { items: { tenant: ["im.message.receive_v1"] } },
+	callbacks: { items: ["card.action.trigger"] }
 };
 var RegisterAppService = class {
 	deps;
@@ -3285,6 +3918,7 @@ function setupBots(ctx, config, deps) {
 		cardUpdateThrottleMs: config.cardUpdateThrottleMs,
 		cardMaxBytes: config.cardMaxBytes,
 		processMaxBytes: config.processMaxBytes,
+		cardPrintStep: config.cardPrintStep,
 		processingReactionEmoji: config.processingReactionEmoji
 	};
 	const storeSecret = async (key, secret) => {
@@ -3292,34 +3926,10 @@ function setupBots(ctx, config, deps) {
 		await ctx.credentials.set(credentialRef(ref), secret);
 		return ref;
 	};
-	/** 创作期注入已迁至 agent-setup.ts + tool-scope.ts（基础工具行 standing scope 挂载 + persona/tools），preset 机制整体移除。 */
+	/** 创作期注入已迁至 agent-setup.ts + tool-scope.ts（基础工具行 standing scope 挂载 + persona/tools）。
+	*  preset 优先 joiner（agent-bot 组合）：mount 成功后委派子会话 composeFrom 认父（spec: docs/superpowers/specs/2026-09-07-bot-delegation-preset-mount-design.md）。 */
 	const toolsScope = createToolsScope(ctx);
-	const agentsPort = {
-		async create(input) {
-			return adaptAgent(await ctx.agents.create({
-				sessionId: SessionId(input.sessionId),
-				meta: { cwd: input.cwd },
-				...input.agentOptions !== void 0 ? { agentOptions: input.agentOptions } : {},
-				setup: (agentCtx) => setupAgentScope(agentCtx, input.hooks, toolsScope)
-			}));
-		},
-		async resume(input) {
-			return adaptAgent(await ctx.agents.resume({
-				resumeSessionId: SessionId(input.sessionId),
-				...input.agentOptions !== void 0 ? { agentOptions: input.agentOptions } : {},
-				setup: (agentCtx) => setupAgentScope(agentCtx, input.hooks, toolsScope)
-			}));
-		}
-	};
-	function adaptAgent(handle) {
-		const { agent } = handle;
-		return {
-			sessionId: String(agent.id),
-			followup: (message) => agent.followup(message),
-			cancel: () => agent.cancel({ kind: "user" }),
-			whenIdle: () => agent.whenIdle()
-		};
-	}
+	const agentsPort = createAgentsPort(ctx, deps.botPresetId !== void 0 ? createScopeJoiner(ctx, deps.botPresetId, toolsScope, log.warn) : toolsScope, deps.ownedSessions);
 	const workspaceRegistry = ctx.get("workspaceRegistry", false);
 	const workspacePort = { async attach(cwd, sessionId) {
 		if (workspaceRegistry === void 0) throw new Error("workspaceRegistry 服务不可用");
@@ -3385,6 +3995,7 @@ function setupBots(ctx, config, deps) {
 	ctx.on("session/event", (session, event) => {
 		runtime?.outbound.handleSessionEvent(String(session.header.id), event);
 	});
+	if (config.approval) ctx.on("approval/request", createApprovalAnswerer(() => runtime?.approval), { prepend: true });
 	ctx.on("agent/error", ({ agent, error }) => {
 		const text = error instanceof Error ? error.message : String(error?.message ?? error);
 		runtime?.outbound.handleAgentError(String(agent.session.id), text);
@@ -3433,6 +4044,37 @@ function setupBots(ctx, config, deps) {
 	});
 }
 //#endregion
+//#region src/agents/bot-preset.ts
+/** agent-bot preset 组合序列化：BASIC_TOOLS → preset 行（bot 会话挂载的最小组合，
+*  委派子会话 composeFrom 认父的前提；spec: docs/superpowers/specs/2026-09-07-bot-delegation-preset-mount-design.md）。 */
+/** BASIC_TOOLS 插件包名 → preset 行 id（与 standard/agent-team 的行 id 对齐）。新增 BASIC_TOOLS 行必须在此登记。 */
+const ROW_IDS = {
+	"@deepseek-ai/dsh-persona": "persona",
+	"@deepseek-ai/dsh-agent-instructions": "agent-instructions",
+	"@deepseek-ai/dsh-tool-pwsh": "tool-pwsh",
+	"@deepseek-ai/dsh-tool-bash": "tool-bash",
+	"@deepseek-ai/dsh-tool-fs": "tool-fs",
+	"@deepseek-ai/dsh-tool-fs-search": "tool-fs-search"
+};
+const BOT_PRESET_NAME = "Bot 会话";
+const BOT_PRESET_DESCRIPTION = "飞书 bot 会话组合：基础工具行（persona/instructions/shell/fs/fs-search）；委派子会话经 composeFrom 继承同一组合";
+/** BASIC_TOOLS → preset 行对象数组（未登记映射的包名抛错，防新增工具行静默丢 id）。 */
+function serializeBotRows(tools) {
+	return tools.map((tool) => {
+		const rowId = ROW_IDS[tool.id];
+		if (rowId === void 0) throw new Error(`bot-preset: BASIC_TOOLS 行 ${tool.id} 未登记 preset 行 id 映射`);
+		return {
+			id: rowId,
+			name: tool.id,
+			...tool.config !== void 0 ? { config: tool.config } : {}
+		};
+	});
+}
+/** agent-bot composition 文本（平台相关 shell 行已由 BASIC_TOOLS 选定，不用 !!js）。 */
+function botPresetComposition() {
+	return yaml.dump(serializeBotRows(BASIC_TOOLS), { lineWidth: -1 });
+}
+//#endregion
 //#region src/agents/team-preset.ts
 /**
 * Agent 团队 preset 自动生成：派生宿主当前 shipped standard composition，
@@ -3493,9 +4135,38 @@ const MARKER_CONTENT = "dsh-agent-toolkit";
 const PRESET_ID = /^[a-z0-9][a-z0-9-]*$/;
 const GENERATED_HEADER = "# 本文件由 dsh-agent-toolkit 自动生成，勿手改（每次启动重写）。\n";
 /**
-* 启动时生成/刷新 agent-team preset。所有失败路径 warn 降级，不影响插件其余功能。
-* 不设为默认 preset、卸载不删目录（可能有会话在用；composition 不引用 toolkit 行，
-* 残留 preset 自身仍可用）。每次启动重写：standing mount 按文件代际，重写只影响新会话。
+* 写一个生成 preset 目录：无标记的同名用户目录不覆盖（warn 返回 false）；marker-first 写入。
+* composition / metadata 写失败（含半途失败）留下的带标记目录，下次启动会被正常重写自愈。
+*/
+async function writeGeneratedPreset(dir, composition, metadata, warn) {
+	const markerPath = join(dir, MARKER_FILE);
+	let dirExists = true;
+	try {
+		await access(dir);
+	} catch {
+		dirExists = false;
+	}
+	if (dirExists) {
+		let marked = false;
+		try {
+			marked = (await readFile(markerPath, "utf8")).trim() === MARKER_CONTENT;
+		} catch {}
+		if (!marked) {
+			warn(`dsh-agent-toolkit: ${dir} 已存在且非本插件生成，不覆盖，跳过生成`);
+			return false;
+		}
+	}
+	await mkdir(dir, { recursive: true });
+	await writeFile(markerPath, `${MARKER_CONTENT}\n`, "utf8");
+	await writeFile(join(dir, COMPOSITION_FILE), composition, "utf8");
+	await writeFile(join(dir, METADATA_FILE), yaml.dump(metadata, { lineWidth: -1 }), "utf8");
+	return true;
+}
+/**
+* 启动时生成/刷新 agent-team 与 agent-bot 两个 preset。所有失败路径 warn 降级，不影响插件其余功能。
+* 不设为默认 preset、卸载不删目录（可能有会话在用；composition 不引用 toolkit 行，残留 preset 自身
+* 仍可用）。每次启动重写：standing mount 按文件代际，重写只影响新会话。agent-bot 内容来自 BASIC_TOOLS，
+* 不依赖源 preset 读取（read 失败只跳过 agent-team）；两块独立 try/catch、独立 marker 保护。
 */
 async function setupAgentTeamPreset(ctx, config) {
 	if (!config.enabled) return;
@@ -3504,52 +4175,979 @@ async function setupAgentTeamPreset(ctx, config) {
 	};
 	const agentPresets = ctx.get("agentPresets", false);
 	if (agentPresets === void 0) return;
-	if (!PRESET_ID.test(config.id)) {
-		warn(`dsh-agent-toolkit: agentTeamPreset.id "${config.id}" 不是合法 preset id，跳过 agent-team 生成`);
-		return;
-	}
-	let source;
-	try {
-		source = await agentPresets.read(config.source);
-	} catch (error) {
-		warn(`dsh-agent-toolkit: 读取源 preset "${config.source}" 失败，跳过 agent-team 生成：${error instanceof Error ? error.message : String(error)}`);
-		return;
-	}
 	const root = agentPresets.roots.find((r) => r.trust === "user");
 	if (root === void 0) {
-		warn("dsh-agent-toolkit: preset roots 中无 trust=user 的目录，跳过 agent-team 生成");
+		warn("dsh-agent-toolkit: preset roots 中无 trust=user 的目录，跳过 agent-team / agent-bot 生成");
 		return;
 	}
-	const composition = GENERATED_HEADER + disableSubagentRows(source, warn);
-	const dir = join(resolve(expandHomePath(root.path)), config.id);
-	try {
-		const markerPath = join(dir, MARKER_FILE);
-		let dirExists = true;
+	const presetDir = (id) => join(resolve(expandHomePath(root.path)), id);
+	if (!PRESET_ID.test(config.id)) warn(`dsh-agent-toolkit: agentTeamPreset.id "${config.id}" 不是合法 preset id，跳过 agent-team 生成`);
+	else {
+		let source;
 		try {
-			await access(dir);
-		} catch {
-			dirExists = false;
+			source = await agentPresets.read(config.source);
+		} catch (error) {
+			warn(`dsh-agent-toolkit: 读取源 preset "${config.source}" 失败，跳过 agent-team 生成：${error instanceof Error ? error.message : String(error)}`);
 		}
-		if (dirExists) {
-			let marked = false;
+		if (source !== void 0) {
+			const dir = presetDir(config.id);
 			try {
-				marked = (await readFile(markerPath, "utf8")).trim() === MARKER_CONTENT;
-			} catch {}
-			if (!marked) {
-				warn(`dsh-agent-toolkit: ${dir} 已存在且非本插件生成，不覆盖，跳过 agent-team 生成`);
-				return;
+				await writeGeneratedPreset(dir, GENERATED_HEADER + disableSubagentRows(source, warn), {
+					name: config.name,
+					description: config.description
+				}, warn);
+			} catch (error) {
+				warn(`dsh-agent-toolkit: 写入 agent-team preset 失败（${dir}）：${error instanceof Error ? error.message : String(error)}`);
 			}
 		}
-		await mkdir(dir, { recursive: true });
-		await writeFile(markerPath, `${MARKER_CONTENT}\n`, "utf8");
-		await writeFile(join(dir, COMPOSITION_FILE), composition, "utf8");
-		await writeFile(join(dir, METADATA_FILE), yaml.dump({
-			name: config.name,
-			description: config.description
-		}, { lineWidth: -1 }), "utf8");
+	}
+	if (config.id === config.botsId) warn(`dsh-agent-toolkit: agentTeamPreset.id 与 agentTeamPreset.botsId 相同（均为 "${config.id}"），跳过 agent-bot 生成`);
+	else if (!PRESET_ID.test(config.botsId)) warn(`dsh-agent-toolkit: agentTeamPreset.botsId "${config.botsId}" 不是合法 preset id，跳过 agent-bot 生成`);
+	else try {
+		await writeGeneratedPreset(presetDir(config.botsId), GENERATED_HEADER + botPresetComposition(), {
+			name: BOT_PRESET_NAME,
+			description: BOT_PRESET_DESCRIPTION
+		}, warn);
 	} catch (error) {
-		warn(`dsh-agent-toolkit: 写入 agent-team preset 失败（${dir}）：${error instanceof Error ? error.message : String(error)}`);
+		warn(`dsh-agent-toolkit: 写入 agent-bot preset 失败：${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+//#endregion
+//#region src/schedule/store.ts
+/** schedule 模块存储域声明：CronTask/CronRun 记录 schema + domain 布局的单一来源。*/
+/** 调度规则三选一：cron（5 字段，可选 IANA 时区，省略 = 进程时区）/ at（RFC 3339 一次性）/ every（≥60s，创建时间为锚）。*/
+const CronScheduleSchema = z$1.discriminatedUnion("kind", [
+	z$1.object({
+		kind: z$1.literal("cron"),
+		expr: z$1.string().min(1),
+		timeZone: z$1.string().min(1).optional()
+	}),
+	z$1.object({
+		kind: z$1.literal("at"),
+		at: z$1.string().min(1)
+	}),
+	z$1.object({
+		kind: z$1.literal("every"),
+		seconds: z$1.number().int().min(60)
+	})
+]);
+/** 执行目标：主 Agent（宿主默认模型，无 persona/restrict）或注册表角色（persona/model/工具白名单随角色）。*/
+const CronTargetSchema = z$1.discriminatedUnion("kind", [z$1.object({ kind: z$1.literal("main") }), z$1.object({
+	kind: z$1.literal("role"),
+	roleId: z$1.string().min(1)
+})]);
+const CronTaskSchema = z$1.object({
+	id: z$1.string().min(1),
+	name: z$1.string().min(1).max(64),
+	prompt: z$1.string().min(1).max(8e3),
+	cwd: z$1.string().min(1),
+	schedule: CronScheduleSchema,
+	target: CronTargetSchema,
+	catchup: z$1.boolean(),
+	enabled: z$1.boolean(),
+	/** 调度器维护的持久缓存（重启 rearm 依据），UTC ISO 串。*/
+	nextRunAt: z$1.string().nullable(),
+	createdAt: z$1.string(),
+	updatedAt: z$1.string()
+});
+const CronRunSchema = z$1.object({
+	id: z$1.string().min(1),
+	taskId: z$1.string().min(1),
+	triggeredAt: z$1.string(),
+	finishedAt: z$1.string().optional(),
+	status: z$1.enum([
+		"running",
+		"ok",
+		"error",
+		"skipped-overlap"
+	]),
+	/** 本次执行新建的会话 id（skipped-overlap 无会话）。*/
+	sessionId: z$1.string().optional(),
+	/** 错误摘要（截断）。*/
+	error: z$1.string().optional()
+});
+/** domain 名/表名均受 UNIT_NAME_RE 约束（^[a-z][a-z0-9_]*$），不允许连字符。*/
+const scheduleDomain = defineDomain({
+	name: "dsh_agent_toolkit_schedule",
+	version: 1,
+	tables: {
+		tasks: domainTable(CronTaskSchema),
+		runs: domainTable(CronRunSchema),
+		meta: domainTable(z$1.object({ value: z$1.string() }))
 	}
+});
+/** 某任务的 run 列表（新 → 旧；同刻按 id 倒序稳定化）。*/
+function listRuns(runs, taskId) {
+	return [...runs.entries()].map(([, run]) => run).filter((run) => run.taskId === taskId).sort((a, b) => b.triggeredAt.localeCompare(a.triggeredAt) || b.id.localeCompare(a.id));
+}
+/** 环形保留某任务最近 limit 条 run，超出删最旧。*/
+async function trimRuns(runs, taskId, limit) {
+	const mine = listRuns(runs, taskId);
+	for (const run of mine.slice(limit)) await runs.delete(run.id);
+}
+/** 删除任务连带清运行历史。*/
+async function deleteRunsOf(runs, taskId) {
+	for (const run of listRuns(runs, taskId)) await runs.delete(run.id);
+}
+//#endregion
+//#region src/schedule/api.ts
+const CreateBodySchema = z$1.object({
+	name: z$1.string().min(1).max(64),
+	prompt: z$1.string().min(1).max(8e3),
+	cwd: z$1.string().min(1),
+	schedule: CronScheduleSchema,
+	target: CronTargetSchema,
+	catchup: z$1.boolean(),
+	enabled: z$1.boolean()
+});
+const UpdateBodySchema = CreateBodySchema.partial();
+function createCronApiHandler(deps) {
+	return async (req, res) => {
+		const sub = new URL(req.url ?? "/", "http://127.0.0.1").pathname.replace(/^\/dsh-agent-toolkit\/api\/cron/, "") || "/";
+		const method = req.method ?? "GET";
+		const taskMatch = /^\/tasks\/([^/]+)$/.exec(sub);
+		const triggerMatch = /^\/tasks\/([^/]+)\/trigger$/.exec(sub);
+		const runsMatch = /^\/tasks\/([^/]+)\/runs$/.exec(sub);
+		if (sub === "/tasks" && method === "GET") {
+			json$1(res, 200, { tasks: deps.service.list() });
+			return;
+		}
+		if (sub === "/tasks" && method === "POST") {
+			const body = await readJsonBody$1(req, res);
+			if (body === void 0) return;
+			const parsed = CreateBodySchema.safeParse(body);
+			if (!parsed.success) {
+				json$1(res, 400, { error: parsed.error.issues[0]?.message ?? "invalid body" });
+				return;
+			}
+			const result = await deps.service.create(parsed.data);
+			if (!result.ok) {
+				json$1(res, 400, { error: result.error });
+				return;
+			}
+			json$1(res, 200, { task: result.value });
+			return;
+		}
+		if (taskMatch !== null && method === "PUT") {
+			const id = decodeURIComponent(taskMatch[1]);
+			if (deps.service.get(id) === void 0) {
+				json$1(res, 404, { error: `定时任务 "${id}" 不存在` });
+				return;
+			}
+			const body = await readJsonBody$1(req, res);
+			if (body === void 0) return;
+			const parsed = UpdateBodySchema.safeParse(body);
+			if (!parsed.success) {
+				json$1(res, 400, { error: parsed.error.issues[0]?.message ?? "invalid body" });
+				return;
+			}
+			const result = await deps.service.update(id, parsed.data);
+			if (!result.ok) {
+				json$1(res, 400, { error: result.error });
+				return;
+			}
+			json$1(res, 200, { task: result.value });
+			return;
+		}
+		if (taskMatch !== null && method === "DELETE") {
+			const id = decodeURIComponent(taskMatch[1]);
+			if (deps.service.get(id) === void 0) {
+				json$1(res, 404, { error: `定时任务 "${id}" 不存在` });
+				return;
+			}
+			const result = await deps.service.remove(id);
+			if (!result.ok) {
+				json$1(res, 400, { error: result.error });
+				return;
+			}
+			json$1(res, 200, { ok: true });
+			return;
+		}
+		if (triggerMatch !== null && method === "POST") {
+			const id = decodeURIComponent(triggerMatch[1]);
+			if (deps.service.get(id) === void 0) {
+				json$1(res, 404, { error: `定时任务 "${id}" 不存在` });
+				return;
+			}
+			const result = await deps.service.trigger(id);
+			if (!result.ok) {
+				json$1(res, /正在运行/.test(result.error) ? 409 : 400, { error: result.error });
+				return;
+			}
+			json$1(res, 200, { run: result.value });
+			return;
+		}
+		if (runsMatch !== null && method === "GET") {
+			const id = decodeURIComponent(runsMatch[1]);
+			if (deps.service.get(id) === void 0) {
+				json$1(res, 404, { error: `定时任务 "${id}" 不存在` });
+				return;
+			}
+			json$1(res, 200, { runs: deps.service.runsOf(id, deps.runHistoryLimit) });
+			return;
+		}
+		if (sub === "/projects" && method === "GET") {
+			json$1(res, 200, { projects: deps.listProjects() });
+			return;
+		}
+		if (sub === "/tasks" || taskMatch !== null || triggerMatch !== null || runsMatch !== null || sub === "/projects") {
+			json$1(res, 405, { error: "method not allowed" });
+			return;
+		}
+		json$1(res, 404, { error: "not found" });
+	};
+}
+//#endregion
+//#region src/schedule/executor.ts
+/** 定时任务执行器：输入一条 task，输出一条 run 记录（建会话 → followup → whenIdle/超时 → 落库）。 */
+/** 来源段名：声明本会话由定时任务触发（order 20，与渠道 sender 段同位）。 */
+const TASK_SECTION_NAME = "dsh-agent-toolkit:schedule:task";
+function taskSectionText(task, triggeredAt) {
+	return `本会话由定时任务「${task.name}」（id: ${task.id}）于 ${triggeredAt} 触发。`;
+}
+/** 错误摘要最大字符数（对齐 feishu.errorDetailMaxChars 默认 500）。 */
+const ERROR_MAX_CHARS = 500;
+var RunTimeoutError = class extends Error {
+	constructor() {
+		super("timeout");
+	}
+};
+function createExecutor(deps) {
+	async function persist(run) {
+		await deps.runs.put(run.id, run);
+		await trimRuns(deps.runs, run.taskId, deps.runHistoryLimit);
+	}
+	return { async trigger(task) {
+		const triggeredAt = new Date(deps.now()).toISOString();
+		const sessionId = deps.newSessionId();
+		const run = {
+			id: deps.newRunId(),
+			taskId: task.id,
+			triggeredAt,
+			status: "running",
+			sessionId
+		};
+		await persist(run);
+		const finish = async (status, error) => {
+			const done = {
+				...run,
+				status,
+				finishedAt: new Date(deps.now()).toISOString(),
+				...error !== void 0 ? { error: error.slice(0, ERROR_MAX_CHARS) } : {}
+			};
+			await persist(done);
+			return done;
+		};
+		const source = {
+			name: TASK_SECTION_NAME,
+			order: 20,
+			text: taskSectionText(task, triggeredAt)
+		};
+		let agentOptions;
+		let hooks;
+		const roleId = task.target.kind === "role" ? task.target.roleId : "main";
+		const role = roleId === "main" ? void 0 : deps.registry.get(roleId);
+		if (roleId === "main" || role === void 0) {
+			if (roleId !== "main" && role === void 0) deps.warn(`[schedule] 定时任务 "${task.id}" 的角色 "${roleId}" 不存在，降级主 Agent 形态`);
+			agentOptions = deps.defaultModel();
+			hooks = { sections: [source] };
+		} else {
+			const base = roleHooks(role);
+			agentOptions = roleAgentOptions(role, deps.defaultModel);
+			hooks = {
+				...base,
+				sections: [...base.sections ?? [], source]
+			};
+		}
+		let agent;
+		try {
+			agent = await deps.agents.create({
+				sessionId,
+				cwd: task.cwd,
+				agentOptions,
+				hooks
+			});
+		} catch (error) {
+			return finish("error", error instanceof Error ? error.message : String(error));
+		}
+		try {
+			await deps.workspace.attach(task.cwd, sessionId);
+		} catch (error) {
+			deps.warn(`[schedule] 会话 ${sessionId} 挂载 workspace 失败：${error instanceof Error ? error.message : String(error)}`);
+		}
+		agent.followup(createUserMessage({
+			content: [{
+				type: "text",
+				text: task.prompt
+			}],
+			source: { kind: "user" }
+		}));
+		const idle = agent.whenIdle();
+		idle.catch(() => void 0);
+		const timeout = deps.delay(deps.runTimeoutMs).then(() => {
+			throw new RunTimeoutError();
+		});
+		timeout.catch(() => void 0);
+		try {
+			await Promise.race([idle, timeout]);
+			return await finish("ok");
+		} catch (error) {
+			if (error instanceof RunTimeoutError) {
+				agent.cancel();
+				return await finish("error", `timeout（超过 ${Math.round(deps.runTimeoutMs / 6e4)} 分钟未空闲，已取消）`);
+			}
+			return await finish("error", error instanceof Error ? error.message : String(error));
+		}
+	} };
+}
+//#endregion
+//#region src/schedule/timing.ts
+/** cron/at/every 纯时间运算：校验、下一触发点、预览、启动 rearm。全部注入 now，无隐藏时钟。*/
+/** croner 选项：paused 仅做解析与预测，不注册真实定时器（计时由调度器 tick 驱动）。*/
+function cronerOptions(schedule) {
+	return {
+		paused: true,
+		...schedule.timeZone !== void 0 ? { timezone: schedule.timeZone } : {}
+	};
+}
+/** 创建/更新即校验；合法返回 undefined，非法返回错误消息（不入库由调用方保证）。*/
+function validateSchedule(schedule, nowMs) {
+	switch (schedule.kind) {
+		case "cron": {
+			const fields = schedule.expr.trim().split(/\s+/);
+			if (fields.length !== 5) return `cron 表达式须为 5 字段（分 时 日 月 周），收到 ${fields.length} 字段；秒级/年字段暂不开放`;
+			if (schedule.timeZone !== void 0) try {
+				new Intl.DateTimeFormat("en-US", { timeZone: schedule.timeZone });
+			} catch {
+				return `未知时区：${schedule.timeZone}`;
+			}
+			try {
+				new Cron(schedule.expr, cronerOptions(schedule));
+			} catch (error) {
+				return `非法 cron 表达式"${schedule.expr}"：${error instanceof Error ? error.message : String(error)}`;
+			}
+			return;
+		}
+		case "at": {
+			const t = Date.parse(schedule.at);
+			if (Number.isNaN(t)) return `非法 at 时间（须 RFC 3339）：${schedule.at}`;
+			if (t <= nowMs) return `at 时间须在未来：${schedule.at}`;
+			return;
+		}
+		case "every": return;
+	}
+}
+/** 下一触发点（epoch ms）；无未来触发点（at 过期等）返回 null。*/
+function nextOccurrence(schedule, createdAtMs, nowMs) {
+	switch (schedule.kind) {
+		case "cron": {
+			const next = new Cron(schedule.expr, cronerOptions(schedule)).nextRun(new Date(nowMs));
+			return next === null ? null : next.getTime();
+		}
+		case "at": {
+			const t = Date.parse(schedule.at);
+			return t > nowMs ? t : null;
+		}
+		case "every": {
+			const intervalMs = schedule.seconds * 1e3;
+			if (nowMs < createdAtMs) return createdAtMs;
+			return createdAtMs + (Math.floor((nowMs - createdAtMs) / intervalMs) + 1) * intervalMs;
+		}
+	}
+}
+/**
+* 启动 rearm：对一条持久化任务重算 enabled/nextRunAt（无变化返回原引用，调用方按引用决定是否写回）。
+* - nextRunAt 仍在未来 → 保持；
+* - 已过期且 catchup → 设为「立即」（首个 tick 补跑一次）；
+* - 已过期且非 catchup → 下一未来触发点；没有（at 一次性）→ enabled=false、nextRunAt=null（过期即作废）。
+*/
+function rearmTask(task, nowMs) {
+	if (!task.enabled) return task.nextRunAt === null ? task : {
+		...task,
+		nextRunAt: null
+	};
+	const persisted = task.nextRunAt === null ? null : Date.parse(task.nextRunAt);
+	if (persisted !== null && persisted > nowMs) return task;
+	if (persisted !== null && task.catchup) return {
+		...task,
+		nextRunAt: new Date(nowMs).toISOString()
+	};
+	const next = nextOccurrence(task.schedule, Date.parse(task.createdAt), nowMs);
+	return next === null ? {
+		...task,
+		enabled: false,
+		nextRunAt: null
+	} : {
+		...task,
+		nextRunAt: new Date(next).toISOString()
+	};
+}
+/** 创建/更新后的 fresh 重算（catchup 是停机补跑语义，不适用于编辑路径）。*/
+function recomputeTask(task, nowMs) {
+	if (!task.enabled) return {
+		...task,
+		nextRunAt: null
+	};
+	const next = nextOccurrence(task.schedule, Date.parse(task.createdAt), nowMs);
+	return next === null ? {
+		...task,
+		enabled: false,
+		nextRunAt: null
+	} : {
+		...task,
+		nextRunAt: new Date(next).toISOString()
+	};
+}
+/** 触发/跳过后推进：cron/every 取 now 之后下一触发点；at 一次性作废。*/
+function advanceAfterTrigger(task, nowMs) {
+	if (task.schedule.kind === "at") return {
+		...task,
+		enabled: false,
+		nextRunAt: null
+	};
+	const next = nextOccurrence(task.schedule, Date.parse(task.createdAt), nowMs);
+	return next === null ? {
+		...task,
+		enabled: false,
+		nextRunAt: null
+	} : {
+		...task,
+		nextRunAt: new Date(next).toISOString()
+	};
+}
+//#endregion
+//#region src/schedule/scheduler.ts
+function createScheduler(deps) {
+	/** 内存重叠锁：同任务上次未结束则本次记 skipped-overlap，不并发执行。 */
+	const running = /* @__PURE__ */ new Set();
+	async function recordSkipped(task) {
+		const nowIso = new Date(deps.now()).toISOString();
+		const run = {
+			id: deps.newRunId(),
+			taskId: task.id,
+			triggeredAt: nowIso,
+			finishedAt: nowIso,
+			status: "skipped-overlap"
+		};
+		await deps.runs.put(run.id, run);
+		await trimRuns(deps.runs, task.id, deps.runHistoryLimit);
+	}
+	function launch(task) {
+		running.add(task.id);
+		deps.execute(task).catch((error) => deps.warn(`[schedule] 任务 "${task.id}" 执行器异常：${error instanceof Error ? error.message : String(error)}`)).finally(() => {
+			running.delete(task.id);
+			const current = deps.tasks.get(task.id);
+			if (current === void 0 || !current.enabled) return;
+			deps.tasks.put(task.id, advanceAfterTrigger(current, deps.now()));
+		});
+	}
+	return {
+		async rearmAll() {
+			for (const [id, task] of deps.tasks.entries()) {
+				const rearmed = rearmTask(task, deps.now());
+				if (rearmed !== task) await deps.tasks.put(id, rearmed);
+			}
+		},
+		async tick() {
+			for (const [, task] of deps.tasks.entries()) {
+				if (!task.enabled || task.nextRunAt === null) continue;
+				if (Date.parse(task.nextRunAt) > deps.now()) continue;
+				if (running.has(task.id)) {
+					await recordSkipped(task);
+					await deps.tasks.put(task.id, advanceAfterTrigger(task, deps.now()));
+					continue;
+				}
+				launch(task);
+			}
+		},
+		recompute: (task) => recomputeTask(task, deps.now()),
+		async triggerManual(taskId) {
+			const task = deps.tasks.get(taskId);
+			if (task === void 0) throw new Error(`定时任务 "${taskId}" 不存在`);
+			if (running.has(taskId)) throw new Error(`定时任务 "${task.name}" 正在运行中，本次手动触发已跳过`);
+			running.add(taskId);
+			try {
+				return await deps.execute(task);
+			} finally {
+				running.delete(taskId);
+			}
+		},
+		isRunning: (taskId) => running.has(taskId)
+	};
+}
+//#endregion
+//#region src/schedule/service.ts
+function createCronService(deps) {
+	/** 创建/更新共用校验：schedule 语法与时值 → cwd → roleId 存在性。 */
+	const validateIO = (input) => {
+		const scheduleError = validateSchedule(input.schedule, deps.now());
+		if (scheduleError !== void 0) return scheduleError;
+		if (!deps.validateProject(input.cwd)) return `项目路径不可用：${input.cwd}`;
+		if (input.target.kind === "role" && deps.registry.get(input.target.roleId) === void 0) return `角色 "${input.target.roleId}" 不存在`;
+	};
+	return {
+		list() {
+			return [...deps.tasks.entries()].map(([, task]) => {
+				const last = listRuns(deps.runs, task.id)[0];
+				return last === void 0 ? task : {
+					...task,
+					lastRun: {
+						status: last.status,
+						triggeredAt: last.triggeredAt
+					}
+				};
+			});
+		},
+		get: (id) => deps.tasks.get(id),
+		async create(input) {
+			const invalid = validateIO(input);
+			if (invalid !== void 0) return {
+				ok: false,
+				error: invalid
+			};
+			const nowIso = new Date(deps.now()).toISOString();
+			const parsed = CronTaskSchema.safeParse({
+				id: deps.newTaskId(),
+				...input,
+				nextRunAt: null,
+				createdAt: nowIso,
+				updatedAt: nowIso
+			});
+			if (!parsed.success) return {
+				ok: false,
+				error: parsed.error.issues[0]?.message ?? "invalid task"
+			};
+			const task = deps.scheduler.recompute(parsed.data);
+			await deps.tasks.put(task.id, task);
+			return {
+				ok: true,
+				value: task
+			};
+		},
+		async update(id, patch) {
+			const existing = deps.tasks.get(id);
+			if (existing === void 0) return {
+				ok: false,
+				error: `定时任务 "${id}" 不存在`
+			};
+			const merged = {
+				...existing,
+				...Object.fromEntries(Object.entries(patch).filter(([, v]) => v !== void 0)),
+				id: existing.id,
+				updatedAt: new Date(deps.now()).toISOString()
+			};
+			const invalid = validateIO(merged);
+			if (invalid !== void 0) return {
+				ok: false,
+				error: invalid
+			};
+			const parsed = CronTaskSchema.safeParse(merged);
+			if (!parsed.success) return {
+				ok: false,
+				error: parsed.error.issues[0]?.message ?? "invalid task"
+			};
+			const task = deps.scheduler.recompute(parsed.data);
+			await deps.tasks.put(id, task);
+			return {
+				ok: true,
+				value: task
+			};
+		},
+		async remove(id) {
+			if (deps.tasks.get(id) === void 0) return {
+				ok: false,
+				error: `定时任务 "${id}" 不存在`
+			};
+			await deps.tasks.delete(id);
+			await deleteRunsOf(deps.runs, id);
+			return {
+				ok: true,
+				value: null
+			};
+		},
+		async trigger(id) {
+			try {
+				return {
+					ok: true,
+					value: await deps.scheduler.triggerManual(id)
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: error instanceof Error ? error.message : String(error)
+				};
+			}
+		},
+		runsOf: (id, limit) => listRuns(deps.runs, id).slice(0, limit)
+	};
+}
+//#endregion
+//#region src/schedule/tools.ts
+/** 互斥探测目标：宿主 @deepseek-ai/dsh-schedule 的会话内提醒工具。 */
+const HOST_SCHEDULE_TOOL = "schedule_create";
+/** 扁平参数 → CronSchedule（缺 kind 对应字段抛错——模型可读的自描述消息）。 */
+function scheduleOf(args) {
+	const kind = args.scheduleKind;
+	if (kind === "cron") {
+		if (typeof args.cronExpr !== "string" || args.cronExpr.trim() === "") throw new Error("scheduleKind=cron 需要 cronExpr（5 字段 cron 表达式）");
+		return {
+			kind: "cron",
+			expr: args.cronExpr,
+			...typeof args.timeZone === "string" && args.timeZone !== "" ? { timeZone: args.timeZone } : {}
+		};
+	}
+	if (kind === "at") {
+		if (typeof args.atTime !== "string" || args.atTime === "") throw new Error("scheduleKind=at 需要 atTime（RFC 3339 时间）");
+		return {
+			kind: "at",
+			at: args.atTime
+		};
+	}
+	if (kind === "every") {
+		if (typeof args.everySeconds !== "number") throw new Error("scheduleKind=every 需要 everySeconds（≥60 的秒数）");
+		return {
+			kind: "every",
+			seconds: args.everySeconds
+		};
+	}
+	throw new Error(`未知 scheduleKind：${String(kind)}（可选 cron / at / every）`);
+}
+function targetOf(args) {
+	if (args.targetKind === "role") {
+		if (typeof args.roleId !== "string" || args.roleId === "") throw new Error("targetKind=role 需要 roleId");
+		return {
+			kind: "role",
+			roleId: args.roleId
+		};
+	}
+	return { kind: "main" };
+}
+/** 服务结果展开：ok:false → 抛错（defineTool 约定：抛错即工具错误结果）。 */
+function unwrap(result) {
+	if (!result.ok) throw new Error(result.error);
+	return result.value;
+}
+const JSON_OUTPUT = {
+	schema: { type: "json" },
+	render: (_args, value) => [{
+		type: "text",
+		text: JSON.stringify(value, null, 2)
+	}]
+};
+const SCHEDULE_PARAMS_REQUIRED = { scheduleKind: {
+	type: "string",
+	required: true,
+	description: "One of: cron / at / every"
+} };
+const SCHEDULE_PARAMS_OPTIONAL = { scheduleKind: {
+	type: "string",
+	description: "Replace schedule kind: cron / at / every (provide the matching fields too)"
+} };
+const SCHEDULE_FIELD_PARAMS = {
+	cronExpr: {
+		type: "string",
+		description: "Required when scheduleKind=cron: 5-field cron expression \"minute hour day-of-month month day-of-week\" (seconds/years not supported)"
+	},
+	timeZone: {
+		type: "string",
+		description: "Optional IANA time zone for cron (e.g. \"Asia/Shanghai\"); default: server process time zone"
+	},
+	atTime: {
+		type: "string",
+		description: "Required when scheduleKind=at: one-shot RFC 3339 time (e.g. \"2026-09-08T09:00:00+08:00\")"
+	},
+	everySeconds: {
+		type: "number",
+		description: "Required when scheduleKind=every: interval seconds (>= 60), anchored at creation time"
+	}
+};
+const TARGET_PARAMS_REQUIRED = { targetKind: {
+	type: "string",
+	required: true,
+	description: "One of: main (main agent, default model) / role (registry role with its persona/model/tool allowlist)"
+} };
+const TARGET_PARAMS_OPTIONAL = { targetKind: {
+	type: "string",
+	description: "Replace target: main / role"
+} };
+const ROLE_ID_PARAM = { roleId: {
+	type: "string",
+	description: "Required when targetKind=role: registry role id"
+} };
+function createCronTools(service) {
+	return [
+		defineTool({
+			name: "cron_task_create",
+			description: "Create a scheduled task that runs a prompt in a NEW standalone session (main agent or a registry role) on a cron/at/every schedule. The task survives restarts; a run missed while stopped is caught up once when catchup=true. Use cron_task_list to see existing tasks.",
+			parameters: {
+				name: {
+					type: "string",
+					required: true,
+					description: "Task name (display)"
+				},
+				prompt: {
+					type: "string",
+					required: true,
+					description: "The prompt sent as the user message when the task fires. Self-contained: the session has no other context."
+				},
+				cwd: {
+					type: "string",
+					required: true,
+					description: "Working directory of the new session (must be a valid project path)"
+				},
+				...SCHEDULE_PARAMS_REQUIRED,
+				...SCHEDULE_FIELD_PARAMS,
+				...TARGET_PARAMS_REQUIRED,
+				...ROLE_ID_PARAM,
+				catchup: {
+					type: "boolean",
+					required: true,
+					description: "true: run once immediately after restart if a run was missed while stopped; false: skip to the next future occurrence"
+				},
+				enabled: {
+					type: "boolean",
+					required: true,
+					description: "false: create paused (nextRunAt stays null until enabled via cron_task_update)"
+				}
+			},
+			output: JSON_OUTPUT,
+			isConcurrencySafe: () => true,
+			async execute(rawArgs) {
+				const args = rawArgs;
+				const input = {
+					name: args.name,
+					prompt: args.prompt,
+					cwd: args.cwd,
+					schedule: scheduleOf(args),
+					target: targetOf(args),
+					catchup: args.catchup,
+					enabled: args.enabled
+				};
+				return unwrap(await service.create(input));
+			}
+		}),
+		defineTool({
+			name: "cron_task_list",
+			description: "List all scheduled tasks with enabled flag, next run time and last run status.",
+			parameters: {},
+			output: JSON_OUTPUT,
+			isConcurrencySafe: () => true,
+			async execute() {
+				return service.list();
+			}
+		}),
+		defineTool({
+			name: "cron_task_update",
+			description: "Update any fields of a scheduled task by id. nextRunAt is recomputed.",
+			parameters: {
+				id: {
+					type: "string",
+					required: true,
+					description: "Task id"
+				},
+				name: {
+					type: "string",
+					description: "New name"
+				},
+				prompt: {
+					type: "string",
+					description: "New prompt"
+				},
+				cwd: {
+					type: "string",
+					description: "New working directory"
+				},
+				...SCHEDULE_PARAMS_OPTIONAL,
+				...SCHEDULE_FIELD_PARAMS,
+				...TARGET_PARAMS_OPTIONAL,
+				...ROLE_ID_PARAM,
+				catchup: {
+					type: "boolean",
+					description: "New catchup flag"
+				},
+				enabled: {
+					type: "boolean",
+					description: "Enable/disable the task"
+				}
+			},
+			output: JSON_OUTPUT,
+			isConcurrencySafe: () => true,
+			async execute(rawArgs) {
+				const args = rawArgs;
+				const patch = {};
+				if (args.name !== void 0) patch.name = args.name;
+				if (args.prompt !== void 0) patch.prompt = args.prompt;
+				if (args.cwd !== void 0) patch.cwd = args.cwd;
+				if (args.scheduleKind !== void 0) patch.schedule = scheduleOf(args);
+				if (args.targetKind !== void 0) patch.target = targetOf(args);
+				if (args.catchup !== void 0) patch.catchup = args.catchup;
+				if (args.enabled !== void 0) patch.enabled = args.enabled;
+				return unwrap(await service.update(args.id, patch));
+			}
+		}),
+		defineTool({
+			name: "cron_task_delete",
+			description: "Delete a scheduled task by id, including its run history.",
+			parameters: { id: {
+				type: "string",
+				required: true,
+				description: "Task id"
+			} },
+			output: JSON_OUTPUT,
+			isConcurrencySafe: () => true,
+			async execute(rawArgs) {
+				return unwrap(await service.remove(rawArgs.id));
+			}
+		}),
+		defineTool({
+			name: "cron_task_trigger",
+			description: "Trigger a scheduled task once right now (works even when disabled; fails with an error if the task is already running).",
+			parameters: { id: {
+				type: "string",
+				required: true,
+				description: "Task id"
+			} },
+			output: JSON_OUTPUT,
+			isConcurrencySafe: () => true,
+			async execute(rawArgs) {
+				return unwrap(await service.trigger(rawArgs.id));
+			}
+		})
+	];
+}
+/**
+* 注册 cron_* 工具到主 Agent scope 并探测宿主 schedule 互斥（spec §1/§5）。
+* 门控：跳过 subagent（session.header.origin === 'subagent'）与插件自有会话（ownedSessions：
+* bot/schedule 会话）——dsh-schedule src/index.ts:45-49 同款 agent/created 模式，
+* 外加存量 roots 立即注册（HMR 重挂后当前主会话不丢工具）。
+* HMR 安全：镜像 dsh-schedule src/index.ts:44-76——attached 身份表防同一 agent 二次挂载，
+* toolkit 级 ctx.effect 卸载时 Promise.allSettled 摘下所有 agent 上挂的工具
+* （agent.ctx 属宿主、长于 toolkit fiber，仅靠 agent.ctx.effect 会在重挂时残留）。
+*/
+function setupCronTools(ctx, tools, ownedSessions) {
+	const attached = /* @__PURE__ */ new Map();
+	let stopping = false;
+	ctx.effect(() => {
+		const stopCreated = ctx.on("agent/created", ({ agent }) => {
+			if (stopping || attached.has(agent)) return;
+			attach(agent);
+		});
+		for (const agent of ctx.agents.roots()) attach(agent);
+		return async () => {
+			stopping = true;
+			stopCreated();
+			const cleanups = [...attached.values()];
+			attached.clear();
+			await Promise.allSettled(cleanups.map((cleanup) => Promise.resolve(cleanup())));
+		};
+	}, "dsh-agent-toolkit.cron-tools()");
+	function attach(agent) {
+		if (attached.has(agent)) return;
+		if (agent.session.header.origin === "subagent") return;
+		if (ownedSessions.has(String(agent.session.id))) return;
+		const cleanup = agent.ctx.effect(() => {
+			const scope = scopeOf(agent.ctx);
+			if (scope !== void 0 ? ctx.tools.get(HOST_SCHEDULE_TOOL, scope) !== void 0 : ctx.tools.get(HOST_SCHEDULE_TOOL) !== void 0) ctx.logger.warn("dsh-agent-toolkit: 检测到宿主 @deepseek-ai/dsh-schedule 的 schedule_create 与 cron_* 并存——两套调度工具并存会显著提高模型误选率，且会话内提醒在会话冷时静默失败；请从组合中移除 @deepseek-ai/dsh-schedule（二选一）");
+			const disposers = tools.map((tool) => agent.ctx.tools.register(tool));
+			return () => {
+				for (const dispose of disposers) dispose();
+				if (attached.get(agent) === cleanup) attached.delete(agent);
+			};
+		}, "dsh-agent-toolkit.cron-tools.attach()");
+		attached.set(agent, cleanup);
+	}
+}
+//#endregion
+//#region src/schedule/index.ts
+/** schedule 模块接线：存储域 → executor/scheduler/service → cron_* 工具 + HTTP API + 30s tick。 */
+/** tick 间隔固定 30s（spec §8：不进 Config——YAGNI）。 */
+const TICK_MS = 3e4;
+function setupSchedule(ctx, config, deps) {
+	const warn = (m) => ctx.logger.warn(m);
+	const toolsScope = createToolsScope(ctx);
+	const agentsPort = createAgentsPort(ctx, deps.botPresetId !== void 0 ? createScopeJoiner(ctx, deps.botPresetId, toolsScope, warn) : toolsScope, deps.ownedSessions);
+	const workspaceRegistryOf = () => ctx.get("workspaceRegistry", false);
+	const workspacePort = { async attach(cwd, sessionId) {
+		const registry = workspaceRegistryOf();
+		if (registry === void 0) throw new Error("workspaceRegistry 服务不可用");
+		await (await registry.create(cwd)).attachSession(SessionId(sessionId));
+	} };
+	let scheduler;
+	const started = openDomainSafely(ctx, scheduleDomain, warn).then(async (domain) => {
+		const tasks = domain.table("tasks");
+		const runs = domain.table("runs");
+		const executor = createExecutor({
+			agents: agentsPort,
+			registry: deps.registry,
+			defaultModel: () => {
+				const selection = ctx.agentDefaultModel.currentSelection();
+				return {
+					provider: selection.provider,
+					model: selection.model
+				};
+			},
+			workspace: workspacePort,
+			runs,
+			runHistoryLimit: config.runHistoryLimit,
+			runTimeoutMs: config.runTimeoutMinutes * 6e4,
+			warn,
+			now: () => Date.now(),
+			newSessionId: () => randomUUID(),
+			newRunId: () => randomUUID(),
+			delay: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+		});
+		scheduler = createScheduler({
+			tasks,
+			runs,
+			runHistoryLimit: config.runHistoryLimit,
+			execute: (task) => executor.trigger(task),
+			now: () => Date.now(),
+			newRunId: () => randomUUID(),
+			warn
+		});
+		const service = createCronService({
+			tasks,
+			runs,
+			scheduler,
+			registry: deps.registry,
+			validateProject: (path) => existsSync(path),
+			now: () => Date.now(),
+			newTaskId: () => randomUUID()
+		});
+		setupCronTools(ctx, createCronTools(service), deps.ownedSessions);
+		registerOptionalRoutes(ctx, (webCtx) => {
+			const dispose = webCtx.webServer.register({
+				kind: "prefix",
+				path: "/dsh-agent-toolkit/api/cron",
+				handler: async (req, res) => {
+					try {
+						await started;
+						await createCronApiHandler({
+							service,
+							listProjects: () => workspaceRegistryOf()?.list().map((w) => w.path) ?? [],
+							runHistoryLimit: config.runHistoryLimit
+						})(req, res);
+					} catch (error) {
+						res.writeHead(500, { "content-type": "application/json" }).end(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+					}
+				}
+			});
+			return () => dispose();
+		});
+		await scheduler.rearmAll();
+	});
+	started.catch((error) => {
+		warn(`[schedule] 启动失败：${error instanceof Error ? error.message : String(error)}`);
+	});
+	ctx.effect(() => {
+		const timer = setInterval(() => {
+			started.then(() => scheduler?.tick());
+		}, TICK_MS);
+		return () => clearInterval(timer);
+	});
+	ctx.effect(() => async () => {
+		await toolsScope.dispose();
+	});
 }
 //#endregion
 //#region src/index.ts
@@ -3594,33 +5192,46 @@ const Config = z.object({
 	toolName: z.string().default("team_delegate"),
 	feishu: z.object({
 		cardUpdateThrottleMs: z.number().default(500),
-		cardMaxBytes: z.number().default(28e3),
+		cardMaxBytes: z.number().default(26e3),
+		cardPrintStep: z.number().default(5),
 		processMaxBytes: z.number().default(8e3),
 		registerAppTimeoutMs: z.number().default(6e5),
 		processingReactionEmoji: z.string().default("OneSecond"),
 		errorDetailMaxChars: z.number().default(500),
-		injectSender: z.boolean().default(true)
+		injectSender: z.boolean().default(true),
+		approval: z.boolean().default(true)
 	}).default({
 		cardUpdateThrottleMs: 500,
-		cardMaxBytes: 28e3,
+		cardMaxBytes: 26e3,
+		cardPrintStep: 5,
 		processMaxBytes: 8e3,
 		registerAppTimeoutMs: 6e5,
 		processingReactionEmoji: "OneSecond",
 		errorDetailMaxChars: 500,
-		injectSender: true
+		injectSender: true,
+		approval: true
 	}),
 	agentTeamPreset: z.object({
 		enabled: z.boolean().default(true),
 		id: z.string().default("agent-team"),
 		source: z.string().default("standard"),
 		name: z.string().default("Agent 团队"),
-		description: z.string().default("Agent 团队模式：禁用原生 subagent 工具族，委派统一走 team_delegate 团队角色")
+		description: z.string().default("Agent 团队模式：禁用原生 subagent 工具族，委派统一走 team_delegate 团队角色"),
+		botsId: z.string().default("agent-bot")
 	}).default({
 		enabled: true,
 		id: "agent-team",
 		source: "standard",
 		name: "Agent 团队",
-		description: "Agent 团队模式：禁用原生 subagent 工具族，委派统一走 team_delegate 团队角色"
+		description: "Agent 团队模式：禁用原生 subagent 工具族，委派统一走 team_delegate 团队角色",
+		botsId: "agent-bot"
+	}),
+	schedule: z.object({
+		runTimeoutMinutes: z.number().min(1).default(60),
+		runHistoryLimit: z.natural().min(1).default(20)
+	}).default({
+		runTimeoutMinutes: 60,
+		runHistoryLimit: 20
 	})
 });
 async function apply(ctx, config) {
@@ -3635,10 +5246,12 @@ async function apply(ctx, config) {
 		meta: domain.table("meta"),
 		promptLayers: domain.table("prompt_layers")
 	};
+	await setupAgentTeamPreset(ctx, config.agentTeamPreset);
+	const toolCatalog = createToolCatalog(ctx, config.agentTeamPreset.id);
 	const registry = await createRegistry(warn, {
 		agents: tables.agents,
 		meta: tables.meta
-	});
+	}, toolCatalog.listPresetTools);
 	const layerSource = await openLayerSource({
 		promptLayers: tables.promptLayers,
 		meta: tables.meta
@@ -3667,10 +5280,10 @@ async function apply(ctx, config) {
 		active: activeRoutes,
 		routes: routesTable
 	});
-	const listTools = () => ctx.tools.schemas().map((s) => s.name);
 	setupAgentsApi(ctx, {
 		registry,
-		listTools,
+		listTools: toolCatalog.listGlobalTools,
+		listPresetTools: toolCatalog.listPresetTools,
 		listProviders: () => ctx.llm.listProviders().map(({ id, name }) => ({
 			id,
 			name
@@ -3682,7 +5295,8 @@ async function apply(ctx, config) {
 	});
 	setupCreateAgentCommand(ctx, {
 		registry,
-		listTools
+		listTools: toolCatalog.listGlobalTools,
+		listPresetTools: toolCatalog.listPresetTools
 	});
 	setupPromptLayersApi(ctx, {
 		source: layerSource,
@@ -3702,9 +5316,18 @@ async function apply(ctx, config) {
 			};
 		}
 	});
-	await setupAgentTeamPreset(ctx, config.agentTeamPreset);
-	if (config.modules.feishu) setupBots(ctx, config.feishu, { registry });
+	const ownedSessions = /* @__PURE__ */ new Set();
+	if (config.modules.feishu) setupBots(ctx, config.feishu, {
+		registry,
+		botPresetId: config.agentTeamPreset.enabled ? config.agentTeamPreset.botsId : void 0,
+		ownedSessions
+	});
 	if (config.modules.usage) setupUsage(ctx, { timezone: config.timezone }, name);
+	setupSchedule(ctx, config.schedule, {
+		registry,
+		botPresetId: config.agentTeamPreset.enabled ? config.agentTeamPreset.botsId : void 0,
+		ownedSessions
+	});
 }
 //#endregion
 export { Config, apply, inject, name };