dsh-agent-toolkit 0.1.0

package/lib/index.js

@@ -0,0 +1,3151 @@
+import z from "@deepseek-ai/schemastery";
+import { z as z$1 } from "zod";
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import yaml from "js-yaml";
+import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+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 { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { randomBytes, randomUUID } from "node:crypto";
+import { setupUsage } from "@dsh-agent-toolkit/token-usage";
+//#region src/agents/store.ts
+/** agents 注册表存储域声明：记录 schema + domain 布局的单一来源。 */
+/** Agent id 约束：'main' 或小写字母开头、仅 [a-z0-9-]、总长 ≤ 32。 */
+const AGENT_ID_RE = /^(?:main|[a-z][a-z0-9-]{0,31})$/;
+const LayerConfigSchema = z$1.object({
+	name: z$1.string(),
+	order: z$1.number(),
+	text: z$1.string()
+});
+const AgentRecordSchema = z$1.object({
+	id: z$1.string().regex(AGENT_ID_RE),
+	name: z$1.string().min(1),
+	description: z$1.string().optional(),
+	persona: z$1.string().optional(),
+	promptLayers: z$1.array(LayerConfigSchema).optional(),
+	model: z$1.object({
+		provider: z$1.string(),
+		model: z$1.string()
+	}).optional(),
+	tools: z$1.object({ allow: z$1.array(z$1.string()).min(1) }).optional(),
+	builtin: z$1.boolean().optional()
+});
+/** domain 名/表名受 UNIT_NAME_RE 约束（^[a-z][a-z0-9_]*$），不允许连字符。 */
+const agentToolkitDomain = defineDomain({
+	name: "dsh_agent_toolkit",
+	version: 1,
+	tables: {
+		agents: domainTable(AgentRecordSchema),
+		meta: domainTable(z$1.object({ value: z$1.string() })),
+		prompt_layers: domainTable(z$1.object({ layers: z$1.array(LayerConfigSchema) }))
+	}
+});
+/**
+* 旧记录迁移：promptLayers 按 order 升序拼接进 persona（忽略纯空白层；persona 已存在不覆盖），
+* 剥离 promptLayers 返回新对象；无需迁移返回原引用（调用方按引用比较决定是否写回）。
+*/
+function migrateAgentRecord(record) {
+	if (record.promptLayers === void 0) return record;
+	const { promptLayers, ...rest } = record;
+	const joined = [...promptLayers].sort((a, b) => a.order - b.order).map((layer) => layer.text).filter((text) => text.trim().length > 0).join("\n\n");
+	const persona = rest.persona ?? joined;
+	return persona.length > 0 ? {
+		...rest,
+		persona
+	} : rest;
+}
+//#endregion
+//#region src/agents/builtin.ts
+const BUILTIN_AGENTS = [
+	{
+		id: "main",
+		name: "主 Agent",
+		builtin: true
+	},
+	{
+		id: "explorer",
+		name: "Explorer",
+		description: "快速只读代码库探索：定位文件/符号、回答结构与调用关系问题，不做任何修改",
+		persona: `你是代码库探索员。快速定位与任务相关的文件与符号，回答关于代码结构、
+调用关系、实现位置的问题。你只读不写：不修改任何文件、不运行有副作用的命令。
+输出结论清单，每条附文件路径与行号；信息不足时说明缺口，不要猜测。`,
+		builtin: true
+	},
+	{
+		id: "general",
+		name: "General",
+		description: "通用多步骤任务执行：可读可写、可运行命令，完成实现/修复类任务",
+		persona: `你是通用执行员。按任务书独立完成多步骤工作，可以读写文件、运行命令。
+动手前先阅读相关 AGENTS.md 并遵循项目约定；完成后运行与改动相关的检查
+（测试/类型检查）验证改动，并在最终输出中报告验证结果。`,
+		builtin: true
+	}
+];
+//#endregion
+//#region src/agents/import-yaml.ts
+/** 首启导入：把旧 agent-team 角色名册 $DSH_HOME/agent-team/roles/*.yml 一次性并入注册表。 */
+/** 导入一次性标记在 meta 表中的键。 */
+const ROLES_YAML_IMPORTED_KEY = "roles_yaml_imported";
+const RoleYamlSchema = z$1.object({
+	name: z$1.string().optional(),
+	description: z$1.string().min(1),
+	persona: z$1.string().min(1),
+	provider: z$1.string().optional(),
+	model: z$1.string().optional(),
+	tools: z$1.object({
+		allow: z$1.array(z$1.string()).optional(),
+		deny: z$1.array(z$1.string()).optional()
+	}).optional()
+});
+/**
+* 解析校验单个角色 YAML 文件并转成 AgentRecord。
+* @param text - 文件内容。
+* @param source - 用于错误信息的来源名（通常是文件路径）。
+* @param fileName - 文件名（去 .yml），name 省略时的取值；显式 name 须与它一致。
+* @param warn - 非致命丢弃（如 tools.deny）的通知通道。
+* @throws YAML 语法错误、结构非法、name 与文件名不一致、id 非法、tools 空。
+*/
+function parseRoleYaml(text, source, fileName, warn) {
+	let parsed;
+	try {
+		parsed = yaml.load(text);
+	} catch (error) {
+		throw new Error(`dsh-agent-toolkit: 角色文件 ${source} 不是合法 YAML：${error instanceof Error ? error.message : String(error)}`);
+	}
+	const hasTools = parsed !== null && typeof parsed === "object" && "tools" in parsed;
+	let raw;
+	try {
+		raw = RoleYamlSchema.parse(parsed);
+	} catch (error) {
+		throw new Error(`dsh-agent-toolkit: 角色文件 ${source} 校验失败：${error instanceof Error ? error.message : String(error)}`);
+	}
+	const id = raw.name ?? fileName;
+	if (raw.name !== void 0 && raw.name !== fileName) throw new Error(`dsh-agent-toolkit: 角色文件 ${source} 的 name "${raw.name}" 与文件名 "${fileName}" 不一致（省略 name 即取文件名）`);
+	if (!AGENT_ID_RE.test(id)) throw new Error(`dsh-agent-toolkit: 角色 id "${id}" 非法（${source}）：只允许小写字母、数字、-，且以小写字母开头`);
+	if (hasTools && raw.tools !== void 0 && (raw.tools.allow?.length ?? 0) === 0 && (raw.tools.deny?.length ?? 0) === 0) throw new Error(`dsh-agent-toolkit: 角色文件 ${source} 的 tools 为空：allow/deny 至少配一个`);
+	if (raw.tools?.deny !== void 0 && raw.tools.deny.length > 0) warn?.(`dsh-agent-toolkit: 角色文件 ${source} 的 tools.deny 已忽略（注册表仅支持 allow 白名单）`);
+	const model = raw.provider !== void 0 && raw.model !== void 0 ? {
+		provider: raw.provider,
+		model: raw.model
+	} : void 0;
+	const tools = hasTools && raw.tools !== void 0 && raw.tools.allow !== void 0 && raw.tools.allow.length > 0 ? { allow: raw.tools.allow } : void 0;
+	return {
+		id,
+		name: id,
+		description: raw.description,
+		persona: raw.persona,
+		...model !== void 0 ? { model } : {},
+		...tools !== void 0 ? { tools } : {}
+	};
+}
+/**
+* 枚举 roles 目录下全部 .yml 角色文件，按文件名字典序返回。
+* 共享骨架（readdir/ENOENT/过滤/排序/文件名推导）——YAML 文件命名约定只在这里维护。
+* @param dir - roles 目录绝对路径。
+* @returns 文件引用列表；目录不存在或无 .yml 文件时返回空列表（静默跳过，属正常态）。
+* @throws 目录存在但不可读（非 ENOENT）。读取/解析的严格与宽容由调用方自行处理。
+*/
+async function enumerateRoleFiles(dir) {
+	let entries;
+	try {
+		entries = await readdir(dir);
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw new Error(`dsh-agent-toolkit: 角色目录不可读：${dir}（${error instanceof Error ? error.message : String(error)}）`);
+	}
+	return entries.filter((f) => f.endsWith(".yml")).sort().map((file) => ({
+		name: file,
+		path: join(dir, file),
+		fileName: file.slice(0, -4)
+	}));
+}
+/**
+* 首启一次性导入：meta 表 roles_yaml_imported 标记短路；逐文件解析失败 warn 跳过（不阻塞激活）；
+* 同名 YAML 覆盖内置保底记录。
+* @param ctx - agents/meta 表句柄与 warn 通道。
+* @param rolesDir - roles 目录；缺省为 $DSH_HOME/agent-team/roles。
+*/
+async function importRolesYaml(ctx, rolesDir) {
+	const result = {
+		imported: 0,
+		skipped: []
+	};
+	if (ctx.meta.get("roles_yaml_imported") !== void 0) return result;
+	const dir = rolesDir ?? join(resolveDshHome(), "agent-team", "roles");
+	let refs;
+	try {
+		refs = await enumerateRoleFiles(dir);
+	} catch (error) {
+		ctx.warn(error instanceof Error ? error.message : String(error));
+		await markImported(ctx);
+		return result;
+	}
+	for (const ref of refs) try {
+		const record = parseRoleYaml(await readFile(ref.path, "utf8"), ref.path, ref.fileName, ctx.warn);
+		await ctx.agents.put(record.id, record);
+		result.imported++;
+	} catch (error) {
+		result.skipped.push(ref.name);
+		ctx.warn(`dsh-agent-toolkit: 角色文件 ${ref.path} 导入失败，已跳过：${error instanceof Error ? error.message : String(error)}`);
+	}
+	await markImported(ctx);
+	return result;
+}
+async function markImported(ctx) {
+	await ctx.meta.put(ROLES_YAML_IMPORTED_KEY, { value: "1" });
+}
+//#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}}." }
+	},
+	{
+		id: "@deepseek-ai/dsh-agent-instructions",
+		config: { maxBytes: 65536 }
+	},
+	...process.platform === "win32" ? [{ id: "@deepseek-ai/dsh-tool-pwsh" }] : [{ id: "@deepseek-ai/dsh-tool-bash" }],
+	{ id: "@deepseek-ai/dsh-tool-fs" },
+	{
+		id: "@deepseek-ai/dsh-tool-fs-search",
+		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()，故需显式常量。 */
+const NATIVE_TOOL_NAMES = [
+	process.platform === "win32" ? "pwsh" : "bash",
+	"read",
+	"write",
+	"edit",
+	"read_image",
+	"glob",
+	"grep"
+];
+//#endregion
+//#region src/agents/registry.ts
+/** tools.allow 一次性并入原生工具名的 meta 表标记键。 */
+const TOOLS_NATIVE_MIGRATED_KEY = "tools_native_migrated";
+/**
+* 打开 dsh_agent_toolkit 域 → 缺 main/explorer/general 时种入内置 → 首启 YAML 导入 →
+* 构建内存缓存。域由 apply 统一 open（storage-domain 同名单开），此处只消费表句柄。
+*/
+async function createRegistry(warn, tables) {
+	const { agents, meta } = tables;
+	await seedBuiltins(agents);
+	await importRolesYaml({
+		agents,
+		meta,
+		warn
+	});
+	const nativeMigrated = meta.get(TOOLS_NATIVE_MIGRATED_KEY) !== void 0;
+	for (const [id, record] of agents.entries()) {
+		let next = migrateAgentRecord(record);
+		if (!nativeMigrated && next.tools !== void 0) {
+			const allow = next.tools.allow;
+			const missing = NATIVE_TOOL_NAMES.filter((name) => !allow.includes(name));
+			if (missing.length > 0) next = {
+				...next,
+				tools: { allow: [...allow, ...missing] }
+			};
+		}
+		if (next !== record) await agents.put(id, next);
+	}
+	if (!nativeMigrated) await meta.put(TOOLS_NATIVE_MIGRATED_KEY, { value: "1" });
+	const cache = /* @__PURE__ */ new Map();
+	for (const [id, record] of agents.entries()) cache.set(id, record);
+	const listeners = /* @__PURE__ */ new Set();
+	const notify = () => {
+		for (const listener of [...listeners]) listener();
+	};
+	return {
+		list() {
+			const main = cache.get("main");
+			const rest = [...cache.entries()].filter(([id]) => id !== "main").map(([, record]) => record).sort((a, b) => a.id.localeCompare(b.id));
+			return main === void 0 ? rest : [main, ...rest];
+		},
+		get(id) {
+			return cache.get(id);
+		},
+		async upsert(record) {
+			const parsed = AgentRecordSchema.safeParse(record);
+			if (!parsed.success) throw new Error(`dsh-agent-toolkit: Agent 记录校验失败：${parsed.error.message}`);
+			const normalized = migrateAgentRecord(parsed.data);
+			const existing = cache.get(record.id);
+			if (record.id === "main" && existing !== void 0) {
+				if (existing.name !== record.name || existing.builtin !== record.builtin) throw new Error("dsh-agent-toolkit: 主 Agent（main）的 name/builtin 字段不可修改");
+			}
+			if (existing?.builtin === true && record.builtin !== true) throw new Error(`dsh-agent-toolkit: 内置角色 ${record.id} 的 builtin 标记不可修改`);
+			await agents.put(record.id, normalized);
+			cache.set(record.id, normalized);
+			notify();
+		},
+		async remove(id) {
+			if (id === "main") throw new Error("dsh-agent-toolkit: 主 Agent（main）不可删除");
+			if (cache.get(id)?.builtin === true) throw new Error(`dsh-agent-toolkit: 内置角色 ${id} 不可删除`);
+			if (await agents.delete(id)) {
+				cache.delete(id);
+				notify();
+			}
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+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/shared/storage.ts
+function openDomainSafely(ctx, domain, warn, beforeClose) {
+	const ready = ctx.storageDomain.open(domain);
+	ready.catch((error) => {
+		warn(error instanceof Error ? error.message : String(error));
+	});
+	ctx.effect(() => async () => {
+		await Promise.resolve(beforeClose?.()).catch(() => void 0);
+		await ready.then((domain) => domain.close()).catch(() => void 0);
+	});
+	return ready;
+}
+//#endregion
+//#region src/prompt/defaults.ts
+/** 通用基座层文本（default.txt 改写版）。 */
+const BASE_TEXT = `IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.
+
+# Tone and style
+You should be concise, direct, and to the point. When you run a non-trivial shell command, explain what the command does and why you are running it, so the user understands what you are doing (this is especially important when the command changes the user's system).
+Your output will be displayed on a command line interface. You can use GitHub-flavored markdown for formatting; it will be rendered in a monospace font using the CommonMark specification.
+Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools or code comments as a means to communicate with the user during the session.
+If you cannot or will not help the user with something, do not preach about why or what it could lead to. Offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences.
+Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
+IMPORTANT: Minimize output tokens as much as possible while maintaining helpfulness, quality, and accuracy. Only address the specific query or task at hand, avoiding tangential information unless absolutely critical. If you can answer in 1-3 sentences or a short paragraph, please do.
+IMPORTANT: Do not answer with unnecessary preamble or postamble (such as explaining your code or summarizing your actions) unless the user asks you to.
+Keep responses short: answer the user's question directly, without elaboration. Avoid introductions, conclusions, and restatements such as "The answer is ..." or "Here is what I will do next ...".
+<example>
+user: what is 2+2?
+assistant: 4
+</example>
+
+<example>
+user: what files are in the directory src/?
+assistant: [lists files and sees foo.c, bar.c, baz.c]
+user: which file contains the implementation of foo?
+assistant: src/foo.c
+</example>
+
+# Proactiveness
+Be proactive only when the user asks you to do something. Strike a balance between:
+1. Doing the right thing when asked, including follow-up actions the request implies.
+2. Not surprising the user with actions taken without asking.
+If the user asks how to approach something, answer the question first instead of immediately jumping into action.
+Do not add a code-explanation summary unless requested. After working on a file, just stop.
+
+# Following conventions
+When making changes to files, first understand the file's code conventions. Mimic code style, use existing libraries and utilities, and follow existing patterns.
+- NEVER assume that a given library is available, even if it is well known. Whenever you write code that uses a library or framework, first check that this codebase already uses it (neighboring files, package manifests such as package.json or cargo.toml).
+- When you create a new component, first look at existing components: framework choice, naming conventions, typing, and other conventions.
+- When you edit a piece of code, read its surrounding context (especially its imports) and make the change idiomatic to it.
+- Always follow security best practices. Never introduce code that exposes or logs secrets and keys. Never commit secrets or keys to the repository.
+
+# Code style
+- IMPORTANT: DO NOT ADD ***ANY*** COMMENTS unless asked.
+
+# Doing tasks
+For software engineering tasks (fixing bugs, adding features, refactoring, explaining code, and more):
+- Use the available search tools extensively, in parallel and sequentially, to understand the codebase and the user's query.
+- Implement the solution using all tools available to you.
+- Verify the solution with tests where possible. NEVER assume a specific test framework or test script; check the README or search the codebase to determine the testing approach.
+- When you have completed a task, run the project's lint and typecheck commands if they exist. If you cannot find the correct command, ask the user for it.
+- NEVER commit changes unless the user explicitly asks you to.
+
+Tool results and user messages may include <system-reminder> tags. They contain useful information and reminders. They are NOT part of the user's provided input or the tool result.
+
+# Tool usage policy
+- For file or content search, prefer dedicated search tools over shell commands to reduce context usage.
+- You can call multiple tools in a single response. Batch independent calls together for optimal performance; run dependent calls sequentially.
+
+Before you begin work, think about what the code you are editing is supposed to do, based on filenames and directory structure.
+
+# Code references
+When referencing specific functions or pieces of code, use the pattern \`file_path:line_number\` so the user can easily navigate to the source location.`;
+/** 模型族行为指导文本（anthropic/gemini/beast/codex/gpt/kimi 改写版，
+*  内容按下文"6 个模型族 TEXT 的改写契约"逐条产出，英文，不写身份首句）。 */
+const ANTHROPIC_TEXT = `IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.
+
+# Tone and style
+- Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
+- Your output will be displayed on a command line interface. Your responses should be short and concise. You can use GitHub-flavored markdown for formatting, and it will be rendered in a monospace font using the CommonMark specification.
+- Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use shell commands or code comments as a means to communicate with the user during the session.
+- NEVER create files unless they are absolutely necessary for achieving your goal. ALWAYS prefer editing an existing file to creating a new one.
+
+# Professional objectivity
+Prioritize technical accuracy and truthfulness over validating the user's beliefs. Focus on facts and problem-solving, providing direct, objective technical information without unnecessary superlatives, praise, or emotional validation. Apply the same rigorous standards to all ideas and disagree when necessary, even if it may not be what the user wants to hear. Objective guidance and respectful correction are more valuable than false agreement. Whenever there is uncertainty, investigate to find the truth first rather than instinctively confirming the user's beliefs.
+
+# Planning and tracking
+Use a task list frequently to plan and track your work, giving the user visibility into your progress. These lists are also helpful for breaking down larger, complex tasks into smaller steps. Mark each task as completed as soon as you are done; do not batch up multiple tasks before marking them completed.
+
+# Doing tasks
+The user will primarily request software engineering tasks: fixing bugs, adding new functionality, refactoring code, explaining code, and more. Search the codebase to understand the user's query, implement the solution using all tools available to you, then verify it. Tool results and user messages may include <system-reminder> tags. They contain useful information and reminders; they are authoritative and are NOT part of the user's provided input or the tool result.
+
+# Tool usage policy
+- For file or content search, prefer dedicated search tools over shell commands to reduce context usage.
+- Prefer dedicated editing tools over shell for modifying files.
+- You can call multiple tools in a single response. Make all independent tool calls in parallel; run dependent calls sequentially. Never use placeholders or guess missing parameters in tool calls.
+
+# Code references
+When referencing specific functions or pieces of code, use the pattern \`file_path:line_number\` so the user can easily navigate to the source location.`;
+const GEMINI_TEXT = `# Core Mandates
+
+- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
+- **Libraries/Frameworks:** NEVER assume a library or framework is available or appropriate. Verify its established usage within the project (check imports and configuration files, or observe neighboring files) before employing it.
+- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
+- **Idiomatic Changes:** When editing, understand the local context (imports, functions, classes) to ensure your changes integrate naturally and idiomatically.
+- **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments.
+- **Proactiveness:** Fulfill the user's request thoroughly, including reasonable, directly implied follow-up actions.
+- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user. If asked *how* to do something, explain first; do not just do it.
+- **Explaining Changes:** After completing a code modification or file operation, do not provide summaries unless asked.
+- **Path Construction:** Before using any file system tool, construct the full absolute path for the file argument. Always combine the absolute path of the project root with the file's path relative to the root. If the user provides a relative path, resolve it against the root to create an absolute path.
+- **Do Not Revert Changes:** Do not revert changes to the codebase unless asked to do so by the user. Only revert changes made by you if they resulted in an error or if the user has explicitly asked you to revert them.
+
+# Primary Workflows
+
+## Software Engineering Tasks
+When requested to fix bugs, add features, refactor, or explain code, follow this sequence:
+1. **Understand:** Think about the request and the relevant codebase context. Search extensively (in parallel if independent) to understand file structures, existing patterns, and conventions. Read to validate any assumptions.
+2. **Plan:** Build a coherent, grounded plan for how you intend to resolve the task. Share an extremely concise yet clear plan with the user if it would help. Use a self-verification loop by writing unit tests where relevant; use output logs or debug statements as part of this loop to arrive at a solution.
+3. **Implement:** Act on the plan using available tools, strictly adhering to the project's established conventions.
+4. **Verify (Tests):** If applicable and feasible, verify the changes using the project's testing procedures. Identify the correct test commands and frameworks by examining README files and build or package configuration; NEVER assume standard test commands.
+5. **Verify (Standards):** After making code changes, execute the project-specific build, lint, and type-checking commands you have identified. If unsure about these commands, ask the user.
+
+## New Applications
+Autonomously implement and deliver a visually appealing, substantially complete, functional prototype:
+1. **Understand Requirements:** Analyze the request to identify core features, desired user experience, visual aesthetic, application type and platform, and explicit constraints. If critical information for planning is missing or ambiguous, ask concise, targeted clarification questions.
+2. **Propose Plan:** Formulate an internal development plan and present a clear, concise summary covering the application's type and core purpose, key technologies, main features, interaction model, and the approach to a polished visual design and user experience.
+3. **User Approval:** Obtain user approval for the proposed plan before implementing.
+4. **Implementation:** Autonomously implement each feature and design element per the approved plan. Use placeholder assets only when essential for progress, intending to replace them with more refined versions or instructing the user on replacement during polishing.
+5. **Verify:** Review work against the original request and approved plan. Fix bugs, deviations, and placeholders where feasible. Build the application and ensure there are no compile errors.
+6. **Solicit Feedback:** Provide instructions on how to start the application and request user feedback.
+
+# Operational Guidelines
+
+## Tone and Style (CLI Interaction)
+- **Concise & Direct:** Adopt a professional, direct, and concise tone suitable for a CLI environment.
+- **Minimal Output:** Aim for fewer than 3 lines of text output (excluding tool use and code generation) per response whenever practical. Focus strictly on the user's query.
+- **Clarity over Brevity (When Needed):** While conciseness is key, prioritize clarity for essential explanations or when seeking necessary clarification.
+- **No Chitchat:** Avoid conversational filler, preambles, or postambles. Get straight to the action or answer.
+- **Formatting:** Use GitHub-flavored Markdown. Responses will be rendered in monospace.
+- **Tools vs. Text:** Use tools for actions; text output only for communication. Do not add explanatory comments within tool calls or code blocks unless specifically part of the required code.
+- **Handling Inability:** If unable or unwilling to fulfill a request, state so briefly (1-2 sentences) without excessive justification. Offer alternatives if appropriate.
+
+## Security and Safety Rules
+- **Explain Critical Commands:** Before executing commands that modify the file system, codebase, or system state, provide a brief explanation of the command's purpose and potential impact. Prioritize user understanding and safety.
+- **Security First:** Always apply security best practices. Never introduce code that exposes, logs, or commits secrets, API keys, or other sensitive information.
+
+## Tool Usage
+- **File Paths:** Always use absolute paths when referring to files with file tools. Relative paths are not supported; you must provide an absolute path.
+- **Parallelism:** Execute multiple independent tool calls in parallel when feasible.
+- **Command Execution:** Run shell commands for actual system commands and terminal operations, remembering to explain modifying commands first.
+- **Respect User Confirmations:** Tool calls will first require confirmation from the user, where they will either approve or cancel. If a user cancels a call, respect their choice and do not try to make the call again; it is okay to request it again only if the user asks on a subsequent prompt.
+
+# Final Reminder
+Your core function is efficient and safe assistance. Balance extreme conciseness with the crucial need for clarity, especially regarding safety and potential system modifications. Always prioritize user control and project conventions. Never make assumptions about the contents of files; instead read to ensure you are not making broad assumptions. Keep going until the user's query is completely resolved.`;
+const BEAST_TEXT = `Keep going until the user's query is completely resolved, before ending your turn and yielding back to the user.
+
+Your thinking should be thorough, and it is fine if it is very long. However, avoid unnecessary repetition and verbosity. You should be concise, but thorough.
+
+You MUST iterate and keep going until the problem is solved. You have everything you need to resolve this problem. Fully solve it autonomously before coming back. Only terminate your turn when you are sure the problem is solved and all items have been checked off. Go through the problem step by step, verify that your changes are correct, and never end your turn without having truly and completely solved the problem. When you say you are going to make a tool call, make sure you ACTUALLY make the tool call instead of ending your turn.
+
+Your knowledge may be out of date because your training date is in the past. Use available search means to verify your understanding of third-party packages and dependencies is up to date every time you install or implement one. It is not enough to just search; you must also read the content of the pages you find and gather all relevant information until you have everything you need.
+
+Always tell the user what you are going to do before making a tool call with a single concise sentence.
+
+Take your time and think through every step. Check your solution rigorously and watch out for boundary cases, especially with the changes you made. Your solution must be perfect; if not, continue working on it. Test your code rigorously using the tools provided, many times, to catch all edge cases. If it is not robust, iterate more. Failing to test your code rigorously is the number one failure mode; make sure you handle all edge cases and run existing tests if they are provided.
+
+Plan extensively before each function call, and reflect extensively on the outcomes of the previous calls. Do not do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully. Keep working until the problem is completely solved and all items in the todo list are checked off; do not end your turn until you have completed all steps and verified that everything is working correctly.
+
+# Workflow
+1. Fetch any URLs provided by the user using the search tool.
+2. Understand the problem deeply. Carefully read the issue and think critically about what is required. Break down the problem into manageable parts, considering the expected behavior, edge cases, potential pitfalls, the larger context of the codebase, and the dependencies and interactions with other parts of the code.
+3. Investigate the codebase. Explore relevant files, search for key functions, and gather context.
+4. Research the problem using available search means by reading relevant articles, documentation, and forums.
+5. Develop a clear, step-by-step plan. Break down the fix into manageable, incremental steps and display the plan as a todo list, checking off each item as you go.
+6. Implement the fix incrementally. Make small, testable code changes.
+7. Debug as needed. Use debugging techniques to isolate and resolve issues.
+8. Test frequently. Run tests after each change to verify correctness.
+9. Iterate until the root cause is fixed and all tests pass.
+10. Reflect and validate comprehensively. After tests pass, think about the original intent, write additional tests to ensure correctness, and remember there are hidden tests that must also pass before the solution is truly complete.
+
+## Debugging
+- Make code changes only if you have high confidence they can solve the problem.
+- When debugging, determine the root cause rather than addressing symptoms. Use print statements, logs, or temporary code to inspect program state and test your hypotheses. Revisit your assumptions if unexpected behavior occurs.
+- Always read enough context to understand the code before editing; avoid re-reading files whose content has not changed.
+
+# Communication
+Communicate clearly and concisely in a casual, friendly yet professional tone. Avoid unnecessary explanations, repetition, and filler. Always write code directly to the correct files, and do not display code to the user unless they specifically ask for it.
+
+# Memory
+Remember user preferences expressed across the session and apply them consistently.
+
+# Git
+Never stage and commit files automatically unless the user explicitly tells you to.`;
+const CODEX_TEXT = `## Editing constraints
+- Default to ASCII when editing or creating files. Only introduce non-ASCII or other Unicode characters when there is a clear justification and the file already uses them.
+- Only add comments if they are necessary to make a non-obvious block easier to understand.
+
+## Tool usage
+- Prefer dedicated tools over shell for file operations: use an editing tool to modify files, a reading tool to view files, and search tools to find files by name or search file contents.
+- Use shell for terminal operations: git, builds, tests, and running scripts.
+- Run tool calls in parallel when neither call needs the other's output; otherwise run them sequentially.
+
+## Git and workspace hygiene
+- You may be in a dirty git worktree.
+  * NEVER revert existing changes you did not make unless explicitly requested, since these changes were made by the user.
+  * If asked to make a commit or code edits and there are unrelated changes to your work or changes you did not make in those files, do not revert those changes.
+  * If the changes are in files you have touched recently, read them carefully and understand how you can work with the changes rather than reverting them.
+  * If the changes are in unrelated files, just ignore them and do not revert them.
+- Do not amend commits unless explicitly requested.
+- **NEVER** use destructive commands like \`git reset --hard\` or \`git checkout --\` unless specifically requested or approved by the user.
+
+## Frontend tasks
+When doing frontend design tasks, avoid collapsing into bland, generic layouts. Aim for interfaces that feel intentional and deliberate.
+- Typography: Use expressive, purposeful fonts and avoid default stacks.
+- Color & Look: Choose a clear visual direction; define CSS variables; avoid generic defaults.
+- Motion: Use a few meaningful animations (page-load, staggered reveals) instead of generic micro-motions.
+- Background: Don't rely on flat, single-color backgrounds; use gradients, shapes, or subtle patterns to build atmosphere.
+- Overall: Avoid boilerplate layouts and interchangeable UI patterns. Vary themes, type families, and visual languages across outputs.
+- Ensure the page loads properly on both desktop and mobile.
+Exception: If working within an existing website or design system, preserve the established patterns, structure, and visual language.
+
+## Presenting your work and final message
+- Default: be very concise; friendly coding teammate tone.
+- Default: do the work without asking questions. Treat short tasks as sufficient direction; infer missing details by reading the codebase and following existing conventions.
+- Questions: only ask when you are truly blocked after checking relevant context AND you cannot safely pick a reasonable default. This usually means one of: the request is ambiguous in a way that materially changes the result and you cannot disambiguate by reading the repo; the action is destructive or irreversible, touches production, or changes billing or security posture; you need a secret or credential or value that cannot be inferred.
+- If you must ask: do all non-blocked work first, then ask exactly one targeted question, include your recommended default, and state what would change based on the answer.
+- Never ask permission questions like "Should I proceed?"; proceed with the most reasonable option and mention what you did.
+- For substantial work, summarize clearly and follow the final-answer formatting rules.
+- Skip heavy formatting for simple confirmations.
+- Don't dump large files you have written; reference paths only.
+- Offer logical next steps (tests, commits, build) briefly; add verify steps if you could not do something.
+- For code changes: lead with a quick explanation of the change, then give more details on the context covering where and why the change was made. If there are natural next steps, suggest them at the end of your response.
+
+## Final answer structure and style guidelines
+- Plain text; the CLI handles styling. Use structure only when it helps scannability.
+- Headers: optional; short Title Case (1-3 words); add only if they truly help.
+- Bullets: use -; merge related points; keep to one line when possible; keep phrasing consistent.
+- Monospace: use inline code for commands, paths, env vars, code ids, and inline examples; never combine with bold.
+- Code samples or multi-line snippets should be wrapped in fenced code blocks; include a language tag as often as possible.
+- Structure: group related bullets; order sections general to specific.
+- Tone: collaborative, concise, factual; present tense, active voice; self-contained.
+- Don'ts: no nested bullets or hierarchies; no ANSI codes; don't cram unrelated keywords; avoid naming formatting styles in answers.
+- File references: reference files with inline code so paths are clickable; each reference should have a standalone path; optionally include line/column (1-based) using the pattern \`file_path:line_number\`.`;
+const GPT_TEXT = `Be a deeply pragmatic, effective software engineer. Take engineering quality seriously; collaboration comes through as direct, factual statements. Communicate efficiently, keeping the user clearly informed about ongoing actions without unnecessary detail. Build context by examining the codebase first without making assumptions or jumping to conclusions. Think through the nuances of the code you encounter and embody the mentality of a skilled senior software engineer.
+
+## Editing Approach
+
+- The best changes are often the smallest correct changes.
+- When you are weighing two correct approaches, prefer the more minimal one (less new names, helpers, tests, and so on).
+- Keep things in one function unless composable or reusable.
+- Do not add backward-compatibility code unless there is a concrete need, such as persisted data, shipped behavior, external consumers, or an explicit user requirement; if unclear, ask one short question instead of guessing.
+
+## Autonomy and persistence
+
+Unless the user explicitly asks for a plan, asks a question about the code, is brainstorming potential solutions, or some other intent makes it clear that code should not be written, assume the user wants you to make code changes or run tools to solve the user's problem. In these cases it is bad to output your proposed solution in a message; you should go ahead and actually implement the change. If you encounter challenges or blockers, attempt to resolve them yourself.
+
+Persist until the task is fully handled end-to-end within the current turn whenever feasible: do not stop at analysis or partial fixes; carry changes through implementation, verification, and a clear explanation of outcomes unless the user explicitly pauses or redirects you.
+
+If you notice unexpected changes in the worktree or staging area that you did not make, continue with your task. NEVER revert, undo, or modify changes you did not make unless the user explicitly asks you to. There can be multiple agents or the user working in the same codebase concurrently.
+
+## Editing constraints
+
+- Default to ASCII when editing or creating files. Only introduce non-ASCII or other Unicode characters when there is a clear justification and the file already uses them.
+- Add succinct code comments that explain what is going on if code is not self-explanatory. Do not add comments like "assigns the value to the variable"; a brief comment might be useful ahead of a complex code block. Usage of these comments should be rare.
+- Use dedicated tools rather than scripts for reading and writing files when a simple dedicated tool call would suffice.
+- You may be in a dirty git worktree.
+  * NEVER revert existing changes you did not make unless explicitly requested, since these changes were made by the user.
+  * If asked to make a commit or code edits and there are unrelated changes to your work or changes you did not make in those files, do not revert those changes.
+  * If the changes are in files you have touched recently, read them carefully and understand how you can work with them rather than reverting them.
+  * If the changes are in unrelated files, just ignore them and do not revert them.
+- Do not amend a commit unless explicitly requested.
+- **NEVER** use destructive commands like \`git reset --hard\` or \`git checkout --\` unless specifically requested or approved by the user.
+
+## Special user requests
+
+If the user makes a simple request (such as asking for the time) which you can fulfill by running a terminal command, do so.
+
+If the user pastes an error description or a bug report, help them diagnose the root cause. You can try to reproduce it if it seems feasible with the available tools.
+
+If the user asks for a "review", default to a code review mindset: prioritize identifying bugs, risks, behavioural regressions, and missing tests. Findings must be the primary focus of the response; keep summaries or overviews brief and only after enumerating the issues. Present findings first, ordered by severity with file/line references, followed by open questions or assumptions, and offer a change summary only as a secondary detail. If no findings are discovered, state that explicitly and mention any residual risks or testing gaps.
+
+## Frontend tasks
+
+When doing frontend design tasks, avoid collapsing into "AI slop" or safe, average-looking layouts.
+- Ensure the page loads properly on both desktop and mobile.
+- Overall: Avoid boilerplate layouts and interchangeable UI patterns. Vary themes, type families, and visual languages across outputs.
+Exception: If working within an existing website or design system, preserve the established patterns, structure, and visual language.
+
+# Working with the user
+
+## General
+
+Do not begin responses with conversational interjections or meta commentary. Avoid openers such as acknowledgements or framing phrases.
+
+Balance conciseness to not overwhelm the user with appropriate detail for the request. Do not narrate abstractly; explain what you are doing and why.
+
+## Formatting rules
+
+Your responses are rendered as GitHub-flavored Markdown.
+
+Never use nested bullets. Keep lists flat (single level). If you need hierarchy, split into separate lists or sections. For numbered lists, only use the \`1. 2. 3.\` style markers (with a period), never \`1)\`.
+
+Headers are optional, only use them when you think they are necessary. If you do use them, use short Title Case (1-3 words). Don't add a blank line.
+
+Use inline code blocks for commands, paths, environment variables, function names, inline examples, and keywords.
+
+Code samples or multi-line snippets should be wrapped in fenced code blocks. Include a language tag when possible.
+
+Don't use emojis or em dashes unless explicitly instructed.
+
+## Progress and final responses
+
+Keep intermediate progress updates short and send them only when they add meaningful new information: a discovery, a tradeoff, a blocker, a substantial plan, or the start of a non-trivial edit or verification step. Do not narrate routine reads, searches, obvious next steps, or minor confirmations. Do not begin responses with conversational interjections or meta commentary. Before substantial work, send a short update describing your first step. Before editing files, send an update describing the edit.
+
+Match the final answer to the complexity of the task. Structure it if necessary, ordering sections from general to specific to supporting. If the task is simple, answer with a one-liner. If the user asks for a code explanation, include code references. For simple tasks, just state the outcome without heavy formatting. For large or complex changes, lead with the solution, then explain what you did and why. For casual chat, just chat. If something could not be done (tests, builds, and so on), say so. Suggest next steps only when they are natural and useful; if you list options, use numbered items.`;
+const KIMI_TEXT = `Your primary goal is to help users with software engineering tasks by taking action: use the tools available to you to make real changes on the user's system. You should also answer questions when asked.
+
+# Prompt and Tool Use
+
+The user's messages may contain questions and/or task descriptions. Read them, understand them, and do what the user requested. For simple questions or greetings that do not involve any information in the working directory or on the internet, reply directly. For anything else, default to taking action with tools. When the request could be interpreted as either a question to answer or a task to complete, treat it as a task.
+
+When handling the user's request, if it involves creating, modifying, or running code or files, you MUST use the appropriate tools to make actual changes; do not just describe the solution in text. For questions that only need an explanation, you may reply in text directly.
+
+If a subagent tool is available, you can use it to delegate a focused subtask to a subagent instance. When delegating, provide a complete prompt with all necessary context because a newly created subagent does not automatically see your context.
+
+You can output any number of tool calls in a single response. If you anticipate making multiple non-interfering tool calls, make them in parallel to significantly improve efficiency. The results of the tool calls will be returned to you; determine your next action based on the results.
+
+Tool results and user messages may include <system-reminder> tags. These are authoritative system directives that you MUST follow. They may override or constrain your normal behavior, and they bear no direct relation to the specific tool results or user messages in which they appear.
+
+When responding to the user, you MUST use the same language as the user, unless explicitly instructed to do otherwise.
+
+# General Guidelines for Coding
+
+When building something from scratch, you should:
+- Understand the user's requirements.
+- Ask the user for clarification if there is anything unclear.
+- Design the architecture and make a plan for the implementation.
+- Write the code in a modular and maintainable way.
+
+Always use tools to implement your code changes: use editing tools to create or modify source files. Code that only appears in your text response is NOT saved to the file system and will not take effect. Use shell to run and test your code after writing it. Iterate: if tests fail, read the error, fix the code, and re-test.
+
+When working on an existing codebase, you should:
+- Understand the codebase by reading it with tools before making changes. Identify the ultimate goal and the most important criteria to achieve it.
+- For a bug fix, check error logs or failed tests, scan the codebase to find the root cause, and figure out a fix. If the user mentioned failed tests, make sure they pass after the changes.
+- For a feature, design the architecture and write the code with minimal intrusion into existing code. Add new tests if the project already has tests.
+- For a refactor, update all call sites if the interface changes. DO NOT change existing logic, especially in tests; focus only on fixing errors caused by the interface changes.
+- Make MINIMAL changes to achieve the goal. This is very important to your performance.
+- Follow the coding style of existing code in the project.
+
+DO NOT run git commit, git push, git reset, git rebase, or any other git mutations unless explicitly asked to do so. Ask for confirmation each time you need to do git mutations, even if the user has confirmed in earlier conversations.
+
+# General Guidelines for Research and Data Processing
+
+Search on the Internet if possible, with carefully-designed search queries to improve efficiency and accuracy. Use proper tools or shell commands to process or generate files, ensuring that third-party packages are installed in a virtual or isolated environment if needed. Once you generate or edit any files, read them again before proceeding to ensure the content is as expected. Avoid installing or deleting anything outside of the current working directory; if you have to, ask the user for confirmation.
+
+# Working Environment
+
+The operating environment is not in a sandbox. Any actions you do will immediately affect the user's system, so you MUST be extremely cautious. Unless explicitly instructed to do so, never access (read, write, or execute) files outside of the working directory. Use absolute paths for file operations.
+
+# Project Information
+
+Markdown files named AGENTS.md usually contain the background, structure, coding styles, user preferences, and other relevant information about the project. You should read the project's AGENTS.md and README files to understand its conventions and preferences. If they are empty or insufficient, check README files or AGENTS.md files in subdirectories for more information.
+
+# Ultimate Reminders
+
+At any time, you should be HELPFUL, CONCISE, and ACCURATE. Be thorough in your actions: test what you build and verify what you change, not in your explanations.
+- Never diverge from the requirements and goals of the task you work on. Stay on track.
+- Never give the user more than what they want.
+- Try your best to avoid hallucination. Do fact checking before providing any factual information.
+- Think about the best approach, then take action decisively.
+- Do not give up too early.
+- ALWAYS keep it stupidly simple. Do not overcomplicate things.
+- When the task requires creating or modifying files, always use tools to do so. Never treat displaying code in your response as a substitute for actually writing it to the file system.`;
+/** DeepSeek 官方建议蒸馏（仅追加，不覆盖 base）。 */
+const DEEPSEEK_APPEND = `Notes for DeepSeek models:
+- Tool calls follow the OpenAI function-calling style; pass arguments strictly according to each tool's JSON schema.
+- Reasoning models (e.g. deepseek-reasoner) emit their reasoning before the final answer; do not ask them to skip the thinking process.`;
+/** 智谱官方建议蒸馏（仅追加，不覆盖 base）。 */
+const GLM_APPEND = `Notes for GLM models:
+- Tool calls follow the OpenAI function-calling style; pass arguments strictly according to each tool's JSON schema.
+- For thinking-enabled GLM models, the reasoning_content of each message must be passed back verbatim on the next request; never drop or rewrite it.
+- With interleaved thinking, keep the reasoning context across tool-call rounds.`;
+/** 默认语义层（固定层栈的唯一可编辑层）：persona。
+*  结构固定——UI 与服务端均不允许增删层、改名、改序，仅文本可编辑。
+*  persona 注册为普通 prompt-stack:persona（order 10），排在内置模型层
+*  prompt-stack:base（order 0）之后；默认空串：dsh「空段不渲染」，未填写时行为零变化。
+*  persona 是唯一可编辑存储层；base 为内置模型层（保留层名，不进存储），见 index.ts。 */
+const DEFAULT_LAYERS = [{
+	name: "persona",
+	order: 10,
+	text: ""
+}];
+/** 默认模型规则（顺序即同分仲裁序，勿调整）。 */
+const DEFAULT_RULES = [
+	{
+		match: { modelPattern: "claude*" },
+		overrides: { base: ANTHROPIC_TEXT }
+	},
+	{
+		match: { modelPattern: "gemini-*" },
+		overrides: { base: GEMINI_TEXT }
+	},
+	{
+		match: { modelPattern: "gpt-4*" },
+		overrides: { base: BEAST_TEXT }
+	},
+	{
+		match: { modelPattern: "o1*" },
+		overrides: { base: BEAST_TEXT }
+	},
+	{
+		match: { modelPattern: "o3*" },
+		overrides: { base: BEAST_TEXT }
+	},
+	{
+		match: { modelPattern: "gpt*codex*" },
+		overrides: { base: CODEX_TEXT }
+	},
+	{
+		match: { modelPattern: "gpt*" },
+		overrides: { base: GPT_TEXT }
+	},
+	{
+		match: { modelPattern: "kimi*" },
+		overrides: { base: KIMI_TEXT }
+	},
+	{
+		match: { modelPattern: "k2*" },
+		overrides: { base: KIMI_TEXT }
+	},
+	{
+		match: { modelPattern: "k3*" },
+		overrides: { base: KIMI_TEXT }
+	},
+	{
+		match: { provider: "moonshotai" },
+		overrides: { base: KIMI_TEXT }
+	},
+	{
+		match: { provider: "moonshotai-cn" },
+		overrides: { base: KIMI_TEXT }
+	},
+	{
+		match: { provider: "kimi-for-coding" },
+		overrides: { base: KIMI_TEXT }
+	},
+	{
+		match: { modelPattern: "deepseek*" },
+		append: DEEPSEEK_APPEND
+	},
+	{
+		match: { modelPattern: "glm-*" },
+		append: GLM_APPEND
+	}
+];
+//#endregion
+//#region src/prompt/match.ts
+/** 正则元字符（`*` 与 `?` 除外——它们是 glob 通配符，之后单独展开）。 */
+const REGEXP_META = /[.+^${}()|[\]\\]/g;
+/**
+* 把 glob（`*` = 任意串，`?` = 单字符）编译为锚定全串的正则。
+* @param pattern - 非空 glob；空或全空白抛错（激活期响亮报错的调用点在 apply）。
+* @returns 锚定全串的正则。
+*/
+function globToRegExp(pattern) {
+	if (pattern.trim() === "") throw new Error("prompt-stack: modelPattern must be a non-empty glob");
+	const source = pattern.replace(REGEXP_META, "\\$&").replaceAll("*", ".*").replaceAll("?", ".");
+	return new RegExp(`^${source}$`);
+}
+/**
+* 给一条规则的 match 打分：任一指定字段不匹配则整条不命中（返回 0）；
+* 命中分值为 model=4 / modelPattern=2 / provider=1 的累加。
+* @param match - 规则的匹配条件。
+* @param provider - 当前 agent 的 provider（创建期配置），可缺失。
+* @param model - 当前 agent 的模型 id，可缺失。
+* @returns 命中分值，0 表示不命中。
+*/
+function scoreRule(match, provider, model) {
+	let score = 0;
+	if (match.provider !== void 0) {
+		if (match.provider !== provider) return 0;
+		score += 1;
+	}
+	if (match.model !== void 0) {
+		if (match.model !== model) return 0;
+		score += 4;
+	}
+	if (match.modelPattern !== void 0) {
+		if (model === void 0 || !globToRegExp(match.modelPattern).test(model)) return 0;
+		score += 2;
+	}
+	return score;
+}
+/**
+* 选出唯一命中规则：最高分者，同分取配置序靠前者。
+* @param rules - 配置中的规则数组（顺序即优先级仲裁序）。
+* @param provider - 当前 agent 的 provider，可缺失。
+* @param model - 当前 agent 的模型 id，可缺失。
+* @returns 命中规则；无命中返回 undefined。
+*/
+function selectRule(rules, provider, model) {
+	let best;
+	let bestScore = 0;
+	for (const rule of rules) {
+		const score = scoreRule(rule.match, provider, model);
+		if (score > bestScore) {
+			best = rule;
+			bestScore = score;
+		}
+	}
+	return best;
+}
+//#endregion
+//#region src/prompt/index.ts
+/** 固定追加层的层名（保留，用户层不得使用）。 */
+const MODEL_NOTES_LAYER = "model-notes";
+/** 内置模型层名（保留）：固定注册 prompt-stack:base 段、不进存储，仍是 rules overrides 的合法目标。 */
+const BASE_LAYER = "base";
+const BASE_SECTION = `prompt-stack:${BASE_LAYER}`;
+/** 原生身份段名与原生文本（与 dsh system-prompt 宿主一致；覆盖判定的基准值）。 */
+const IDENTITY_SECTION = "harness:identity";
+const NATIVE_IDENTITY_TEXT = "You are an AI agent powered by DeepSeek Harness.";
+/** 层列表语义校验：空、层名重复、保留层名（base/model-notes）。 */
+function validateLayers(layers) {
+	if (layers.length === 0) throw new Error("prompt-stack: config.layers must define at least one layer");
+	const names = /* @__PURE__ */ new Set();
+	for (const layer of layers) {
+		if (layer.name === "model-notes" || layer.name === "base") throw new Error(`prompt-stack: layer name "${layer.name}" is reserved`);
+		if (names.has(layer.name)) throw new Error(`prompt-stack: duplicate layer name "${layer.name}"`);
+		names.add(layer.name);
+	}
+}
+/**
+* 激活期校验（dsh「误配置响亮失败」惯例）：空 layers、层名重复、保留层名、
+* overrides 引用未知层（内置 base 与 model-notes 之外的存储层名）、空 match、非法 glob 全部抛错。
+*/
+function validateConfig(config) {
+	validateLayers(config.layers);
+	const names = /* @__PURE__ */ new Set([BASE_LAYER, ...config.layers.map((layer) => layer.name)]);
+	for (const [index, rule] of config.rules.entries()) {
+		const { provider, model, modelPattern } = rule.match;
+		if (provider === void 0 && model === void 0 && modelPattern === void 0) throw new Error(`prompt-stack: rules[${index}].match must set at least one of provider, model, modelPattern`);
+		if (modelPattern !== void 0) globToRegExp(modelPattern);
+		for (const key of Object.keys(rule.overrides ?? {})) if (!names.has(key)) throw new Error(`prompt-stack: rules[${index}].overrides references unknown layer "${key}"`);
+	}
+}
+/**
+* 固定注册 prompt-stack:base（模型层，order 0）+ 每个存储层一个段 + model-notes。
+* 文本在每次组装时按当前 agent 的 provider/model 选唯一命中规则（最高分、同分取配置序靠前），
+* 模型层用 overrides.base 整体替换内置 BASE_TEXT，存储层用 overrides 替换该层文本。
+* 裸组装（无 agent）静默用默认文本。deployment:persona 槽位还原生，本模块不触碰。
+*
+* 运行时选模型与首条消息钉住语义不变（见 waterfall 注释）。
+*/
+function setupPrompt(ctx, config) {
+	const { source, rules } = config;
+	const hitRule = (context) => selectRule(rules, context.agent?.options?.provider, context.agent?.options?.model);
+	const isSubagent = (context) => context.agent?.session?.header?.origin === "subagent";
+	let disposers = [];
+	const registerSections = () => {
+		for (const dispose of disposers) dispose();
+		disposers = [];
+		const layers = source.get();
+		validateLayers(layers);
+		const notesOrder = Math.max(0, ...layers.map((layer) => layer.order)) + 1;
+		disposers.push(ctx.systemPrompt.section({
+			name: BASE_SECTION,
+			order: 0,
+			text: (context) => isSubagent(context) ? "" : hitRule(context)?.overrides?.["base"] ?? BASE_TEXT
+		}));
+		for (const layer of layers) disposers.push(ctx.systemPrompt.section({
+			name: `prompt-stack:${layer.name}`,
+			order: layer.order,
+			text: (context) => isSubagent(context) ? "" : hitRule(context)?.overrides?.[layer.name] ?? layer.text
+		}));
+		disposers.push(ctx.systemPrompt.section({
+			name: `prompt-stack:${MODEL_NOTES_LAYER}`,
+			order: notesOrder,
+			text: (context) => hitRule(context)?.append ?? ""
+		}));
+	};
+	registerSections();
+	ctx.effect(() => source.subscribe(registerSections));
+	const notesSection = `prompt-stack:${MODEL_NOTES_LAYER}`;
+	const pinned = /* @__PURE__ */ new WeakMap();
+	ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
+		const assembled = await next();
+		let provider = assembled.variables.provider ?? context.agent?.options?.provider;
+		let model = assembled.variables.model ?? context.agent?.options?.model;
+		const agent = context.agent;
+		if (agent !== void 0) {
+			const cached = pinned.get(agent);
+			if (cached !== void 0 && cached.sessionId === agent.session.id) {
+				provider = cached.provider;
+				model = cached.model;
+			} else if (provider !== void 0 || model !== void 0) pinned.set(agent, {
+				sessionId: agent.session.id,
+				provider,
+				model
+			});
+		}
+		const rule = selectRule(rules, provider, model);
+		const layers = source.get();
+		const ownSection = (section) => {
+			if (section.name === BASE_SECTION) return isSubagent(context) ? "" : hitRule(context)?.overrides?.["base"] ?? BASE_TEXT;
+			const layer = layers.find((l) => section.name === `prompt-stack:${l.name}`);
+			if (layer === void 0) return void 0;
+			return isSubagent(context) ? "" : hitRule(context)?.overrides?.[layer.name] ?? layer.text;
+		};
+		const sections = assembled.sections.map((section) => {
+			if (section.name === IDENTITY_SECTION) {
+				const override = source.getIdentity();
+				if (override === "" || isSubagent(context) || section.text !== NATIVE_IDENTITY_TEXT) return section;
+				return {
+					...section,
+					text: override
+				};
+			}
+			if (section.name === notesSection) return {
+				...section,
+				text: rule?.append ?? ""
+			};
+			const own = ownSection(section);
+			if (own === void 0 || section.text !== own) return section;
+			if (section.name === BASE_SECTION) return {
+				...section,
+				text: isSubagent(context) ? "" : rule?.overrides?.["base"] ?? BASE_TEXT
+			};
+			const layer = layers.find((l) => section.name === `prompt-stack:${l.name}`);
+			return {
+				...section,
+				text: isSubagent(context) ? "" : rule?.overrides?.[layer.name] ?? layer.text
+			};
+		});
+		return {
+			...assembled,
+			sections
+		};
+	});
+}
+//#endregion
+//#region src/prompt/layer-source.ts
+/** prompt_layers 表单行的 key 常量。 */
+const PROMPT_LAYERS_KEY = "layers";
+/** meta 表首启种子一次性标记键。 */
+const PROMPT_LAYERS_SEEDED_KEY = "prompt_layers_seeded";
+/** 组装存储行：identity 仅非空时落字段（空串 = 还原原生，不留残字段）。 */
+function row(layers, identity) {
+	return identity === "" ? { layers } : {
+		layers,
+		identity
+	};
+}
+/** 固定结构校验：name+order 多重集合必须等于种子（仅 text 可变）。 */
+function validateFixedLayers(layers, seedLayers) {
+	const key = (layer) => `${layer.name}@${String(layer.order)}`;
+	const seed = seedLayers.map(key).sort();
+	const actual = layers.map(key).sort();
+	if (actual.length !== seed.length || actual.some((k, i) => k !== seed[i])) throw new Error(`prompt-stack: layer structure is fixed (${seedLayers.map((l) => l.name).join(", ")}); only layer text is editable`);
+}
+/** 按种子结构 reconcile 已存储层：同名层保留已存文本（order 以种子为准）、补缺失、丢多余。 */
+function reconcileLayers(stored, seedLayers) {
+	return seedLayers.map((seed) => ({
+		...seed,
+		text: stored.find((layer) => layer.name === seed.name)?.text ?? seed.text
+	}));
+}
+/**
+* 打开层源。域由 apply 统一 open（storage-domain 同名单开），本函数只消费表句柄。
+* 首启（表无数据）种入 Config 种子并置标记；此后读存储并按种子结构 reconcile
+* （层栈固定化迁移：保留已编辑文本、补新层、丢多余层）。
+*/
+async function openLayerSource(tables, seedLayers) {
+	const { promptLayers, meta } = tables;
+	validateLayers(seedLayers);
+	let cache;
+	let identity;
+	const existing = promptLayers.get(PROMPT_LAYERS_KEY);
+	if (existing !== void 0) {
+		cache = reconcileLayers(existing.layers, seedLayers);
+		validateLayers(cache);
+		identity = existing.identity ?? "";
+		await promptLayers.put(PROMPT_LAYERS_KEY, row(cache, identity));
+	} else {
+		cache = seedLayers;
+		identity = "";
+		await promptLayers.put(PROMPT_LAYERS_KEY, { layers: cache });
+	}
+	if (meta.get("prompt_layers_seeded") === void 0) await meta.put(PROMPT_LAYERS_SEEDED_KEY, { value: "1" });
+	const listeners = /* @__PURE__ */ new Set();
+	const notify = () => {
+		for (const listener of [...listeners]) listener();
+	};
+	return {
+		get: () => cache,
+		getIdentity: () => identity,
+		async set(layers) {
+			validateLayers(layers);
+			validateFixedLayers(layers, seedLayers);
+			await promptLayers.put(PROMPT_LAYERS_KEY, row(layers, identity));
+			cache = layers;
+			notify();
+		},
+		async setIdentity(text) {
+			await promptLayers.put(PROMPT_LAYERS_KEY, row(cache, text));
+			identity = text;
+			notify();
+		},
+		async reset() {
+			await promptLayers.delete(PROMPT_LAYERS_KEY);
+			await meta.delete(PROMPT_LAYERS_SEEDED_KEY);
+			await promptLayers.put(PROMPT_LAYERS_KEY, { layers: seedLayers });
+			await meta.put(PROMPT_LAYERS_SEEDED_KEY, { value: "1" });
+			cache = seedLayers;
+			identity = "";
+			notify();
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+//#endregion
+//#region src/shared/webserver.ts
+function registerOptionalRoutes(ctx, register) {
+	ctx.inject(["webServer"], (webCtx) => {
+		webCtx.effect(() => register(webCtx));
+	});
+}
+function json$1(res, code, body) {
+	res.writeHead(code, { "content-type": "application/json" }).end(JSON.stringify(body));
+}
+/** 读 JSON body；超限 413 / 非法 JSON 400（已写响应时返回 undefined）。 */
+async function readJsonBody$1(req, res) {
+	const chunks = [];
+	let received = 0;
+	for await (const chunk of req) {
+		const buffer = chunk;
+		received += buffer.byteLength;
+		if (received > 65536) {
+			json$1(res, 413, { error: "body too large" });
+			req.destroy();
+			return;
+		}
+		chunks.push(buffer);
+	}
+	try {
+		return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+	} catch {
+		json$1(res, 400, { error: "invalid JSON body" });
+		return;
+	}
+}
+//#endregion
+//#region src/prompt/api.ts
+const LayersBodySchema = z$1.object({
+	layers: z$1.array(LayerConfigSchema),
+	identityOverride: z$1.string().optional()
+});
+function createPromptLayersApiHandler(deps) {
+	return async (req, res) => {
+		const sub = new URL(req.url ?? "/", "http://127.0.0.1").pathname.replace(/^\/dsh-agent-toolkit\/api\/prompt-layers/, "") || "/";
+		const method = req.method ?? "GET";
+		if (sub === "/" && method === "GET") {
+			let native = {
+				sections: [],
+				contexts: []
+			};
+			try {
+				native = await deps.probe();
+			} catch {}
+			json$1(res, 200, {
+				layers: deps.source.get(),
+				rules: deps.rules,
+				seedLayers: deps.seedLayers,
+				native,
+				modelFallbackText: BASE_TEXT,
+				identityOverride: deps.source.getIdentity()
+			});
+			return;
+		}
+		if (sub === "/" && method === "PUT") {
+			const body = await readJsonBody$1(req, res);
+			if (body === void 0) return;
+			const parsed = LayersBodySchema.safeParse(body);
+			if (!parsed.success) {
+				json$1(res, 400, { error: parsed.error.issues[0]?.message ?? "invalid layers body" });
+				return;
+			}
+			try {
+				validateLayers(parsed.data.layers);
+				validateFixedLayers(parsed.data.layers, deps.seedLayers);
+			} catch (error) {
+				json$1(res, 400, { error: error instanceof Error ? error.message : String(error) });
+				return;
+			}
+			try {
+				await deps.source.set(parsed.data.layers);
+				if (parsed.data.identityOverride !== void 0) await deps.source.setIdentity(parsed.data.identityOverride);
+			} catch (error) {
+				json$1(res, 500, { error: error instanceof Error ? error.message : String(error) });
+				return;
+			}
+			json$1(res, 200, { ok: true });
+			return;
+		}
+		if (sub === "/reset" && method === "POST") {
+			try {
+				await deps.source.reset();
+			} catch (error) {
+				json$1(res, 500, { error: error instanceof Error ? error.message : String(error) });
+				return;
+			}
+			json$1(res, 200, { ok: true });
+			return;
+		}
+		if (sub === "/reset" || sub === "/") {
+			json$1(res, 405, { error: "method not allowed" });
+			return;
+		}
+		json$1(res, 404, { error: "not found" });
+	};
+}
+/** 注册 /dsh-agent-toolkit/api/prompt-layers 前缀路由（webServer 可选服务，缺席惰性不注册）。 */
+function setupPromptLayersApi(ctx, deps) {
+	const handler = createPromptLayersApiHandler(deps);
+	registerOptionalRoutes(ctx, (webCtx) => {
+		const dispose = webCtx.webServer.register({
+			kind: "prefix",
+			path: "/dsh-agent-toolkit/api/prompt-layers",
+			handler
+		});
+		return () => dispose();
+	});
+}
+//#endregion
+//#region src/prompt/persona.ts
+/** 委派子 Agent 的 persona 装配：契约段 + 内置模型层（按子的模型改写）+ 角色 persona。 */
+const SECTION_A = (roleName) => `你是团队中的一名成员（角色：${roleName}），由主 Agent 委派任务。
+- 你看不到主对话；任务书包含你完成工作所需的全部上下文。
+- 你的最终输出会作为结果完整返回给主 Agent：直接给出结论与必要细节。
+- 你不能再次委派他人；任务需要拆分时，自己按顺序完成。`;
+const SECTION_B = `能力使用守则：
+- 你可以使用与主 Agent 相同的工具与 MCP 资源，但只在任务必需时调用。
+- 动手修改代码前，先阅读项目根目录及涉及目录的 AGENTS.md，并遵循其中约定。
+- 产生或修改文件后，运行相关检查（测试、类型检查）验证你的改动。`;
+/**
+* 子 Agent 提示词 = 契约段 A/B + 模型层文本（命中规则 overrides.base 整份替换内置
+* BASE_TEXT）+ 角色 persona（非空时，排在模型层之后）+ 命中规则的 append（model-notes）。
+* 全局 persona 层是主 Agent 的人设，不进入子 Agent（子的角色由 role.persona 顶替）。
+*/
+function buildAgentPersona(config, role, model) {
+	const rule = selectRule(config.rules, model?.provider, model?.model);
+	const texts = [rule?.overrides?.base ?? BASE_TEXT];
+	if (role.persona !== void 0 && role.persona.trim().length > 0) texts.push(role.persona);
+	if (rule?.append !== void 0) texts.push(rule.append);
+	return [
+		SECTION_A(role.name),
+		SECTION_B,
+		...texts
+	].join("\n\n");
+}
+//#endregion
+//#region src/delegate/tool.ts
+/** 非 completed 的 stopReason 意味着成员未干净完成。 */
+function stopReasonError(result) {
+	switch (result.stopReason) {
+		case "completed": return;
+		case "aborted": return "成员运行被取消";
+		case "error": return "成员运行失败";
+		case "max-tokens": return "成员在结束前触及 token 上限";
+		case "refusal": return "成员拒绝了该任务";
+		default: return `成员运行异常结束（${String(result.stopReason)}）`;
+	}
+}
+/** 报错时附上成员已产出的部分文本，让截断/取消的真实产出仍回到主 Agent。 */
+function withPartialText(error, output) {
+	const text = output.filter((block) => block.type === "text").map((block) => block.text).join("");
+	return text.length === 0 ? error : `${error}\n成员中断前的部分产出：\n${text}`;
+}
+/** 收集并释放一次前台运行；dispose 失败不掩盖独立的结果失败。 */
+async function settleForegroundRun(run, roleId) {
+	const childSessionId = String(run.id);
+	const [execution] = await Promise.allSettled([run.result.then((result) => {
+		const error = stopReasonError(result);
+		if (error !== void 0) throw new Error(withPartialText(error, result.output));
+		return {
+			kind: "foreground",
+			role: roleId,
+			runId: String(run.id),
+			childSessionId,
+			output: result.output
+		};
+	})]);
+	const [disposal] = await Promise.allSettled([Promise.resolve().then(() => run.dispose())]);
+	if (execution.status === "rejected") {
+		if (disposal.status === "rejected") throw new AggregateError([execution.reason, disposal.reason], `成员运行失败：${String(execution.reason)}；dispose 失败：${String(disposal.reason)}`);
+		throw execution.reason;
+	}
+	if (disposal.status === "rejected") throw disposal.reason;
+	return execution.value;
+}
+/**
+* 创建 team_delegate 工具。
+* @param toolName - 模型可见工具名（Config.toolName，默认 team_delegate）。
+* @param deps - 名册、provider、persona 装配与委派入口。
+* @returns defineTool 产物，交给 ctx.tools.register。
+*
+* 工具注册是 standing scope 的单次注册，description 无法内嵌名册；名册对模型的
+* 可见性走系统提示团队段（index.ts）。
+*/
+function createDelegateTool(toolName, deps) {
+	return defineTool({
+		name: toolName,
+		description: "Delegate a self-contained task to a team member (a separate agent with its own persona and optional model override). The member does NOT see this conversation — give it a complete, standalone prompt. Available members and their descriptions are listed in the team section of the system prompt. This call waits for the member and returns its result.",
+		parameters: {
+			role: {
+				type: "string",
+				required: true,
+				description: "The member to delegate to. Must be one of the listed names."
+			},
+			description: {
+				type: "string",
+				required: true,
+				description: "A short (3-5 word) description of the delegated task, for display."
+			},
+			prompt: {
+				type: "string",
+				required: true,
+				description: "The complete, self-contained task for the member. It does not share this conversation's context, so include everything it needs."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					kind: {
+						type: "string",
+						required: true,
+						const: "foreground"
+					},
+					role: {
+						type: "string",
+						required: true
+					},
+					runId: {
+						type: "string",
+						required: true
+					},
+					childSessionId: {
+						type: "string",
+						required: true
+					},
+					output: {
+						type: "array",
+						required: true,
+						items: { type: "json" }
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.output.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("")
+			}],
+			presentationMeta: (_args, value) => ({
+				role: value.role,
+				runId: value.runId,
+				childSessionId: value.childSessionId
+			})
+		},
+		isConcurrencySafe: () => true,
+		presentCall: (args) => ({
+			card: "generic",
+			title: `委派 · ${args.role}: ${args.description}`,
+			rawInput: args.prompt
+		}),
+		presentResult: (_args, result) => result.isError ? void 0 : { card: "generic" },
+		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 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);
+			const request = {
+				label: `role:${role.id}: ${args.description}`,
+				prompt: [{
+					type: "text",
+					text: args.prompt
+				}],
+				parent,
+				persona,
+				maxDepth: 1,
+				signal: exec.signal,
+				...role.model !== void 0 ? { agentOptions: {
+					provider: role.model.provider,
+					model: role.model.model
+				} } : {},
+				...role.tools !== void 0 ? { toolFilter: { allow: [...role.tools.allow] } } : {}
+			};
+			return settleForegroundRun(await deps.startRun(deps.provider, request), role.id);
+		}
+	});
+}
+//#endregion
+//#region src/delegate/index.ts
+/** 团队名册段在 prompt 中的位置：紧随内置 subagent 段（116.5）之后。 */
+const TEAM_SECTION_ORDER = 116.6;
+/**
+* 挂载 team_delegate 工具与函数式团队提示段。
+* provider 能力守卫与生命周期镜像同归档 tool-subagent：persona/depthLimit 缺失响亮报错，
+* 工具随 provider 在场与否挂载/摘除。名册来自注册表（main 排除），工具与提示段都经
+* 闭包读取 registry，UI 改角色后新会话即生效。
+*/
+function setupDelegate(ctx, config, registry) {
+	const { provider, toolName } = config;
+	let disposeTool;
+	let providerFailed = false;
+	const mountTool = (p) => {
+		const missing = [];
+		if (!p.capabilities.persona) missing.push("persona");
+		if (!p.capabilities.depthLimit) missing.push("depthLimit");
+		if (missing.length > 0) throw new Error(`dsh-agent-toolkit: provider "${p.name}" 缺少 team_delegate 委派必需能力 ${missing.join("/")}（固定发送 persona 与 maxDepth:1）——请配置具备 persona 与 depthLimit 能力的 provider（如 spawn/fork）`);
+		if (disposeTool === void 0) disposeTool = ctx.tools.register(createDelegateTool(toolName, {
+			roster: () => registry.list(),
+			provider,
+			buildPersona: (role) => buildAgentPersona({ rules: config.rules }, role, role.model),
+			startRun: (pr, request) => ctx.subagents.start(pr, request)
+		}));
+	};
+	ctx.on("subagent/provider-added", (p) => {
+		if (p.name !== provider || providerFailed) return;
+		try {
+			mountTool(p);
+		} catch (error) {
+			providerFailed = true;
+			ctx.logger.error(error instanceof Error ? error.message : String(error));
+		}
+	});
+	ctx.on("subagent/provider-removed", (removed) => {
+		if (removed !== provider) return;
+		providerFailed = false;
+		if (disposeTool !== void 0) {
+			disposeTool();
+			disposeTool = void 0;
+		}
+	});
+	const present = ctx.subagents.getProvider(provider);
+	if (present !== void 0) mountTool(present);
+	else ctx.logger.info(`dsh-agent-toolkit: subagent provider "${provider}" 尚未注册；team_delegate 将等它出现时挂载`);
+	ctx.systemPrompt.section({
+		name: "plugin:dsh-agent-toolkit:team",
+		order: TEAM_SECTION_ORDER,
+		text: () => {
+			const rosterText = registry.list().filter((r) => r.id !== "main").map((r) => `${r.id}: ${r.description ?? r.name}`).join("\n");
+			return `你有一组可委派的成员：用 ${config.toolName} 把自包含的子任务委派给合适的成员，成员结果会作为工具返回值回到本对话。\n可用成员：\n${rosterText}`;
+		}
+	});
+}
+//#endregion
+//#region src/agents/api.ts
+function createAgentsApiHandler(deps) {
+	return async (req, res) => {
+		const sub = new URL(req.url ?? "/", "http://127.0.0.1").pathname.replace(/^\/dsh-agent-toolkit\/api/, "") || "/";
+		const method = req.method ?? "GET";
+		if (sub === "/agents" && method === "GET") {
+			json$1(res, 200, deps.registry.list());
+			return;
+		}
+		if (sub === "/tools" && method === "GET") {
+			json$1(res, 200, {
+				native: [...NATIVE_TOOL_NAMES],
+				global: deps.listTools()
+			});
+			return;
+		}
+		if (sub === "/providers" && method === "GET") {
+			json$1(res, 200, deps.listProviders());
+			return;
+		}
+		const modelsMatch = /^\/providers\/([^/]+)\/models$/.exec(sub);
+		if (modelsMatch !== null && method === "GET") {
+			let models = [];
+			try {
+				models = await deps.listModels(decodeURIComponent(modelsMatch[1]));
+			} catch {
+				models = [];
+			}
+			json$1(res, 200, models);
+			return;
+		}
+		const agentMatch = /^\/agents\/([^/]+)$/.exec(sub);
+		if (agentMatch !== null) {
+			const id = decodeURIComponent(agentMatch[1]);
+			if (method === "PUT") {
+				const body = await readJsonBody$1(req, res);
+				if (body === void 0) return;
+				const bodyRecord = { ...body };
+				delete bodyRecord.builtin;
+				const candidate = {
+					...bodyRecord,
+					id
+				};
+				if (deps.registry.get(id)?.builtin === true) candidate.builtin = true;
+				const parsed = AgentRecordSchema.safeParse(candidate);
+				if (!parsed.success) {
+					json$1(res, 400, { error: parsed.error.issues[0]?.message ?? "invalid agent record" });
+					return;
+				}
+				try {
+					await deps.registry.upsert(parsed.data);
+				} catch (error) {
+					json$1(res, 409, { error: error instanceof Error ? error.message : String(error) });
+					return;
+				}
+				json$1(res, 200, { ok: true });
+				return;
+			}
+			if (method === "DELETE") {
+				if (deps.registry.get(id) === void 0) {
+					json$1(res, 404, { error: `agent "${id}" 不存在` });
+					return;
+				}
+				try {
+					await deps.registry.remove(id);
+				} catch (error) {
+					json$1(res, 409, { error: error instanceof Error ? error.message : String(error) });
+					return;
+				}
+				json$1(res, 200, { ok: true });
+				return;
+			}
+			json$1(res, 405, { error: "method not allowed" });
+			return;
+		}
+		if ([
+			"/agents",
+			"/providers",
+			"/tools"
+		].some((p) => sub === p || sub.startsWith(`${p}/`))) {
+			json$1(res, 405, { error: "method not allowed" });
+			return;
+		}
+		json$1(res, 404, { error: "not found" });
+	};
+}
+/**
+* 注册 agents 核心 RPC 路由（恒启用，不随 modules.feishu 门控——Agents 面板总是挂载，
+* 这些端点缺失即「加载失败」）。webServer 为可选服务：缺席时经 registerOptionalRoutes
+* 惰性不注册。挂载点与 bots 同处 /dsh-agent-toolkit/api 前缀，但按路径空间拆成独立
+* prefix/exact 条目（webServer 精确先于最长前缀），互不重叠：
+* - prefix /dsh-agent-toolkit/api/agents   → /agents 与 /agents/:id
+* - prefix /dsh-agent-toolkit/api/providers → /providers 与 /providers/:p/models
+* - exact /dsh-agent-toolkit/api/tools
+* - prefix /dsh-agent-toolkit/api           → 兜底：api 前缀下未被更具体路由（bots/usage）
+*   认领的未知路径仍回 404 JSON（与旧统一分发行为字节一致）。
+*/
+function setupAgentsApi(ctx, deps) {
+	const handler = createAgentsApiHandler(deps);
+	registerOptionalRoutes(ctx, (webCtx) => {
+		const dispose = [
+			webCtx.webServer.register({
+				kind: "prefix",
+				path: "/dsh-agent-toolkit/api/agents",
+				handler
+			}),
+			webCtx.webServer.register({
+				kind: "prefix",
+				path: "/dsh-agent-toolkit/api/providers",
+				handler
+			}),
+			webCtx.webServer.register({
+				kind: "exact",
+				path: "/dsh-agent-toolkit/api/tools",
+				handler
+			}),
+			webCtx.webServer.register({
+				kind: "prefix",
+				path: "/dsh-agent-toolkit/api",
+				handler
+			})
+		];
+		return () => dispose.forEach((unregister) => unregister());
+	});
+}
+//#endregion
+//#region src/channels/agent-setup.ts
+/** bot 会话角色 persona 的 scoped 段名：与全局 persona 层同名，scoped 注册即 shadow 覆盖主 Agent persona。 */
+const TOOLKIT_PERSONA_SECTION = "prompt-stack:persona";
+/** 默认加载器：复刻 preset mount 的模块解析——loader 的 unwrapExports 取 `default ?? 命名导出模块`。 */
+async function loadToolModule(specifier) {
+	const mod = await import(specifier);
+	return mod.default ?? mod;
+}
+/**
+* 组合 agent 作用域：先 scoped 挂载基础工具行（persona/instructions/shell/fs/fs-search，
+* 与原生 UI 会话的 standard preset 同源），再叠 bot 的 persona 与 tools 白名单。
+* 顺序敏感：restrict 必须在工具行挂载之后，否则白名单命中不到挂载带入的工具名。
+*/
+async function setupAgentScope(agentCtx, hooks, loadTool = loadToolModule) {
+	for (const tool of BASIC_TOOLS) await agentCtx.plugin(await loadTool(tool.id), tool.config);
+	if (hooks.persona !== void 0) agentCtx.systemPrompt.section({
+		name: TOOLKIT_PERSONA_SECTION,
+		order: 10,
+		text: hooks.persona
+	});
+	if (hooks.sections !== void 0) for (const section of hooks.sections) agentCtx.systemPrompt.section({
+		name: section.name,
+		order: section.order,
+		text: section.text
+	});
+	if (hooks.tools !== void 0) agentCtx.tools.restrict({ allow: hooks.tools });
+}
+//#endregion
+//#region src/channels/feishu/api.ts
+/** SDK 薄封装：tenant_access_token 由 SDK 自动管理；错误带 code/msg 上下文。 */
+function createFeishuApi(client) {
+	return {
+		async createCard(cardJson) {
+			const res = await client.cardkit.v1.card.create({ data: {
+				type: "card_json",
+				data: cardJson
+			} });
+			const cardId = res.data?.card_id;
+			if (typeof cardId !== "string" || cardId.length === 0) throw new Error(`cardkit 建卡失败：code=${res.code} msg=${res.msg}`);
+			return cardId;
+		},
+		async sendCardMessage(chatId, cardId) {
+			await client.im.message.create({
+				params: { receive_id_type: "chat_id" },
+				data: {
+					receive_id: chatId,
+					msg_type: "interactive",
+					content: JSON.stringify({
+						type: "card",
+						data: { card_id: cardId }
+					})
+				}
+			});
+		},
+		async updateCardElement(cardId, elementId, content, sequence) {
+			await client.cardkit.v1.cardElement.content({
+				path: {
+					card_id: cardId,
+					element_id: elementId
+				},
+				data: {
+					content,
+					sequence
+				}
+			});
+		},
+		async insertElement(cardId, elementJson, targetElementId, sequence) {
+			await client.cardkit.v1.cardElement.create({
+				path: { card_id: cardId },
+				data: {
+					type: "insert_before",
+					target_element_id: targetElementId,
+					elements: `[${elementJson}]`,
+					sequence
+				}
+			});
+		},
+		async setCardStreaming(cardId, streaming, sequence, summary) {
+			await client.cardkit.v1.card.settings({
+				path: { card_id: cardId },
+				data: {
+					settings: JSON.stringify({ config: {
+						streaming_mode: streaming,
+						...summary !== void 0 ? { summary: { content: summary } } : {}
+					} }),
+					sequence
+				}
+			});
+		},
+		async replaceCard(cardId, cardJson, sequence) {
+			await client.cardkit.v1.card.update({
+				path: { card_id: cardId },
+				data: {
+					card: {
+						type: "card_json",
+						data: cardJson
+					},
+					sequence
+				}
+			});
+		},
+		async sendText(chatId, text) {
+			await client.im.message.create({
+				params: { receive_id_type: "chat_id" },
+				data: {
+					receive_id: chatId,
+					msg_type: "text",
+					content: JSON.stringify({ text })
+				}
+			});
+		},
+		async addReaction(messageId, emojiType) {
+			const res = await client.im.messageReaction.create({
+				path: { message_id: messageId },
+				data: { reaction_type: { emoji_type: emojiType } }
+			});
+			const reactionId = res.data?.reaction_id;
+			if (typeof reactionId !== "string") throw new Error(`加表情失败：code=${res.code} msg=${res.msg}`);
+			return reactionId;
+		},
+		async removeReaction(messageId, reactionId) {
+			await client.im.messageReaction.delete({ path: {
+				message_id: messageId,
+				reaction_id: reactionId
+			} });
+		}
+	};
+}
+//#endregion
+//#region src/channels/directive.ts
+/** 仅当整条消息就是一个指令时命中；带参数/前后文的按普通消息处理。 */
+function parseDirective(text) {
+	const t = text.trim().toLowerCase();
+	if (t === "/new") return "new";
+	if (t === "/stop") return "stop";
+	if (t === "/status") return "status";
+	return null;
+}
+/** 群消息正文中的 @ 占位符（@_user_1 等）剥掉，得到纯净指令文本。 */
+function stripMentionPlaceholders(text) {
+	return text.replace(/@_user_\d+\s*/g, "").trim();
+}
+//#endregion
+//#region src/channels/feishu/parse.ts
+/** im.message.receive_v1 事件解析：窄化为渠道无关的 ParsedMessage；message_id 去重。 */
+/**
+* SDK handler 收到的 data 即事件体（README 示例 `data.message` 直接解构）；
+* 兼容包一层 { event } 的形态。过滤：机器人消息、非文本、群内未 @机器人、空文本。
+*/
+function parseMessageEvent(data) {
+	const wrapped = data;
+	const event = wrapped.event ?? wrapped;
+	if (event.sender?.sender_type !== "user") return null;
+	const userId = event.sender.sender_id?.open_id;
+	const msg = event.message;
+	if (typeof userId !== "string" || msg === void 0) return null;
+	if (msg.message_type !== "text" || 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;
+	let text;
+	try {
+		const parsed = JSON.parse(msg.content);
+		if (typeof parsed.text !== "string") return null;
+		text = stripMentionPlaceholders(parsed.text);
+	} catch {
+		return null;
+	}
+	if (text.length === 0) return null;
+	return {
+		messageId: msg.message_id,
+		chatId: msg.chat_id,
+		chatType: msg.chat_type,
+		userId,
+		text
+	};
+}
+/** message_id 去重（飞书会重推）；FIFO 容量淘汰。 */
+var MessageDedup = class {
+	cap;
+	seen = /* @__PURE__ */ new Set();
+	order = [];
+	constructor(cap = 1e3) {
+		this.cap = cap;
+	}
+	/** true = 新消息。 */
+	check(id) {
+		if (this.seen.has(id)) return false;
+		this.seen.add(id);
+		this.order.push(id);
+		if (this.order.length > this.cap) this.seen.delete(this.order.shift());
+		return true;
+	}
+};
+//#endregion
+//#region src/channels/feishu/cards.ts
+const STATUS_ELEMENT_ID = "status";
+/** create 未返回真实 card_id 前的占位哨兵（executor 赋值；防并发 flush 重复建卡）。 */
+const PENDING_CARD_ID = "__pending__";
+/** 过程区截尾后的头部省略标记。 */
+const PROCESS_OMITTED = "…（已省略前文）\n";
+/** 输出中状态行文案。 */
+const STATUS_STREAMING = "⏳ 输出中…";
+/** 定格状态行文案。 */
+const STATUS_FINAL = {
+	done: "✅ 输出完成",
+	error: "❌ 输出出错",
+	cancelled: "⏹ 已取消"
+};
+/** 新卡固定开销字节数（状态行 + 结构，粗算进预算）。 */
+const CARD_FIXED_BYTES = 64;
+/** 单卡组件数安全上限（飞书硬上限 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;
+	const budget = maxBytes - Buffer.byteLength(PROCESS_OMITTED, "utf8");
+	if (budget <= 0) throw new Error(`processMaxBytes=${maxBytes} 过小，连省略标记都容纳不了`);
+	let lo = 0;
+	let hi = text.length;
+	while (lo < hi) {
+		const mid = Math.floor((lo + hi) / 2);
+		if (Buffer.byteLength(text.slice(mid), "utf8") <= budget) hi = mid;
+		else lo = mid + 1;
+	}
+	let cut = lo;
+	if (cut < text.length) {
+		const code = text.charCodeAt(cut);
+		if (code >= 56320 && code <= 57343) cut += 1;
+	}
+	return PROCESS_OMITTED + text.slice(cut);
+}
+/** 新卡：仅状态行的流式卡；段后续经插入组件 API 动态加入。 */
+function buildCardJson() {
+	return JSON.stringify({
+		schema: "2.0",
+		config: {
+			streaming_mode: true,
+			summary: { content: "生成中…" },
+			streaming_config: {
+				print_frequency_ms: { default: 70 },
+				print_step: { default: 1 },
+				print_strategy: "fast"
+			}
+		},
+		body: { elements: [{
+			tag: "markdown",
+			content: STATUS_STREAMING,
+			element_id: STATUS_ELEMENT_ID
+		}] }
+	});
+}
+/** 段元素 JSON（insert op 负载）：process = 默认收起折叠面板；text = 纯 markdown。 */
+function buildSegmentJson(kind, elementId, content) {
+	if (kind === "process") return JSON.stringify({
+		tag: "collapsible_panel",
+		expanded: false,
+		header: { title: {
+			tag: "plain_text",
+			content: "思考与工具调用过程"
+		} },
+		elements: [{
+			tag: "markdown",
+			content,
+			element_id: elementId
+		}]
+	});
+	return JSON.stringify({
+		tag: "markdown",
+		content,
+		element_id: elementId
+	});
+}
+const initialStreamState = () => ({
+	cardId: null,
+	seq: 0,
+	cardBytes: 0,
+	cardElements: 0,
+	segCounter: 0,
+	closedSegCount: 0,
+	tail: void 0,
+	carry: void 0
+});
+/** 把段序列的新增部分同步到卡片；新段 insert 到状态行之前，尾段增长走元素 update，满卡关流开续卡。 */
+function planSync(state, segments, maxBytes, processMaxBytes) {
+	const ops = [];
+	let { cardId, seq, cardBytes, cardElements, segCounter, closedSegCount, tail, carry } = state;
+	const ensureCard = () => {
+		if (cardId !== null) return;
+		ops.push({
+			type: "create",
+			cardJson: buildCardJson()
+		});
+		ops.push({ type: "send" });
+		cardId = PENDING_CARD_ID;
+		seq = 0;
+		cardBytes = CARD_FIXED_BYTES;
+		cardElements = 1;
+	};
+	const closeCard = () => {
+		seq += 1;
+		ops.push({
+			type: "settings",
+			streaming: false,
+			sequence: seq
+		});
+		cardId = null;
+		tail = void 0;
+	};
+	let i = tail?.segIndex ?? closedSegCount;
+	while (i < segments.length) {
+		const seg = segments[i];
+		const content = seg.kind === "process" ? sliceTailByBytes(seg.content, processMaxBytes) : seg.content;
+		const base = tail !== void 0 && tail.segIndex === i ? tail.base : carry?.segIndex === i ? carry.base : 0;
+		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");
+				if (cardBytes + delta <= maxBytes) {
+					seq += 1;
+					ops.push({
+						type: "update",
+						elementId: tail.elementId,
+						content: elementContent,
+						sequence: seq
+					});
+					cardBytes += delta;
+					tail = {
+						...tail,
+						shownText: elementContent
+					};
+				} else if (seg.kind === "text") {
+					const piece = sliceByBytes(elementContent, Buffer.byteLength(tail.shownText, "utf8") + (maxBytes - cardBytes));
+					if (piece.length > tail.shownText.length) {
+						seq += 1;
+						ops.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,
+						base: tail.base + tail.shownText.length
+					};
+					closeCard();
+					continue;
+				} else {
+					closeCard();
+					continue;
+				}
+			}
+			if (i === segments.length - 1) break;
+			tail = void 0;
+			closedSegCount = i + 1;
+			carry = void 0;
+			i += 1;
+			continue;
+		}
+		if (seg.kind === "process") {
+			const windowBytes = Buffer.byteLength(elementContent, "utf8");
+			if (cardId !== null && (cardBytes + windowBytes > 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;
+			cardElements += 2;
+			tail = {
+				segIndex: i,
+				elementId,
+				base: 0,
+				shownText: elementContent
+			};
+		} else {
+			if (elementContent.length === 0) {
+				closedSegCount = i + 1;
+				carry = void 0;
+				i += 1;
+				continue;
+			}
+			if (cardId !== null && cardElements + 1 > CARD_ELEMENT_LIMIT) {
+				closeCard();
+				continue;
+			}
+			ensureCard();
+			const piece = sliceByBytes(elementContent, maxBytes - cardBytes);
+			if (piece.length === 0) throw new Error(`cardMaxBytes=${maxBytes} 过小，扣固定开销后连一个字符都容纳不了`);
+			segCounter += 1;
+			const elementId = `seg_${segCounter}`;
+			seq += 1;
+			ops.push({
+				type: "insert",
+				elementJson: buildSegmentJson("text", elementId, piece),
+				sequence: seq
+			});
+			cardBytes += Buffer.byteLength(piece, "utf8");
+			cardElements += 1;
+			tail = {
+				segIndex: i,
+				elementId,
+				base,
+				shownText: piece
+			};
+			if (piece.length < elementContent.length) {
+				carry = {
+					segIndex: i,
+					base: base + piece.length
+				};
+				closeCard();
+				continue;
+			}
+		}
+		carry = void 0;
+		if (i === segments.length - 1) break;
+		tail = void 0;
+		closedSegCount = i + 1;
+		i += 1;
+	}
+	return {
+		state: {
+			cardId,
+			seq,
+			cardBytes,
+			cardElements,
+			segCounter,
+			closedSegCount,
+			tail,
+			carry
+		},
+		ops
+	};
+}
+/** 定格：先 update 状态行（流式还开着），再关闭 + summary。 */
+function planFinalize(state, status) {
+	if (state.cardId === null) return { ops: [] };
+	return { ops: [{
+		type: "update",
+		elementId: STATUS_ELEMENT_ID,
+		content: STATUS_FINAL[status],
+		sequence: state.seq + 1
+	}, {
+		type: "settings",
+		streaming: false,
+		sequence: state.seq + 2,
+		summary: STATUS_FINAL[status]
+	}] };
+}
+//#endregion
+//#region src/channels/feishu/reply.ts
+/** 指数退避重试（默认 3 次，300ms 起）。 */
+async function withRetry(fn, attempts = 3, baseDelayMs = 300) {
+	let lastError;
+	for (let i = 0; i < attempts; i++) try {
+		return await fn();
+	} catch (error) {
+		lastError = error;
+		if (i < attempts - 1) await new Promise((resolve) => setTimeout(resolve, baseDelayMs * 2 ** i));
+	}
+	throw lastError;
+}
+var FeishuReplyHandle = class {
+	api;
+	chatId;
+	tunables;
+	log;
+	state = initialStreamState();
+	segments = [];
+	tail = Promise.resolve();
+	timer;
+	finalized = false;
+	constructor(api, chatId, tunables, log) {
+		this.api = api;
+		this.chatId = chatId;
+		this.tunables = tunables;
+		this.log = log;
+	}
+	/** 惰性建卡：无文本输出的 turn 不产生空卡片。 */
+	beginTurn() {
+		return Promise.resolve();
+	}
+	update(segments) {
+		if (this.finalized) return Promise.resolve();
+		this.segments = segments;
+		if (this.timer === void 0) this.timer = setTimeout(() => {
+			this.timer = void 0;
+			this.flush();
+		}, this.tunables.cardUpdateThrottleMs);
+		return Promise.resolve();
+	}
+	async finalize(status, detail) {
+		if (this.finalized) {
+			await this.tail;
+			return;
+		}
+		this.finalized = true;
+		if (this.timer !== void 0) {
+			clearTimeout(this.timer);
+			this.timer = void 0;
+		}
+		this.flush();
+		await this.tail;
+		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));
+		await this.tail;
+	}
+	notice(text) {
+		this.enqueue(() => withRetry(() => this.api.sendText(this.chatId, text)).then(() => void 0));
+		return this.tail.then(() => void 0);
+	}
+	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));
+	}
+	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));
+	}
+};
+/** 「处理中」表情：加上后返回删除 disposer；加/删失败都静默（表情残留无害）。 */
+function makeAck(api, messageId, emojiType) {
+	return async () => {
+		try {
+			const reactionId = await api.addReaction(messageId, emojiType);
+			return () => {
+				api.removeReaction(messageId, reactionId).catch(() => void 0);
+			};
+		} catch {
+			return;
+		}
+	};
+}
+//#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.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);
+			io.onMessage({
+				botId: bot.record.id,
+				chatId: parsed.chatId,
+				userId: parsed.userId,
+				messageId: parsed.messageId,
+				text: parsed.text,
+				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
+		};
+	}
+};
+//#endregion
+//#region src/bots/store.ts
+/** project-bot 存储域声明：身份、版本、记录 zod schema 的单一来源。 */
+/** 飞书自建应用 appId 形态（WSClient 同款校验）。 */
+const FEISHU_APP_ID_RE = /^cli_[0-9a-fA-F]{16}$/;
+/** CredentialRef 字符集（credentials 服务 credentialRef() 的校验规则）。 */
+const CREDENTIAL_REF_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** bot id：小写 slug。 */
+const BOT_ID_RE = /^[a-z][a-z0-9-]{0,31}$/;
+const FeishuConfigSchema = z$1.object({
+	appId: z$1.string().regex(FEISHU_APP_ID_RE),
+	appSecretRef: z$1.string().regex(CREDENTIAL_REF_RE)
+});
+const BotRecordSchema = z$1.object({
+	id: z$1.string().regex(BOT_ID_RE),
+	name: z$1.string().min(1).max(64),
+	channel: z$1.literal("feishu"),
+	feishu: FeishuConfigSchema,
+	/** 绑定项目（agent 的 cwd，绝对路径）。一 bot 一项目。 */
+	project: z$1.string().min(1),
+	/** 透传到 agent 创作期的 persona 提示段。 */
+	persona: z$1.string().max(8e3).optional(),
+	/** 绑定的 Agent（'main' 或注册表角色 id，缺省 = 'main'）。 */
+	agentRef: z$1.string().min(1).optional(),
+	/** 可用工具白名单（缺省 = 不限制）；空数组无意义，直接拒绝。 */
+	tools: z$1.array(z$1.string().min(1)).min(1).optional(),
+	agentOptions: z$1.object({
+		provider: z$1.string().min(1).optional(),
+		model: z$1.string().min(1).optional()
+	}).optional(),
+	createdAt: z$1.number().int().nonnegative(),
+	updatedAt: z$1.number().int().nonnegative()
+});
+const BindingSchema = z$1.object({ sessionId: z$1.string().min(1) });
+/** domain 名受 UNIT_NAME_RE 约束（^[a-z][a-z0-9_]*$），不允许连字符。 */
+const projectBotDomain = defineDomain({
+	name: "project_bot",
+	version: 1,
+	tables: {
+		bots: domainTable(BotRecordSchema),
+		bindings: domainTable(BindingSchema)
+	}
+});
+/** bindings 表 key：(botId, chatId) → sessionId。 */
+function bindingKey(botId, chatId) {
+	return `${botId}:${chatId}`;
+}
+//#endregion
+//#region src/channels/inbound.ts
+/** 入站：指令分流 → 路由 → 单 in-flight 准入 → 表情回复 → followup 投递。 */
+var Inbound = class {
+	deps;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	onMessage(msg) {
+		this.handle(msg).catch(async (error) => {
+			this.deps.onError(`[project-bot] 入站处理失败：${error instanceof Error ? error.message : String(error)}`);
+			await msg.reply.notice("处理失败，请稍后再试").catch(() => void 0);
+		});
+	}
+	async handle(msg) {
+		const bot = this.deps.bots.get(msg.botId);
+		if (bot === void 0) return;
+		const directive = parseDirective(msg.text);
+		if (directive === "new") {
+			await this.deps.router.reset(bot, msg.chatId, msg.reply);
+			await msg.reply.notice("已开启新会话");
+			return;
+		}
+		if (directive === "stop") {
+			const rt = this.deps.router.lookup(bot.id, msg.chatId);
+			if (rt?.inflight !== void 0) {
+				rt.agent.cancel();
+				await msg.reply.notice("已请求停止当前任务");
+			} else await msg.reply.notice("当前没有进行中的任务");
+			return;
+		}
+		if (directive === "status") {
+			const rt = this.deps.router.lookup(bot.id, msg.chatId);
+			await msg.reply.notice(rt === void 0 ? `项目：${bot.project}\n会话：未创建（发送消息即创建）` : `项目：${bot.project}\n会话：${rt.sessionId}\n状态：${rt.inflight !== void 0 ? "处理中" : "空闲"}`);
+			return;
+		}
+		const rt = await this.deps.router.ensure(bot, msg.chatId, msg.reply);
+		if (rt.inflight !== void 0) {
+			await msg.reply.notice("上一条还在处理中，请稍候（或发送 /stop 取消）");
+			return;
+		}
+		rt.inflight = { ack: void 0 };
+		rt.inflight.ack = await msg.ackProcessing().catch(() => void 0) ?? void 0;
+		const message = createUserMessage({
+			content: [{
+				type: "text",
+				text: msg.text
+			}],
+			source: { kind: "user" }
+		});
+		try {
+			rt.agent.followup(message);
+		} catch (error) {
+			const ack = rt.inflight.ack;
+			rt.inflight = void 0;
+			await ack?.();
+			throw error;
+		}
+	}
+};
+/** 向段序列追加内容：与尾段同类则合并，异类开新段。 */
+function appendToSegments(segments, kind, text) {
+	const tail = segments[segments.length - 1];
+	if (tail !== void 0 && tail.kind === kind) tail.content += text;
+	else segments.push({
+		kind,
+		content: text
+	});
+}
+function mapTurnEnd(reason) {
+	if (reason.kind === "completed") return "done";
+	if (reason.kind === "aborted" || reason.kind === "interrupted") return "cancelled";
+	return "error";
+}
+/** 截断错误摘要到 max 字符，超出追加省略号。 */
+function truncateDetail(text, max) {
+	return text.length > max ? `${text.slice(0, max)}…` : text;
+}
+/** 从 turn/end reason 提取错误摘要；非 error 或无 message 返回 undefined。 */
+function errorDetailOf(reason, max) {
+	if (reason.kind !== "error") return void 0;
+	const message = reason.error?.message;
+	return truncateDetail(typeof message === "string" && message.length > 0 ? message : "未知错误", max);
+}
+var Outbound = class {
+	sessions;
+	onError;
+	maxErrorDetailChars;
+	constructor(sessions, onError, maxErrorDetailChars = 500) {
+		this.sessions = sessions;
+		this.onError = onError;
+		this.maxErrorDetailChars = maxErrorDetailChars;
+	}
+	handleSessionEvent(sessionId, event) {
+		const rt = this.sessions.get(sessionId);
+		if (rt === void 0) return;
+		if (event.type === "turn/start") {
+			rt.turn = {
+				n: event.data.turn,
+				segments: [],
+				began: false
+			};
+			return;
+		}
+		if (event.type === "assistant/chunk") {
+			const turn = rt.turn;
+			if (turn === void 0 || turn.n !== event.data.turn) return;
+			const chunk = event.data.chunk;
+			if (chunk.type === "text-delta" && typeof chunk.text === "string") appendToSegments(turn.segments, "text", chunk.text);
+			else if (chunk.type === "reasoning-delta" && typeof chunk.text === "string") appendToSegments(turn.segments, "process", chunk.text);
+			else if (chunk.type === "block-end" && chunk.block?.type === "reasoning" && turn.segments[turn.segments.length - 1]?.kind === "process") appendToSegments(turn.segments, "process", "\n\n");
+			else return;
+			const snapshot = turn.segments.map((s) => ({ ...s }));
+			this.enqueue(rt, async () => {
+				if (rt.reply === void 0) return;
+				if (!turn.began) {
+					await rt.reply.beginTurn();
+					turn.began = true;
+				}
+				await rt.reply.update(snapshot);
+			});
+			return;
+		}
+		if (event.type === "tool/call") {
+			const turn = rt.turn;
+			if (turn === void 0 || turn.n !== event.data.turn) return;
+			const name = event.data.name;
+			const args = typeof event.data.arguments === "string" ? event.data.arguments : JSON.stringify(event.data.arguments ?? {});
+			appendToSegments(turn.segments, "process", `🔧 ${name} — ${truncateDetail(args, 120)}\n\n`);
+			const snapshot = turn.segments.map((s) => ({ ...s }));
+			this.enqueue(rt, async () => {
+				if (rt.reply === void 0) return;
+				if (!turn.began) {
+					await rt.reply.beginTurn();
+					turn.began = true;
+				}
+				await rt.reply.update(snapshot);
+			});
+			return;
+		}
+		if (event.type === "turn/end") {
+			const turn = rt.turn;
+			if (turn === void 0 || turn.n !== event.data.turn) return;
+			const reason = event.data.reason;
+			const status = mapTurnEnd(reason);
+			const detail = errorDetailOf(reason, this.maxErrorDetailChars);
+			this.enqueue(rt, async () => {
+				if ((turn.began || detail !== void 0) && rt.reply !== void 0) await rt.reply.finalize(status, detail);
+				const ack = rt.inflight?.ack;
+				rt.inflight = void 0;
+				if (ack !== void 0) await ack();
+			});
+			rt.turn = void 0;
+		}
+	}
+	/**
+	* turn 外错误（agent/error：resume/驱动边界失败等没有 turn/end 的场景）：
+	* notice 错误摘要并释放 inflight 槽 + 删除表情；turn 进行中的错误由 turn/end 报告，跳过防双发。
+	*/
+	handleAgentError(sessionId, errorText) {
+		const rt = this.sessions.get(sessionId);
+		if (rt === void 0 || rt.turn !== void 0) return;
+		const detail = truncateDetail(errorText, this.maxErrorDetailChars);
+		this.enqueue(rt, async () => {
+			if (rt.reply !== void 0) await rt.reply.notice(`出错了：${detail}`);
+			const ack = rt.inflight?.ack;
+			rt.inflight = void 0;
+			if (ack !== void 0) await ack();
+		});
+	}
+	enqueue(rt, task) {
+		rt.tail = rt.tail.then(task).catch((error) => {
+			this.onError(`[project-bot] 出站处理失败：${error instanceof Error ? error.message : String(error)}`);
+		});
+	}
+};
+//#endregion
+//#region src/channels/ports.ts
+/** 从 bot 记录提取创作期注入（主 Agent 绑定形态）。 */
+function hooksOf(bot) {
+	return {
+		...bot.persona !== void 0 ? { persona: bot.persona } : {},
+		...bot.tools !== void 0 ? { tools: bot.tools } : {}
+	};
+}
+//#endregion
+//#region src/channels/router.ts
+/** 绑定路由：(botId, chatId) → 长期会话；create / resume / reset。 */
+var Router = class {
+	agents;
+	bindings;
+	sessions;
+	defaultModel;
+	workspace;
+	onWarn;
+	registry;
+	constructor(agents, bindings, sessions, defaultModel, workspace, onWarn, registry) {
+		this.agents = agents;
+		this.bindings = bindings;
+		this.sessions = sessions;
+		this.defaultModel = defaultModel;
+		this.workspace = workspace;
+		this.onWarn = onWarn;
+		this.registry = registry;
+	}
+	/** 取（或建/恢复）该 chat 的会话 runtime；reply 刷新为最近一次入站携带的句柄。 */
+	async ensure(bot, chatId, reply) {
+		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;
+			}
+			const agent = await this.agents.resume({
+				sessionId: bound,
+				...this.resolveSession(bot)
+			});
+			await this.attach(bot.project, bound);
+			return this.adopt(bot.id, chatId, bound, agent, reply);
+		}
+		const sessionId = randomUUID();
+		const agent = await this.agents.create({
+			sessionId,
+			cwd: bot.project,
+			...this.resolveSession(bot)
+		});
+		await this.bindings.set(bot.id, chatId, sessionId);
+		await this.attach(bot.project, sessionId);
+		return this.adopt(bot.id, chatId, sessionId, agent, reply);
+	}
+	/** attach 失败仅告警（会话降级为未分组），不阻塞消息处理。 */
+	async attach(cwd, sessionId) {
+		try {
+			await this.workspace.attach(cwd, sessionId);
+		} catch (error) {
+			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();
+	}
+	/**
+	* 按 bot.agentRef 解析会话组装（agentOptions + 创作期 hooks）：
+	* - 缺省/指向 main → 主 Agent 形态：bot 自带 persona/tools + 默认模型回退；
+	* - 指向角色 → 角色形态：persona 单 section + tools.restrict + role.model；
+	* - 指向不存在角色 → warn 并降级为主 Agent 形态。
+	*/
+	resolveSession(bot) {
+		const ref = bot.agentRef ?? "main";
+		const role = this.registry.get(ref);
+		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),
+				hooks: hooksOf(bot)
+			};
+		}
+		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: {
+				...sections.length > 0 ? { sections } : {},
+				...role.tools !== void 0 ? { tools: role.tools.allow } : {}
+			}
+		};
+	}
+	/** /new：取消旧会话、清绑定、开新会话。 */
+	async reset(bot, chatId, reply) {
+		const bound = this.bindings.get(bot.id, chatId);
+		if (bound !== void 0) {
+			this.sessions.get(bound)?.agent.cancel();
+			this.sessions.delete(bound);
+			await this.bindings.delete(bot.id, chatId);
+		}
+		return this.ensure(bot, chatId, reply);
+	}
+	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) {
+		const rt = {
+			botId,
+			chatId,
+			sessionId,
+			agent,
+			reply,
+			inflight: void 0,
+			tail: Promise.resolve(),
+			turn: void 0
+		};
+		this.sessions.set(sessionId, rt);
+		return rt;
+	}
+};
+//#endregion
+//#region src/channels/runtime.ts
+var BotRuntime = class {
+	deps;
+	sessions = /* @__PURE__ */ new Map();
+	router;
+	inbound;
+	outbound;
+	handles = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+		const bindingStore = this.bindingStore();
+		this.router = new Router(deps.agents, bindingStore, this.sessions, deps.defaultModel, deps.workspace, (m) => deps.log.warn(m), deps.registry);
+		this.inbound = new Inbound({
+			router: this.router,
+			bots: deps.bots,
+			onError: (m) => deps.log.warn(m)
+		});
+		this.outbound = new Outbound(this.sessions, (m) => deps.log.warn(m), deps.maxErrorDetailChars);
+	}
+	async startAll() {
+		for (const botId of [...this.deps.bots.keys()]) await this.reconcile(botId);
+	}
+	/** 按最新记录重建该 bot 的渠道（创建/更新后调用；记录已删则纯停止）。 */
+	async reconcile(botId) {
+		await this.stopChannel(botId);
+		const record = this.deps.bots.get(botId);
+		if (record === void 0) return;
+		if (!this.deps.validateProject(record.project)) {
+			this.deps.log.warn(`[project-bot] bot "${botId}" 的项目路径不可用：${record.project}`);
+			return;
+		}
+		const secret = await this.deps.resolveSecret(record.feishu.appSecretRef);
+		if (secret === void 0) {
+			this.deps.log.warn(`[project-bot] bot "${botId}" 的密钥 ${record.feishu.appSecretRef} 未配置`);
+			return;
+		}
+		const channel = this.deps.channels.get(record.channel);
+		if (channel === void 0) {
+			this.deps.log.warn(`[project-bot] bot "${botId}" 的渠道 "${record.channel}" 未实现`);
+			return;
+		}
+		try {
+			const handle = await channel.start({
+				record,
+				secret
+			}, { onMessage: (msg) => this.inbound.onMessage(msg) }, 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)}`);
+		}
+	}
+	/** 删除 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);
+		}
+		await this.bindingStore().deleteBot(botId);
+	}
+	statusOf(botId) {
+		return this.handles.get(botId)?.status() ?? "not-running";
+	}
+	/** 卸载时序：取消在飞会话 → 等 idle → drain 出站链（卡片定格）→ 断全部渠道。 */
+	async stopAll() {
+		for (const rt of this.sessions.values()) rt.agent.cancel();
+		await Promise.allSettled([...this.sessions.values()].map(async (rt) => {
+			await rt.agent.whenIdle().catch(() => void 0);
+			await rt.tail;
+		}));
+		await Promise.allSettled([...this.handles.values()].map((h) => h.close()));
+		this.handles.clear();
+	}
+	async stopChannel(botId) {
+		const handle = this.handles.get(botId);
+		if (handle === void 0) return;
+		this.handles.delete(botId);
+		await handle.close().catch((error) => {
+			this.deps.log.warn(`[project-bot] bot "${botId}" 渠道关闭异常：${error instanceof Error ? error.message : String(error)}`);
+		});
+	}
+	bindingStore() {
+		const { bindings } = this.deps;
+		return {
+			get: (b, c) => bindings.get(bindingKey(b, c))?.sessionId,
+			set: async (b, c, s) => {
+				await bindings.put(bindingKey(b, c), { sessionId: s });
+			},
+			delete: async (b, c) => {
+				await bindings.delete(bindingKey(b, c));
+			},
+			deleteBot: async (b) => {
+				for (const key of [...bindings.keys()]) if (key.startsWith(`${b}:`)) await bindings.delete(key);
+			}
+		};
+	}
+};
+//#endregion
+//#region src/bots/api.ts
+/** 浏览器半 RPC：单前缀路由 /dsh-agent-toolkit/api/bots + 内部路径分发。 */
+const MAX_BODY_BYTES = 65536;
+const CreateBodySchema = z$1.object({
+	/** 缺省时后端自动生成（bot-<8 位随机小写字母数字>）。 */
+	id: z$1.string().regex(BOT_ID_RE).optional(),
+	name: z$1.string().min(1).max(64),
+	project: z$1.string().min(1),
+	persona: z$1.string().max(8e3).optional(),
+	/** 绑定的 Agent（'main' 或注册表角色 id；缺省 = main）。 */
+	agentRef: z$1.string().min(1).optional(),
+	tools: z$1.array(z$1.string().min(1)).min(1).optional(),
+	agentOptions: z$1.object({
+		provider: z$1.string().min(1).optional(),
+		model: z$1.string().min(1).optional()
+	}).optional(),
+	feishu: z$1.object({
+		appId: z$1.string().regex(FEISHU_APP_ID_RE),
+		/** 手动填写路径：明文密钥（立即入 credentials，不落表）。 */
+		appSecret: z$1.string().min(1).optional(),
+		/** 扫码路径：registerApp 已入库，直接给引用。 */
+		appSecretRef: z$1.string().optional()
+	})
+});
+const UpdateBodySchema = 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(),
+	agentRef: z$1.string().min(1).nullable().optional(),
+	tools: z$1.array(z$1.string().min(1)).min(1).nullable().optional(),
+	agentOptions: z$1.object({
+		provider: z$1.string().min(1).optional(),
+		model: z$1.string().min(1).optional()
+	}).nullable().optional(),
+	/** 换绑应用：明文新密钥（立即入 credentials）。 */
+	feishu: z$1.object({
+		appId: z$1.string().regex(FEISHU_APP_ID_RE),
+		appSecret: z$1.string().min(1)
+	}).optional()
+});
+function json(res, code, body) {
+	res.writeHead(code, { "content-type": "application/json" }).end(JSON.stringify(body));
+}
+const ID_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
+/** 生成 bot-<8 位随机小写字母数字>（符合 BOT_ID_RE）；与现有 id 冲突时重试。 */
+function generateBotId(occupied) {
+	for (;;) {
+		const bytes = randomBytes(8);
+		let id = "bot-";
+		for (let i = 0; i < 8; i++) id += ID_CHARS[bytes[i] % 36];
+		if (!occupied(id)) return id;
+	}
+}
+/** 读 JSON body；超限 413 / 非法 JSON 400（已写响应时返回 undefined）。 */
+async function readJsonBody(req, res) {
+	const chunks = [];
+	let received = 0;
+	for await (const chunk of req) {
+		const buffer = chunk;
+		received += buffer.byteLength;
+		if (received > MAX_BODY_BYTES) {
+			json(res, 413, { error: "body too large" });
+			req.destroy();
+			return;
+		}
+		chunks.push(buffer);
+	}
+	try {
+		return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+	} catch {
+		json(res, 400, { error: "invalid JSON body" });
+		return;
+	}
+}
+function createApiHandler(deps) {
+	return async (req, res) => {
+		const url = new URL(req.url ?? "/", "http://127.0.0.1");
+		const sub = url.pathname.replace(/^\/dsh-agent-toolkit\/api\/bots/, "") || "/";
+		const method = req.method ?? "GET";
+		if (sub === "/bots" && method === "GET") {
+			json(res, 200, { bots: [...deps.bots.entries()].map(([, record]) => ({
+				...record,
+				status: deps.runtime.statusOf(record.id)
+			})) });
+			return;
+		}
+		if (sub === "/bots" && method === "POST") {
+			const body = await readJsonBody(req, res);
+			if (body === void 0) return;
+			const parsed = CreateBodySchema.safeParse(body);
+			if (!parsed.success) {
+				json(res, 400, { error: parsed.error.issues[0]?.message ?? "invalid body" });
+				return;
+			}
+			const input = parsed.data;
+			const id = input.id ?? generateBotId((candidate) => deps.bots.get(candidate) !== void 0);
+			if (deps.bots.get(id) !== void 0) {
+				json(res, 409, { error: `bot id "${id}" 已存在` });
+				return;
+			}
+			for (const [, existing] of deps.bots.entries()) if (existing.feishu.appId === input.feishu.appId) {
+				json(res, 409, { error: `appId 已被 bot "${existing.id}" 使用` });
+				return;
+			}
+			if (!deps.validateProject(input.project)) {
+				json(res, 400, { error: `项目路径不可用：${input.project}` });
+				return;
+			}
+			let appSecretRef = input.feishu.appSecretRef;
+			if (appSecretRef === void 0) {
+				if (input.feishu.appSecret === void 0) {
+					json(res, 400, { error: "缺少 appSecret 或 appSecretRef" });
+					return;
+				}
+				appSecretRef = await deps.storeSecret(id, input.feishu.appSecret);
+			}
+			const record = BotRecordSchema.parse({
+				id,
+				name: input.name,
+				channel: "feishu",
+				feishu: {
+					appId: input.feishu.appId,
+					appSecretRef
+				},
+				project: input.project,
+				...input.persona !== void 0 ? { persona: input.persona } : {},
+				...input.agentRef !== void 0 ? { agentRef: input.agentRef } : {},
+				...input.tools !== void 0 ? { tools: input.tools } : {},
+				...input.agentOptions !== void 0 ? { agentOptions: input.agentOptions } : {},
+				createdAt: deps.now(),
+				updatedAt: deps.now()
+			});
+			await deps.bots.put(record.id, record);
+			await deps.runtime.reconcile(record.id);
+			json(res, 200, { bot: {
+				...record,
+				status: deps.runtime.statusOf(record.id)
+			} });
+			return;
+		}
+		if (sub === "/bots" && method === "PUT") {
+			const id = url.searchParams.get("id") ?? "";
+			const existing = deps.bots.get(id);
+			if (existing === void 0) {
+				json(res, 404, { error: `bot "${id}" 不存在` });
+				return;
+			}
+			const body = await readJsonBody(req, res);
+			if (body === void 0) return;
+			const parsed = UpdateBodySchema.safeParse(body);
+			if (!parsed.success) {
+				json(res, 400, { error: parsed.error.issues[0]?.message ?? "invalid body" });
+				return;
+			}
+			const input = parsed.data;
+			let feishu = existing.feishu;
+			if (input.feishu !== void 0) feishu = {
+				appId: input.feishu.appId,
+				appSecretRef: await deps.storeSecret(id, input.feishu.appSecret)
+			};
+			const project = input.project ?? existing.project;
+			if (!deps.validateProject(project)) {
+				json(res, 400, { error: `项目路径不可用：${project}` });
+				return;
+			}
+			const merged = {
+				...existing,
+				...input.name !== void 0 ? { name: input.name } : {},
+				project,
+				feishu,
+				updatedAt: deps.now()
+			};
+			if (input.persona === null) delete merged.persona;
+			else if (input.persona !== void 0) merged.persona = input.persona;
+			if (input.agentRef === null) delete merged.agentRef;
+			else if (input.agentRef !== void 0) merged.agentRef = input.agentRef;
+			if (input.tools === null) delete merged.tools;
+			else if (input.tools !== void 0) merged.tools = input.tools;
+			if (input.agentOptions === null) delete merged.agentOptions;
+			else if (input.agentOptions !== void 0) merged.agentOptions = input.agentOptions;
+			const record = BotRecordSchema.parse(merged);
+			await deps.bots.put(id, record);
+			await deps.runtime.reconcile(id);
+			json(res, 200, { bot: {
+				...record,
+				status: deps.runtime.statusOf(id)
+			} });
+			return;
+		}
+		if (sub === "/bots" && method === "DELETE") {
+			const id = url.searchParams.get("id") ?? "";
+			const existing = deps.bots.get(id);
+			if (existing === void 0) {
+				json(res, 404, { error: `bot "${id}" 不存在` });
+				return;
+			}
+			await deps.runtime.stopBot(id);
+			await deps.bots.delete(id);
+			await deps.deleteSecret(existing.feishu.appSecretRef);
+			json(res, 200, { ok: true });
+			return;
+		}
+		if (sub === "/register-app" && method === "POST") {
+			json(res, 200, { id: deps.registerApp.start() });
+			return;
+		}
+		if (sub === "/register-app/status" && method === "GET") {
+			const id = url.searchParams.get("id") ?? "";
+			const state = deps.registerApp.get(id);
+			if (state === void 0) {
+				json(res, 404, { error: "register session 不存在" });
+				return;
+			}
+			json(res, 200, { state });
+			return;
+		}
+		if (sub === "/tools" && method === "GET") {
+			json(res, 200, { tools: deps.listTools() });
+			return;
+		}
+		if (sub === "/providers" && method === "GET") {
+			json(res, 200, { providers: deps.listProviders() });
+			return;
+		}
+		if (sub === "/models" && method === "GET") {
+			let models = [];
+			try {
+				models = await deps.listModels(url.searchParams.get("provider") ?? "");
+			} catch {
+				models = [];
+			}
+			json(res, 200, { models });
+			return;
+		}
+		if ([
+			"/bots",
+			"/register-app",
+			"/register-app/status",
+			"/tools",
+			"/providers",
+			"/models"
+		].includes(sub)) {
+			json(res, 405, { error: "method not allowed" });
+			return;
+		}
+		json(res, 404, { error: "not found" });
+	};
+}
+//#endregion
+//#region src/bots/register-app.ts
+/** 扫码一键创建飞书应用：lark.registerApp（OAuth 2.0 Device Authorization Grant）的状态机封装。 */
+var RegisterAppService = class {
+	deps;
+	sessions = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** 发起一轮扫码创建；返回轮询 id。 */
+	start() {
+		const id = (this.deps.newId ?? randomUUID)();
+		const controller = new AbortController();
+		const entry = {
+			state: { status: "pending" },
+			controller,
+			timer: setTimeout(() => {
+				controller.abort();
+			}, this.deps.timeoutMs)
+		};
+		this.sessions.set(id, entry);
+		this.deps.registerApp({
+			signal: controller.signal,
+			onQRCodeReady: (info) => {
+				entry.state = {
+					status: "pending",
+					url: info.url,
+					expireIn: info.expireIn
+				};
+			}
+		}).then(async (result) => {
+			const credentialRef = await this.deps.storeSecret(result.client_id, result.client_secret);
+			entry.state = {
+				status: "done",
+				appId: result.client_id,
+				credentialRef
+			};
+		}).catch((error) => {
+			const e = error;
+			entry.state = {
+				status: "error",
+				code: typeof e.code === "string" ? e.code : "unknown",
+				...typeof e.description === "string" ? { description: e.description } : {}
+			};
+		}).finally(() => {
+			clearTimeout(entry.timer);
+		});
+		return id;
+	}
+	get(id) {
+		return this.sessions.get(id)?.state;
+	}
+	/** 卸载：中断全部进行中的轮询。 */
+	dispose() {
+		for (const entry of this.sessions.values()) {
+			entry.controller.abort();
+			clearTimeout(entry.timer);
+		}
+		this.sessions.clear();
+	}
+};
+//#endregion
+//#region src/bots/index.ts
+/** bots 模块：项目机器人（飞书渠道）——多 bot 作为项目 agent 的交互入口（project-bot Node 半迁移，去 preset 化）。 */
+function setupBots(ctx, config, deps) {
+	const log = {
+		warn: (m) => ctx.logger.warn(m),
+		info: (m) => ctx.logger.info(m)
+	};
+	const channels = /* @__PURE__ */ new Map([["feishu", feishuChannel]]);
+	const tunables = {
+		cardUpdateThrottleMs: config.cardUpdateThrottleMs,
+		cardMaxBytes: config.cardMaxBytes,
+		processMaxBytes: config.processMaxBytes,
+		processingReactionEmoji: config.processingReactionEmoji
+	};
+	const storeSecret = async (key, secret) => {
+		const ref = `project_bot_${key.replace(/[^A-Za-z0-9_]/g, "_")}`;
+		await ctx.credentials.set(credentialRef(ref), secret);
+		return ref;
+	};
+	/** 创作期注入已迁至 agent-setup.ts（基础工具 scoped 挂载 + persona/tools），preset 机制整体移除。 */
+	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)
+			}));
+		},
+		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)
+			}));
+		}
+	};
+	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 workspaceRegistry = ctx.get("workspaceRegistry", false);
+	const workspacePort = { async attach(cwd, sessionId) {
+		if (workspaceRegistry === void 0) throw new Error("workspaceRegistry 服务不可用");
+		await (await workspaceRegistry.create(cwd)).attachSession(SessionId(sessionId));
+	} };
+	let botsTable;
+	let bindingsTable;
+	let runtime;
+	let started = Promise.resolve();
+	const domainReady = openDomainSafely(ctx, projectBotDomain, (msg) => log.warn(msg), async () => {
+		await started.catch(() => void 0);
+		await runtime?.stopAll();
+	}).then((domain) => {
+		botsTable = domain.table("bots");
+		bindingsTable = domain.table("bindings");
+		return domain;
+	});
+	const registerAppService = new RegisterAppService({
+		registerApp: (options) => import("@larksuiteoapi/node-sdk").then((lark) => lark.registerApp(options)),
+		storeSecret,
+		timeoutMs: config.registerAppTimeoutMs
+	});
+	started = domainReady.then(() => {
+		runtime = new BotRuntime({
+			bots: botsTable,
+			bindings: bindingsTable,
+			agents: agentsPort,
+			registry: deps.registry,
+			defaultModel: () => {
+				const selection = ctx.agentDefaultModel.currentSelection();
+				return {
+					provider: selection.provider,
+					model: selection.model
+				};
+			},
+			workspace: workspacePort,
+			channels,
+			tunables,
+			maxErrorDetailChars: config.errorDetailMaxChars,
+			resolveSecret: async (ref) => (await ctx.credentials.resolve(credentialRef(ref)))?.value,
+			validateProject: (path) => existsSync(path),
+			log
+		});
+		return runtime.startAll();
+	});
+	started.catch((error) => {
+		log.warn(`[project-bot] 启动失败：${error instanceof Error ? error.message : String(error)}`);
+	});
+	ctx.on("session/event", (session, event) => {
+		runtime?.outbound.handleSessionEvent(String(session.header.id), event);
+	});
+	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);
+	});
+	registerOptionalRoutes(ctx, (webCtx) => {
+		const botsHandler = async (req, res) => {
+			if (runtime === void 0) throw new Error("runtime unavailable");
+			await createApiHandler({
+				bots: botsTable,
+				runtime,
+				registerApp: registerAppService,
+				listTools: () => ctx.tools.schemas().map((s) => s.name),
+				listProviders: () => ctx.llm.listProviders().map(({ id, name }) => ({
+					id,
+					name
+				})),
+				listModels: (provider) => ctx.llm.listModels(provider).then((models) => models.map(({ id, name }) => ({
+					id,
+					name
+				}))),
+				storeSecret,
+				deleteSecret: async (ref) => ctx.credentials.unset(credentialRef(ref)),
+				validateProject: (path) => existsSync(path),
+				now: () => Date.now()
+			})(req, res);
+		};
+		const dispose = webCtx.webServer.register({
+			kind: "prefix",
+			path: "/dsh-agent-toolkit/api/bots",
+			handler: async (req, res) => {
+				try {
+					await started;
+					await botsHandler(req, res);
+				} catch (error) {
+					res.writeHead(500, { "content-type": "application/json" }).end(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+				}
+			}
+		});
+		return () => dispose();
+	});
+	ctx.effect(() => async () => {
+		registerAppService.dispose();
+	});
+}
+//#endregion
+//#region src/index.ts
+const name = "dsh-agent-toolkit";
+const inject = [
+	"storageDomain",
+	"tools",
+	"subagents",
+	"systemPrompt",
+	"commands",
+	"llm",
+	"agentDefaultModel",
+	"agents",
+	"tokenMeter",
+	"credentials"
+];
+/** layers/rules 的 schemastery schema 照归档 prompt-stack/src/index.ts:21-41 逐字段平移（含 overrides transform hack）。 */
+const Config = z.object({
+	modules: z.object({
+		feishu: z.boolean().default(true),
+		usage: z.boolean().default(true)
+	}).default({
+		feishu: true,
+		usage: true
+	}),
+	layers: z.array(z.object({
+		name: z.string().required(),
+		order: z.number().required(),
+		text: z.string().required()
+	})).default(DEFAULT_LAYERS),
+	rules: z.array(z.object({
+		match: z.object({
+			provider: z.string(),
+			model: z.string(),
+			modelPattern: z.string()
+		}).required(),
+		overrides: z.transform(z.dict(z.string()), (value) => Object.keys(value).length === 0 ? void 0 : value),
+		append: z.string()
+	})).default(DEFAULT_RULES),
+	timezone: z.string().default("Asia/Shanghai"),
+	provider: z.string().default("spawn"),
+	toolName: z.string().default("team_delegate"),
+	feishu: z.object({
+		cardUpdateThrottleMs: z.number().default(500),
+		cardMaxBytes: z.number().default(28e3),
+		processMaxBytes: z.number().default(8e3),
+		registerAppTimeoutMs: z.number().default(6e5),
+		processingReactionEmoji: z.string().default("OneSecond"),
+		errorDetailMaxChars: z.number().default(500)
+	}).default({
+		cardUpdateThrottleMs: 500,
+		cardMaxBytes: 28e3,
+		processMaxBytes: 8e3,
+		registerAppTimeoutMs: 6e5,
+		processingReactionEmoji: "OneSecond",
+		errorDetailMaxChars: 500
+	})
+});
+async function apply(ctx, config) {
+	validateConfig({
+		layers: config.layers,
+		rules: config.rules
+	});
+	const warn = (msg) => ctx.logger.warn(msg);
+	const domain = await openDomainSafely(ctx, agentToolkitDomain, warn);
+	const tables = {
+		agents: domain.table("agents"),
+		meta: domain.table("meta"),
+		promptLayers: domain.table("prompt_layers")
+	};
+	const registry = await createRegistry(warn, {
+		agents: tables.agents,
+		meta: tables.meta
+	});
+	const layerSource = await openLayerSource({
+		promptLayers: tables.promptLayers,
+		meta: tables.meta
+	}, config.layers);
+	setupPrompt(ctx, {
+		source: layerSource,
+		rules: config.rules
+	});
+	setupDelegate(ctx, {
+		provider: config.provider,
+		toolName: config.toolName,
+		rules: config.rules
+	}, registry);
+	setupAgentsApi(ctx, {
+		registry,
+		listTools: () => ctx.tools.schemas().map((s) => s.name),
+		listProviders: () => ctx.llm.listProviders().map(({ id, name }) => ({
+			id,
+			name
+		})),
+		listModels: (provider) => ctx.llm.listModels(provider).then((models) => models.map(({ id, name }) => ({
+			id,
+			name
+		})))
+	});
+	setupPromptLayersApi(ctx, {
+		source: layerSource,
+		rules: config.rules,
+		seedLayers: config.layers,
+		probe: async () => {
+			const assembly = await ctx.systemPrompt.assemble({});
+			return {
+				sections: assembly.sections.map(({ name: n, text }) => ({
+					name: n,
+					text
+				})),
+				contexts: assembly.contexts.map(({ name: n, text }) => ({
+					name: n,
+					text
+				}))
+			};
+		}
+	});
+	if (config.modules.feishu) setupBots(ctx, config.feishu, { registry });
+	if (config.modules.usage) setupUsage(ctx, { timezone: config.timezone }, name);
+}
+//#endregion
+export { Config, apply, inject, name };
+
+//# sourceMappingURL=index.js.map