dsh-plugin-prompt-tool 1.0.0 → 2.0.0

package/lib/module-package-Cnd1_mwx.mjs

@@ -0,0 +1,2872 @@
+import { A as packageEngineDir, Ct as assertModuleTree, D as loadModuleSpec, Et as setModuleDefinitionId, F as resolveModuleDir, Ft as validateCustomToolIdentities, G as assertCanonicalRuleSource, H as editModuleRules, J as rulePromptConfigOptions, K as ensureModuleSlices, P as renderComposition, Q as injectionConfigSpec, St as assertModuleId, Tt as modulePathExists, U as readModuleRules, Ut as MODULES_DIR, V as withModuleDefinition, W as ModuleRulesError, Wt as MODULE_DEFINITION_FILE, X as withModuleLock, Y as validateModuleDefinitionText, Z as compileRules, bt as readModuleLayerSettings, d as assertSafeConfigId, dt as prepareStText, ft as renderStText, g as appendModuleCapabilities, gt as atomicWriteTextFile, i as promptConfigToRule, n as convertLegacyModuleRules, p as enabledModuleIds, q as loadModuleDefinition, s as appendModuleConfigOrder, v as assertCompositionArray, w as invalidateModuleSpec, wt as canonicalModulesRoot, xt as assertModuleDirectory, yt as engineParamPath } from "./rules-migration-DJ6vASB5.mjs";
+import { basename, dirname, join, posix, resolve } from "node:path";
+import { appendFileSync, cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { YAMLMap, YAMLSeq, parse, parseDocument, stringify } from "yaml";
+import { createHash } from "node:crypto";
+import { inflateSync } from "node:zlib";
+import { Uint8ArrayReader, Uint8ArrayWriter, ZipReader, ZipWriter } from "@zip.js/zip.js";
+import { parameterSchemaSpecToJsonSchema, valueSchemaSpecToJsonSchema } from "@deepseek-ai/dsh-tools";
+//#region src/shared/preset-ids.ts
+/**
+* 包内模块与用户副本共用同名 ID；避免与宿主官方预设重名。
+*
+* 内置模块随包分发在仓库根的 `modules/`。旧的内置预设 `pt-*` 已整体退场——它们是官方
+* 预设形态的遗留，重构后不再读取也不再维护；这里指向当前随包分发的内置模块作为兜底。
+*/
+const DEFAULT_MODULE_ID = "ponytail";
+//#endregion
+//#region src/host/rule-content.ts
+/** 资产工具只投影注入动作的内容；不读取旧定义或创建第二份配置源。 */
+function ruleInjections(rules = []) {
+	return rules.flatMap((rule) => rule.then.flatMap((action) => action.kind === "inject-text" ? [{
+		rule,
+		action,
+		config: injectionConfigSpec(rule, action)
+	}] : []));
+}
+/** 只替换指定注入动作载荷，保留同一卡的判断与其他动作。 */
+function mapRuleInjections(rule, map) {
+	return {
+		...rule,
+		then: rule.then.map((action) => action.kind === "inject-text" ? {
+			...action,
+			config: map(injectionConfigSpec(rule, action), action)
+		} : action)
+	};
+}
+//#endregion
+//#region src/shared/asset-transfer.ts
+/** 载体和解码后的资源集合使用同一上限。 */
+const MAX_ASSET_BYTES = 67108864;
+//#endregion
+//#region src/host/character-png.ts
+const PNG_SIGNATURE = Buffer.from("89504e470d0a1a0a", "hex");
+const MAX_PNG_CARD_BYTES = 16777216;
+function isPngBuffer(buffer) {
+	return buffer.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE);
+}
+/** host、上传入口与 CLI 共用；完整 chunk 边界及解压上限在读取时检查。 */
+function decodePngCharacterCard(buffer) {
+	if (!isPngBuffer(buffer)) throw new Error("不是有效的 PNG 文件");
+	const chunks = [];
+	let offset = PNG_SIGNATURE.length;
+	let ended = false;
+	while (offset < buffer.length) {
+		if (offset + 12 > buffer.length) throw new Error("PNG chunk 越界");
+		const length = buffer.readUInt32BE(offset);
+		const dataStart = offset + 8;
+		const dataEnd = dataStart + length;
+		if (dataEnd + 4 > buffer.length) throw new Error("PNG chunk 越界");
+		const type = buffer.toString("latin1", offset + 4, offset + 8);
+		if (type === "tEXt") {
+			const separator = buffer.indexOf(0, dataStart);
+			if (separator > dataStart && separator < dataEnd) chunks.push({
+				keyword: buffer.toString("latin1", dataStart, separator).toLowerCase(),
+				text: buffer.toString("latin1", separator + 1, dataEnd)
+			});
+		}
+		if (type === "IEND") {
+			ended = true;
+			break;
+		}
+		offset = dataEnd + 4;
+	}
+	if (!ended) throw new Error("PNG 缺少完整 IEND chunk");
+	const card = chunks.find((chunk) => chunk.keyword === "ccv3") ?? chunks.find((chunk) => chunk.keyword === "chara");
+	if (card === void 0) throw new Error("PNG 不含角色卡数据（无 chara/ccv3 tEXt chunk）");
+	if (card.text.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(card.text)) throw new Error("PNG 角色卡 base64 非法");
+	const encoded = Buffer.from(card.text, "base64");
+	if (encoded.length > MAX_PNG_CARD_BYTES) throw new Error("PNG 角色卡数据超限");
+	let decoded;
+	try {
+		decoded = inflateSync(encoded, { maxOutputLength: MAX_PNG_CARD_BYTES });
+	} catch (error) {
+		if (error.code === "ERR_BUFFER_TOO_LARGE") throw new Error("PNG 角色卡解压超限");
+		decoded = encoded;
+	}
+	const jsonText = new TextDecoder("utf-8", { fatal: true }).decode(decoded);
+	JSON.parse(jsonText);
+	return {
+		jsonText,
+		avatar: buffer
+	};
+}
+//#endregion
+//#region src/host/worldbook.ts
+/** 世界书条目 CRUD 服务：promptConfigs world-book 策略配置的增删改查。
+*  与角色卡导入（characters.applyCharacterToPreset）共用同一存储（preset.yml
+*  promptConfigs），模型工具（world_book_*）与未来 bridge 端点同源，
+*  不各自实现 parseDocument 往返。 */
+/**
+* 世界书条目结构工厂（能力归一）。
+* strategy/layer/position 固定值与 params 键集单一权威——ST 导入（sillytavern.ts）
+* 与模型工具（world_book_upsert）共用，不再各自手写条目结构。
+*/
+function buildWorldBookEntry(input) {
+	return {
+		...input.id !== void 0 ? { id: input.id } : {},
+		name: input.name,
+		strategy: "world-book",
+		order: typeof input.order === "number" ? input.order : 100,
+		text: input.text,
+		layer: "pre-step",
+		position: "before-all",
+		...input.enabled !== void 0 ? { enabled: input.enabled } : {},
+		params: {
+			constant: input.constant,
+			...input.keys !== void 0 && input.keys.length > 0 ? { keys: input.keys } : {},
+			...input.secondaryKeys !== void 0 && input.secondaryKeys.length > 0 ? { secondaryKeys: input.secondaryKeys } : {},
+			...input.caseSensitive === true ? { caseSensitive: true } : {},
+			...input.wholeWords === true ? { wholeWords: true } : {},
+			...typeof input.selectiveLogic === "number" ? { selectiveLogic: input.selectiveLogic } : {}
+		}
+	};
+}
+const isWorldBook = (config) => config !== null && typeof config === "object" && !Array.isArray(config) && config.strategy === "world-book";
+/** 当前模块全部世界书条目（保持文件顺序）。 */
+function listWorldBookEntries(moduleDir) {
+	return ruleInjections(loadModuleSpec(moduleDir).rules).flatMap(({ rule, config }) => isWorldBook(config) ? [{
+		...config,
+		enabled: rule.enabled !== false && config.enabled !== false
+	}] : []);
+}
+/** 新增或更新一条世界书条目（按 id 定位；不存在则追加）。返回写入后条目总数。 */
+function upsertWorldBookEntry(moduleDir, entry) {
+	if (entry === null || typeof entry !== "object" || typeof entry.id !== "string" || entry.id.length === 0) throw new TypeError("世界书条目必须含非空字符串 id");
+	const snapshot = readModuleRules(moduleDir);
+	const matches = ruleInjections(snapshot.rules).filter(({ config }) => isWorldBook(config) && config.id === entry.id);
+	if (matches.length > 1) throw new Error(`世界书条目 ${entry.id} 的动作身份重复，无法安全更新`);
+	const existing = matches[0];
+	const rule = existing === void 0 ? promptConfigToRule({
+		...entry,
+		id: entry.id
+	}) : {
+		...existing.rule,
+		then: existing.rule.then.map((action) => action.id === existing.action.id ? {
+			...action,
+			config: entry
+		} : action)
+	};
+	return ruleInjections(editModuleRules(moduleDir, {
+		expectedRevisions: snapshot.revisions,
+		edits: [{
+			previousId: existing?.rule.id ?? null,
+			rule,
+			settingsChanged: existing === void 0
+		}]
+	}).rules).filter(({ config }) => isWorldBook(config)).length;
+}
+/** 删除一条世界书条目；不存在抛错。返回删除后条目总数。 */
+function deleteWorldBookEntry(moduleDir, id) {
+	const snapshot = readModuleRules(moduleDir);
+	const matches = ruleInjections(snapshot.rules).filter(({ config }) => isWorldBook(config) && config.id === id);
+	if (matches.length === 0) throw new Error(`世界书条目 ${id} 不存在`);
+	if (matches.length > 1) throw new Error(`世界书条目 ${id} 的动作身份重复，无法安全删除`);
+	const { rule, action } = matches[0];
+	const actions = rule.then.filter((item) => item.id !== action.id);
+	return ruleInjections(editModuleRules(moduleDir, {
+		expectedRevisions: snapshot.revisions,
+		edits: [{
+			previousId: rule.id,
+			rule: actions.length > 0 ? {
+				...rule,
+				then: actions
+			} : null,
+			settingsChanged: false
+		}]
+	}).rules).filter(({ config }) => isWorldBook(config)).length;
+}
+//#endregion
+//#region src/host/sillytavern.ts
+/**
+* SillyTavern 预设 → 本项目单文件预设转换引擎（纯函数，无文件 IO）。
+*
+* 按需转换原则：只按注入层级映射 SillyTavern 实际内容，不注入本项目默认内容。
+*   - prompts[] → promptConfigs：role=system → system-section（可拼接）；
+*     其余 → pre-step（role/position/dedupe 按 ST 语义）；
+*   - 角色卡正文（chara_card_v3：data 内层；旧版顶层直存）→ promptConfigs：
+*     description/personality/scenario 拼接为「角色设定」system-section，
+*     system_prompt / post_history_instructions → system-section，
+*     first_mes → pre-step 开场白（dedupe=session 每会话一次）；
+*   - 采样参数（temperature/openai_max_tokens/reasoning_effort）**不转译**：
+*     模型参数由「模型设置」UI 统一管理（预设级 params.model*，writePreset 渲染
+*     agent-request patch），ST 卡固化值会覆盖用户在模型设置里的设置，故剥离；
+*   - modules 按需组装：prompt-config-engine 始终，system-section 注入需要
+*     persona（complete: false 允许 system-section 生效），世界书条目需要 world-book-tools。
+*/
+/** 转换器版本：报告用它解释本次生成使用了哪一版语义（语义调整时同步递增）。
+*  v2：pre-step 角色统一降级为 user（原角色只作来源元数据）+ 选组优先级修正常量事实。
+*  v3：世界书触发键（keys/secondaryKeys）的未定义宏登记为空占位并产出可见诊断。 */
+const ST_CONVERTER_VERSION = "st-to-rules/4";
+/** 报告的展示上限：只截断观测数据，不改变转换结果。 */
+const REPORT_ENTRY_LIMIT = 500;
+const REPORT_DIAGNOSTIC_LIMIT = 200;
+/**
+* pre-step 只接受 user：宿主把本批消息逐条写成 `user/message` 事件，事件校验要求
+* `role === 'user'`。ST 侧的 assistant/system 角色在导入期统一降级为 user，原角色
+* 保留在 stSource.role / stWorldBook.role，条目按 degraded 记录并带同一原因码。
+*/
+const ST_PRE_STEP_ROLE = "user";
+const ST_ROLE_DOWNGRADE_CODE = "assistant-role-downgrade";
+/**
+* `enable_web_search: false` 时被拒绝的 web 工具名。
+* 三个声明式触发器（assembly / sdk-strip / guard）共用这一份名单——呈现过滤与执行
+* 边界必须同一判据，不得各写一份（见 engine/actions.mjs 的 (5) 类说明）。
+*/
+const ST_WEB_TOOLS = ["web_search", "web_fetch"];
+/** ST marker prompts（marker: true）：content 不发送给模型（仅标记注入位置，ST
+*  以运行时内容填充该位置）；SPresetSettings 是旧版 ST 的预设设置 dump（正则
+*  脚本/扩展配置/ToolBindings，动辄数百 KB）。两者转换时整体丢弃并计数进
+*  meta.stDroppedMarkers——防止设置 dump 与位置占位污染 promptConfigs 与注入。 */
+/** 显式文本求值工具；导入本身仅 prepare，避免执行禁用卡的副作用。 */
+function processStText(text, cardName, variables) {
+	return renderStText(prepareStText(text, cardName), {
+		variables,
+		local: variables
+	}).trim();
+}
+/**
+* 合并多个转换结果为一个预设，并返回「来源 + 生成配置下标 → 最终 id」的同一份映射。
+*
+* 报告必须消费这份映射，而不是按后缀规则另行推测：后缀分配只发生在这里一次。
+*/
+function mergeStModulesWithReport(specs) {
+	const rules = [];
+	const seen = /* @__PURE__ */ new Set();
+	const idMap = /* @__PURE__ */ new Map();
+	for (const [sourceIndex, spec] of specs.entries()) {
+		const perSource = /* @__PURE__ */ new Map();
+		for (const [entryIndex, config] of (spec.rules ?? []).entries()) {
+			if (config === null || typeof config !== "object" || Array.isArray(config)) continue;
+			const entry = config;
+			const base = String(entry.id ?? "");
+			if (base.length === 0) continue;
+			let id = base;
+			for (let suffix = 2; seen.has(id); suffix++) id = `${base}-${suffix}`;
+			seen.add(id);
+			perSource.set(entryIndex, id);
+			rules.push(mapRuleInjections({
+				...entry,
+				id
+			}, (payload) => {
+				const next = {
+					...payload,
+					variables: {
+						...spec.variablesEnabled === false ? {} : spec.variables,
+						...payload.variables
+					}
+				};
+				if (id !== base) next.id = id;
+				return next;
+			}));
+		}
+		idMap.set(sourceIndex, perSource);
+	}
+	const params = {};
+	const layerSettings = {};
+	for (const spec of specs) {
+		readModuleLayerSettings(spec);
+		Object.assign(params, spec.params ?? {});
+		for (const [layer, fields] of Object.entries(spec.layerSettings ?? {})) layerSettings[layer] = {
+			...layerSettings[layer],
+			...fields
+		};
+	}
+	const variables = Object.fromEntries(specs.filter((spec) => spec.variablesEnabled !== false).flatMap((spec) => Object.entries(spec.variables ?? {})));
+	const warnings = [...new Set(specs.flatMap((spec) => Array.isArray(spec.meta?.stWarnings) ? spec.meta.stWarnings.filter((value) => typeof value === "string") : []))];
+	const modules = [];
+	for (const spec of specs) for (const name of spec.modules ?? []) if (!modules.includes(name)) modules.push(name);
+	const managementModules = [
+		"character-tools",
+		...ruleInjections(rules).some(({ config }) => config.strategy === "world-book") ? ["world-book-tools"] : [],
+		"session-var-tools",
+		"tool-config-engine"
+	];
+	for (const name of managementModules) if (!modules.includes(name)) modules.push(name);
+	const moduleConfigs = {};
+	for (const spec of specs) for (const [key, value] of Object.entries(spec.moduleConfigs ?? {})) moduleConfigs[key] = {
+		...moduleConfigs[key],
+		...value
+	};
+	const persona = specs.find((spec) => spec.persona !== void 0)?.persona;
+	const stripSuffix = (name) => name.replace(/（SillyTavern 转换）$/, "");
+	return {
+		spec: {
+			id: specs.length > 1 ? specs.map((item) => item.id).join("-") : specs[0].id,
+			name: specs.map((item) => stripSuffix(item.name)).join(" × ") + "（SillyTavern 合并）",
+			version: "1.0.0",
+			engineCompat: ">=0.4.2",
+			meta: {
+				source: "sillytavern",
+				...warnings.length > 0 ? { stWarnings: warnings } : {}
+			},
+			...Object.keys(params).length > 0 ? { params } : {},
+			...Object.keys(layerSettings).length > 0 ? { layerSettings } : {},
+			...Object.keys(variables).length > 0 ? { variables } : {},
+			...persona === void 0 ? {} : { persona },
+			modules,
+			moduleConfigs,
+			rules
+		},
+		idMap
+	};
+}
+/** 合并多个转换结果为一个预设（角色卡 × 响应预设 → 单预设）。 */
+function mergeStModules(specs) {
+	return mergeStModulesWithReport(specs).spec;
+}
+/**
+* 选组优先级（唯一实现，转换与预览共用）：
+*   请求显式选择 → 文件内 character_id → 全局组 100001 → 仅有一组时回退。
+* 显式选择必须命中，命中失败不回落；重复 character_id 无法明确对应，一律拒绝。
+*/
+function resolveStOrder(record, options) {
+	if (!Array.isArray(record.prompt_order)) return { groups: [] };
+	const groups = record.prompt_order.filter((entry) => entry !== null && typeof entry === "object" && Array.isArray(entry.order));
+	const summaries = (list) => list.map((entry) => ({
+		characterId: String(entry.character_id ?? ""),
+		entries: entry.order.length
+	}));
+	if (groups.length === 0) return { groups };
+	const explicit = typeof options.characterId === "string" && options.characterId.length > 0 ? options.characterId : void 0;
+	const fileCharacterId = record.character_id === void 0 || record.character_id === null ? void 0 : String(record.character_id);
+	const find = (id) => id === void 0 ? void 0 : groups.find((entry) => String(entry.character_id) === id);
+	let group = find(explicit);
+	if (explicit !== void 0 && group === void 0) return {
+		groups,
+		needsSelection: summaries(groups),
+		error: `SillyTavern prompt_order 不包含 character_id ${JSON.stringify(explicit)} 的顺序表`
+	};
+	group ??= find(fileCharacterId);
+	group ??= find("100001");
+	if (group === void 0 && groups.length === 1) [group] = groups;
+	if (group === void 0) return {
+		groups,
+		...groups.length > 1 ? { needsSelection: summaries(groups) } : {}
+	};
+	const picked = String(group.character_id ?? "");
+	if (groups.filter((entry) => String(entry.character_id ?? "") === picked).length > 1) return {
+		groups,
+		error: `SillyTavern prompt_order 中 character_id ${JSON.stringify(picked)} 重复，无法明确对应顺序表`
+	};
+	return {
+		groups,
+		group
+	};
+}
+/**
+* 预览选组状态：多组且按优先级无法明确选择时给出候选，让 UI 先让用户选组再重新预览；
+* 候选状态不代表已转换，调用方不得据此启用确认或提交。
+*/
+function stOrderSelectionState(card, options = {}) {
+	const resolved = resolveStOrder(card !== null && typeof card === "object" ? card : {}, options);
+	if (resolved.error !== void 0) return {
+		needsSelection: false,
+		error: resolved.error
+	};
+	if (resolved.needsSelection !== void 0) return {
+		needsSelection: true,
+		candidates: resolved.needsSelection
+	};
+	return { needsSelection: false };
+}
+/** SillyTavern JSON 预设卡片 → 本项目 ModuleSpec（导入端点直接消费）。 */
+function convertStToModule(card, baseName, options = {}) {
+	return convertStToModuleWithReport(card, baseName, options).spec;
+}
+/**
+* 同源转换 + 结构化报告：预览与实际提交共用这一个纯函数实现，
+* 报告只是派生元数据（不进 module.yml、不作写入凭证）。
+*/
+function convertStToModuleWithReport(card, baseName, options = {}) {
+	const record = card !== null && typeof card === "object" ? card : {};
+	const prompts = Array.isArray(record.prompts) ? record.prompts.filter((item) => item !== null && typeof item === "object") : [];
+	const orderIndex = /* @__PURE__ */ new Map();
+	const orderEnabled = /* @__PURE__ */ new Map();
+	const orderGroups = [];
+	let ordered = false;
+	{
+		const resolved = resolveStOrder(record, options);
+		if (resolved.error !== void 0) throw new TypeError(resolved.error);
+		if (resolved.needsSelection !== void 0) throw new TypeError("SillyTavern prompt_order 包含多个角色，请提供 character_id 或导出全局预设");
+		const { groups, group } = resolved;
+		for (const entry of groups) orderGroups.push({
+			characterId: String(entry.character_id ?? ""),
+			selected: entry === group,
+			entries: entry.order.length
+		});
+		if (Array.isArray(record.prompt_order)) {
+			const order = group === void 0 ? record.prompt_order : group.order;
+			ordered = group !== void 0 || order.some((entry) => entry !== null && typeof entry === "object" && typeof entry.identifier === "string");
+			let rank = 0;
+			for (const entry of order) {
+				if (entry === null || typeof entry !== "object") continue;
+				const id = typeof entry.identifier === "string" ? entry.identifier : "";
+				if (id.length === 0) continue;
+				if (!orderIndex.has(id)) orderIndex.set(id, rank);
+				orderEnabled.set(id, entry.enabled === true);
+				rank += 1;
+			}
+		}
+	}
+	const configs = [];
+	/** module.yml 顶层触发器声明（`enable_web_search: false` 的 web 拒绝名单在此登记）。 */
+	const triggers = [];
+	const worldBookSources = /* @__PURE__ */ new Map();
+	const droppedMarkers = [];
+	const diagnostics = [];
+	const reportEntries = [];
+	const diagnosticKeys = /* @__PURE__ */ new Set();
+	const warnings = /* @__PURE__ */ new Set();
+	const classifications = {
+		equivalent: 0,
+		degraded: 0,
+		unsupported: 0,
+		excluded: 0
+	};
+	let needsReview = 0;
+	let reportTruncated = false;
+	let sourceInputs = 0;
+	const note = (code, message, extra = {}, severity = "warning") => {
+		const key = JSON.stringify([code, extra.entryId]);
+		if (diagnosticKeys.has(key)) return;
+		diagnosticKeys.add(key);
+		if (severity === "warning") {
+			needsReview += 1;
+			warnings.add(message);
+		}
+		if (diagnostics.length >= REPORT_DIAGNOSTIC_LIMIT) {
+			reportTruncated = true;
+			return;
+		}
+		diagnostics.push({
+			code,
+			severity,
+			message,
+			...extra.entryId !== void 0 ? { entryId: extra.entryId } : {},
+			...extra.field !== void 0 ? { field: extra.field } : {}
+		});
+	};
+	const recordEntry = (entry) => {
+		classifications[entry.classification] += 1;
+		if (reportEntries.length >= REPORT_ENTRY_LIMIT) {
+			reportTruncated = true;
+			return;
+		}
+		let targetIndex;
+		if (entry.targetId !== void 0) {
+			for (let index = configs.length - 1; index >= 0; index--) if (configs[index]?.id === entry.targetId) {
+				targetIndex = index;
+				break;
+			}
+		}
+		reportEntries.push(targetIndex === void 0 ? entry : {
+			...entry,
+			targetIndex
+		});
+	};
+	/** info 级诊断：进入报告但**不**改变既有 stWarnings 表现。 */
+	const noteInfo = (code, message, extra = {}) => {
+		note(code, message, extra, "info");
+	};
+	let systemSectionCount = 0;
+	const body = record.data !== null && typeof record.data === "object" ? record.data : record;
+	const extensions = body.extensions !== null && typeof body.extensions === "object" ? body.extensions : void 0;
+	if (extensions && Object.keys(extensions).some((key) => /helper|script|regex|tavern/i.test(key))) note("st-extension-scripts", "ST 扩展脚本与正则不执行，依赖它们的界面或状态更新需要单独适配", { field: "extensions" });
+	const bodyText = (key) => typeof body[key] === "string" ? body[key].trim() : "";
+	const cardName = typeof record.name === "string" && record.name.trim().length > 0 ? record.name.trim() : typeof body.name === "string" && body.name.trim().length > 0 ? body.name.trim() : "";
+	const variables = {};
+	if (cardName && (body.description !== void 0 || body.first_mes !== void 0 || body.character_book !== void 0)) {
+		variables.char = cardName;
+		variables.charifnotgroup = cardName;
+		variables.charIfNotGroup = cardName;
+	}
+	const clean = (text) => prepareStText(text, cardName);
+	for (const key of [
+		"description",
+		"personality",
+		"scenario",
+		"persona"
+	]) {
+		const value = bodyText(key);
+		if (value.length > 0) variables[key] = clean(value);
+	}
+	const creatorNotes = bodyText("creator_notes");
+	if (creatorNotes.length > 0) variables.creator_notes = clean(creatorNotes);
+	const characterDefinitionClean = clean([
+		bodyText("description"),
+		bodyText("personality"),
+		bodyText("scenario")
+	].filter((text) => text.length > 0).join("\n\n"));
+	if (characterDefinitionClean.length > 0) {
+		sourceInputs += 1;
+		configs.push({
+			id: "character-definition",
+			name: "角色设定",
+			strategy: "static",
+			order: -30,
+			text: characterDefinitionClean,
+			layer: "system-section",
+			mergeMode: "merged"
+		});
+		recordEntry({
+			sourceId: "description/personality/scenario",
+			sourceIndex: 0,
+			targetId: "character-definition",
+			layer: "system-section",
+			order: -30,
+			classification: "equivalent",
+			codes: []
+		});
+		systemSectionCount += 1;
+	}
+	const systemPromptClean = clean(bodyText("system_prompt"));
+	if (systemPromptClean.length > 0) {
+		sourceInputs += 1;
+		configs.push({
+			id: "system-prompt",
+			name: "系统提示",
+			strategy: "static",
+			order: -20,
+			text: systemPromptClean,
+			layer: "system-section",
+			mergeMode: "merged"
+		});
+		recordEntry({
+			sourceId: "system_prompt",
+			sourceIndex: 0,
+			targetId: "system-prompt",
+			layer: "system-section",
+			order: -20,
+			classification: "equivalent",
+			codes: []
+		});
+		systemSectionCount += 1;
+	}
+	const postHistoryClean = clean(bodyText("post_history_instructions"));
+	if (postHistoryClean.length > 0) {
+		sourceInputs += 1;
+		configs.push({
+			id: "post-history-instructions",
+			name: "后续指令",
+			strategy: "static",
+			order: -10,
+			text: postHistoryClean,
+			layer: "system-section",
+			mergeMode: "merged"
+		});
+		noteInfo("st-post-history", "ST post_history_instructions 放入 system-section，不等于历史后覆盖", {
+			entryId: "post-history-instructions",
+			field: "post_history_instructions"
+		});
+		recordEntry({
+			sourceId: "post_history_instructions",
+			sourceIndex: 0,
+			targetId: "post-history-instructions",
+			layer: "system-section",
+			order: -10,
+			classification: "degraded",
+			codes: ["post-history-position"]
+		});
+		systemSectionCount += 1;
+	}
+	const examples = bodyText("mes_example");
+	if (examples.length > 0) {
+		const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const marker = new RegExp(`(?:^|\\n)\\s*(\\{\\{user\\}\\}|\\{\\{char\\}\\}|user|assistant${cardName ? `|${escape(cardName)}` : ""})\\s*:\\s*`, "gi");
+		let index = 0;
+		let exampleDowngraded = false;
+		for (const block of examples.split(/<START>/gi).filter((text) => text.trim().length > 0)) {
+			const turns = [...block.matchAll(marker)];
+			const parts = turns.length > 0 ? turns.map((turn, at) => ({
+				role: /^(?:\{\{user\}\}|user)$/i.test(turn[1]) ? "user" : "assistant",
+				text: block.slice(turn.index + turn[0].length, turns[at + 1]?.index)
+			})) : [{
+				role: "user",
+				text: block
+			}];
+			for (const part of parts) {
+				const text = clean(part.text);
+				if (!text) continue;
+				sourceInputs += 1;
+				const entryIndex = ++index;
+				const targetId = `dialogue-example-${entryIndex}`;
+				const order = -60 + entryIndex / 1e3;
+				const downgraded = part.role === "assistant";
+				exampleDowngraded ||= downgraded;
+				configs.push({
+					id: targetId,
+					name: `示例对话 ${entryIndex}`,
+					strategy: "static",
+					text,
+					layer: "pre-step",
+					role: "user",
+					position: "before-all",
+					dedupe: "session",
+					order,
+					params: { stSource: {
+						field: "mes_example",
+						role: part.role
+					} }
+				});
+				recordEntry({
+					sourceId: `mes_example[${entryIndex}]`,
+					sourceIndex: entryIndex - 1,
+					targetId,
+					layer: "pre-step",
+					order,
+					role: "user",
+					position: "before-all",
+					classification: downgraded ? "degraded" : "equivalent",
+					codes: downgraded ? [ST_ROLE_DOWNGRADE_CODE] : []
+				});
+			}
+		}
+		if (exampleDowngraded) noteInfo("st-example-role", "DSH pre-step 只接受 user 角色：示例对话的 assistant 轮次降级为 user，原角色保留在 stSource.role", {
+			entryId: "mes_example",
+			field: "mes_example"
+		});
+	}
+	const book = body.character_book ?? (body.entries !== void 0 ? body : void 0);
+	if (book !== null && typeof book === "object" && !Array.isArray(book)) {
+		const rawEntries = book.entries;
+		const entryList = Array.isArray(rawEntries) ? rawEntries : rawEntries !== null && typeof rawEntries === "object" ? Object.values(rawEntries).filter((e) => e !== null && typeof e === "object" && !Array.isArray(e)) : [];
+		for (const [index, entry] of entryList.entries()) {
+			if (entry === null || typeof entry !== "object") continue;
+			const content = clean(typeof entry.content === "string" ? entry.content : "");
+			sourceInputs += 1;
+			const sourceId = String(entry.id ?? entry.uid ?? index);
+			if (content.length === 0) {
+				recordEntry({
+					sourceId,
+					sourceIndex: index,
+					classification: "excluded",
+					codes: ["empty-content"]
+				});
+				continue;
+			}
+			const comment = typeof entry.comment === "string" && entry.comment.trim().length > 0 ? entry.comment.trim() : `世界书 ${String(entry.id ?? entry.uid ?? index)}`;
+			const rawKeys = entry.keys ?? entry.key;
+			const keys = Array.isArray(rawKeys) ? rawKeys.map(String).filter((key) => key.trim().length > 0) : [];
+			const rawSecondary = entry.secondary_keys ?? entry.keysecondary;
+			const secondaryKeys = Array.isArray(rawSecondary) ? rawSecondary.map(String).filter((key) => key.trim().length > 0) : [];
+			const constant = entry.constant === true || entry.add_always === true;
+			const enabled = entry.disable !== void 0 ? entry.disable !== true : entry.enabled !== false;
+			const stOrder = typeof entry.insertion_order === "number" ? entry.insertion_order : typeof entry.order === "number" ? entry.order : 100;
+			const ext = entry.extensions !== null && typeof entry.extensions === "object" && !Array.isArray(entry.extensions) ? entry.extensions : {};
+			const option = (...names) => {
+				for (const scope of [ext, entry]) for (const name of names) if (scope[name] !== void 0) return scope[name];
+			};
+			const position = option("position") ?? (entry.position === "after_char" ? 1 : 0);
+			const stWorldBook = {
+				selective: entry.selective === true,
+				position,
+				depth: option("depth") ?? 4,
+				role: option("role") ?? 0,
+				scanDepth: option("scan_depth", "scanDepth") ?? book.scan_depth ?? 2
+			};
+			if (book.recursive_scanning === true) stWorldBook.recursive = true;
+			for (const [target, source] of Object.entries({
+				probability: "probability",
+				useProbability: "useProbability",
+				group: "group",
+				groupOverride: "group_override",
+				groupWeight: "group_weight",
+				sticky: "sticky",
+				cooldown: "cooldown",
+				delay: "delay",
+				recursive: "recursive_scanning",
+				excludeRecursion: "exclude_recursion",
+				preventRecursion: "prevent_recursion",
+				delayUntilRecursion: "delay_until_recursion",
+				useGroupScoring: "use_group_scoring",
+				matchCharacterDescription: "match_character_description",
+				matchCharacterPersonality: "match_character_personality",
+				matchScenario: "match_scenario",
+				matchPersonaDescription: "match_persona_description",
+				matchCreatorNotes: "match_creator_notes",
+				matchCharacterDepthPrompt: "match_character_depth_prompt"
+			})) {
+				const value = option(source, target, ...target === "useProbability" ? ["use_probability"] : []);
+				if (typeof value === "number" || typeof value === "boolean" || typeof value === "string") stWorldBook[target] = value;
+			}
+			const sourceRole = stWorldBook.role;
+			const rawFilter = entry.characterFilter;
+			const filterSource = rawFilter !== null && typeof rawFilter === "object" && !Array.isArray(rawFilter) ? rawFilter : void 0;
+			const filterNames = Array.isArray(filterSource?.names) ? filterSource.names : [];
+			const filterTags = Array.isArray(filterSource?.tags) ? filterSource.tags : [];
+			if (filterSource !== void 0) stWorldBook.characterFilter = {
+				...filterSource,
+				...Array.isArray(filterSource.names) ? { names: [...filterSource.names] } : {},
+				...Array.isArray(filterSource.tags) ? { tags: [...filterSource.tags] } : {}
+			};
+			const entryCodes = [];
+			if (filterNames.length > 0 || filterTags.length > 0) {
+				entryCodes.push("character-filter-unsupported");
+				note("st-worldbook-character-filter", "ST 角色/标签过滤在本项目不受支持：该条目会对所有角色生效", {
+					entryId: sourceId,
+					field: "characterFilter"
+				});
+			}
+			if (position === 4) {
+				entryCodes.push("depth-collapsed");
+				note("st-worldbook-depth", "ST 世界书深度位置无法映射到持久历史：保留 position/depth/role，降级为当前消息批末尾", {
+					entryId: sourceId,
+					field: "position"
+				});
+			} else if (![
+				0,
+				1,
+				"before_char",
+				"after_char"
+			].includes(position)) {
+				entryCodes.push("position-downgraded");
+				note("st-worldbook-position", "ST 世界书特殊插入点暂不可用：保留来源位置，降级为当前消息批头部", {
+					entryId: sourceId,
+					field: "position"
+				});
+			}
+			if (sourceRole === 0) {
+				entryCodes.push("system-role-downgrade");
+				note("st-worldbook-role", "DSH pre-step 不接受 system 角色：世界书 system 消息降级为 user，原角色保留在 stWorldBook", {
+					entryId: sourceId,
+					field: "role"
+				});
+			} else if (sourceRole === 2) {
+				entryCodes.push(ST_ROLE_DOWNGRADE_CODE);
+				noteInfo("st-worldbook-role-assistant", "DSH pre-step 只接受 user 角色：世界书 assistant 消息降级为 user，原角色保留在 stWorldBook.role", {
+					entryId: sourceId,
+					field: "role"
+				});
+			}
+			const rawAutomationId = option("automation_id", "automationId");
+			const rawOutletName = option("outlet_name", "outletName");
+			const automationId = typeof rawAutomationId === "string" ? rawAutomationId.trim() : "";
+			const outletName = typeof rawOutletName === "string" ? rawOutletName.trim() : "";
+			if (automationId.length > 0) stWorldBook.automationId = rawAutomationId;
+			if (outletName.length > 0) stWorldBook.outletName = rawOutletName;
+			if (option("vectorized") === true || outletName.length > 0 || Array.isArray(option("triggers")) && option("triggers").length > 0) {
+				entryCodes.push("unsupported-controls");
+				note("st-worldbook-controls", "ST 世界书向量、outlet 或生成类型控制需要宿主专门适配", {
+					entryId: sourceId,
+					field: "extensions"
+				});
+			}
+			if (automationId.length > 0) {
+				entryCodes.push("automation-dependent");
+				note("st-worldbook-automation", keys.length === 0 && secondaryKeys.length === 0 && constant !== true ? "该条目依赖 STscript 自动化触发，本项目不执行自动化；它没有主键也非常驻，因此不会自动注入" : "该条目依赖 STscript 自动化触发，本项目不执行自动化", {
+					entryId: sourceId,
+					field: "automationId"
+				});
+			}
+			if (enabled === false) entryCodes.push("disabled");
+			const worldConfig = buildWorldBookEntry({
+				id: `lore-${sourceId}`,
+				name: comment,
+				enabled,
+				order: stOrder,
+				text: content,
+				constant,
+				keys: keys.length > 0 ? keys : void 0,
+				secondaryKeys: secondaryKeys.length > 0 ? secondaryKeys : void 0,
+				...option("case_sensitive", "caseSensitive") === true ? { caseSensitive: true } : {},
+				...option("match_whole_words", "matchWholeWords") === true ? { wholeWords: true } : {},
+				...typeof option("selectiveLogic", "selective_logic") === "number" ? { selectiveLogic: option("selectiveLogic", "selective_logic") } : {}
+			});
+			configs.push({
+				...worldConfig,
+				role: ST_PRE_STEP_ROLE,
+				position: position === 4 ? "after-all" : "before-all",
+				params: {
+					...worldConfig.params,
+					stWorldBook
+				}
+			});
+			worldBookSources.set(String(worldConfig.id), sourceId);
+			recordEntry({
+				sourceId,
+				sourceIndex: index,
+				targetId: `lore-${sourceId}`,
+				layer: "pre-step",
+				order: stOrder,
+				role: ST_PRE_STEP_ROLE,
+				position: position === 4 ? "after-all" : "before-all",
+				classification: entryCodes.includes("unsupported-controls") ? "unsupported" : entryCodes.some((code) => code !== "disabled") ? "degraded" : "equivalent",
+				codes: entryCodes
+			});
+		}
+	}
+	const depthPromptRaw = extensions?.depth_prompt;
+	const depthPromptSource = depthPromptRaw !== null && typeof depthPromptRaw === "object" && !Array.isArray(depthPromptRaw) ? depthPromptRaw : void 0;
+	const depthPromptText = typeof depthPromptSource?.prompt === "string" ? clean(depthPromptSource.prompt) : "";
+	if (depthPromptText.length > 0) {
+		variables.depth_prompt = depthPromptText;
+		sourceInputs += 1;
+		const order = -50;
+		configs.push({
+			id: "st-depth-prompt",
+			name: "角色深度提示词",
+			strategy: "static",
+			enabled: false,
+			order,
+			text: depthPromptText,
+			layer: "pre-step",
+			mergeMode: "merged",
+			role: ST_PRE_STEP_ROLE,
+			position: "before-all",
+			dedupe: "none",
+			params: { stSource: {
+				field: "extensions.depth_prompt",
+				depth: depthPromptSource?.depth ?? 4,
+				role: depthPromptSource?.role ?? 0
+			} }
+		});
+		recordEntry({
+			sourceId: "extensions.depth_prompt",
+			sourceIndex: 0,
+			targetId: "st-depth-prompt",
+			layer: "pre-step",
+			order,
+			role: ST_PRE_STEP_ROLE,
+			position: "before-all",
+			classification: "degraded",
+			codes: ["depth-prompt-group-only"]
+		});
+		noteInfo("st-depth-prompt", "ST 角色深度提示词只在群聊自动注入：本项目保留为默认禁用的 pre-step 配置，可由用户手动启用", {
+			entryId: "st-depth-prompt",
+			field: "extensions.depth_prompt"
+		});
+	}
+	const firstMes = clean(bodyText("first_mes"));
+	if (firstMes.length > 0) {
+		sourceInputs += 1;
+		configs.push({
+			id: "first-mes",
+			name: "开场白",
+			strategy: "static",
+			order: -40,
+			text: firstMes,
+			layer: "pre-step",
+			mergeMode: "merged",
+			role: ST_PRE_STEP_ROLE,
+			position: "before-all",
+			dedupe: "session",
+			params: { stSource: {
+				field: "first_mes",
+				role: "assistant"
+			} }
+		});
+		recordEntry({
+			sourceId: "first_mes",
+			sourceIndex: 0,
+			targetId: "first-mes",
+			layer: "pre-step",
+			order: -40,
+			role: ST_PRE_STEP_ROLE,
+			position: "before-all",
+			classification: "degraded",
+			codes: [ST_ROLE_DOWNGRADE_CODE]
+		});
+		noteInfo("st-first-mes-role", "DSH pre-step 只接受 user 角色：ST 开场白降级为 user，原角色保留在 stSource.role", {
+			entryId: "first_mes",
+			field: "first_mes"
+		});
+	}
+	const alternateGreetings = Array.isArray(body.alternate_greetings) ? body.alternate_greetings.map((item) => typeof item === "string" ? item : "").map(clean).filter((item) => item.length > 0) : [];
+	if (alternateGreetings.length > 0) noteInfo("st-alternate-greetings-role", "DSH pre-step 只接受 user 角色：备用开场白降级为 user，原角色保留在 stSource.role", {
+		entryId: "alternate_greetings",
+		field: "alternate_greetings"
+	});
+	for (const [index, greeting] of alternateGreetings.entries()) {
+		sourceInputs += 1;
+		const targetId = `first-mes-${index + 2}`;
+		const order = -40 + index + 1;
+		configs.push({
+			id: targetId,
+			name: `开场白 ${index + 2}`,
+			strategy: "static",
+			enabled: false,
+			order,
+			text: greeting,
+			layer: "pre-step",
+			mergeMode: "merged",
+			role: ST_PRE_STEP_ROLE,
+			position: "before-all",
+			dedupe: "session",
+			params: { stSource: {
+				field: `alternate_greetings[${index}]`,
+				role: "assistant"
+			} }
+		});
+		recordEntry({
+			sourceId: `alternate_greetings[${index}]`,
+			sourceIndex: index,
+			targetId,
+			layer: "pre-step",
+			order,
+			role: ST_PRE_STEP_ROLE,
+			position: "before-all",
+			classification: "degraded",
+			codes: [ST_ROLE_DOWNGRADE_CODE]
+		});
+	}
+	for (const [index, prompt] of prompts.entries()) {
+		const rawId = typeof prompt.identifier === "string" ? prompt.identifier : "";
+		const sourceId = rawId.length > 0 ? rawId : `prompt-${index + 1}`;
+		sourceInputs += 1;
+		if (prompt.marker === true || rawId === "SPresetSettings") {
+			if (rawId.length > 0) droppedMarkers.push(rawId);
+			recordEntry({
+				sourceId,
+				sourceIndex: index,
+				classification: "excluded",
+				codes: ["marker-dropped"]
+			});
+			continue;
+		}
+		const content = clean(typeof prompt.content === "string" ? prompt.content : "");
+		if (content.length === 0) {
+			recordEntry({
+				sourceId,
+				sourceIndex: index,
+				classification: "excluded",
+				codes: ["empty-content"]
+			});
+			continue;
+		}
+		const id = rawId.length > 0 && !/^[0-9a-f-]{36}$/i.test(rawId) ? rawId : `st-prompt-${index + 1}`;
+		const stRole = typeof prompt.role === "string" ? prompt.role : "system";
+		const preStep = stRole !== "system";
+		const role = preStep ? ST_PRE_STEP_ROLE : "system";
+		const roleDowngraded = preStep && stRole !== "user";
+		const systemPromptFlag = prompt.system_prompt === true;
+		const base = {
+			id,
+			name: typeof prompt.name === "string" && prompt.name.length > 0 ? prompt.name : id,
+			enabled: ordered ? orderEnabled.get(rawId) === true : prompt.enabled !== false,
+			strategy: "static",
+			order: ((rawId.length > 0 ? orderIndex.get(rawId) : void 0) ?? (ordered ? orderIndex.size + index : index)) * 10,
+			text: content,
+			...prompt.injection_position === 1 || Array.isArray(prompt.injection_trigger) || roleDowngraded || systemPromptFlag ? { params: { stSource: {
+				position: prompt.injection_position ?? 0,
+				depth: prompt.injection_depth ?? 4,
+				order: prompt.injection_order ?? 100,
+				role: stRole,
+				...Array.isArray(prompt.injection_trigger) ? { triggers: prompt.injection_trigger } : {},
+				...systemPromptFlag ? { systemPrompt: true } : {}
+			} } } : {}
+		};
+		const codes = [];
+		if (systemPromptFlag) noteInfo("st-prompt-system-flag", "ST 的 prompts[].system_prompt 只标记内置/全局 prompt，不改变发送角色：本条仍按 role 分层", {
+			entryId: sourceId,
+			field: "system_prompt"
+		});
+		if (roleDowngraded) {
+			codes.push(ST_ROLE_DOWNGRADE_CODE);
+			noteInfo("st-prompt-role", "DSH pre-step 只接受 user 角色：ST prompt 的 assistant/model 角色降级为 user，原角色保留在 stSource.role", {
+				entryId: sourceId,
+				field: "role"
+			});
+		}
+		if (prompt.injection_position === 1) {
+			codes.push("depth-collapsed");
+			note("st-prompt-depth", "ST prompt 深度注入暂按 DSH 插入点降级，原 position/depth/order/role 保留在 stSource", {
+				entryId: sourceId,
+				field: "injection_position"
+			});
+		}
+		if (Array.isArray(prompt.injection_trigger) && prompt.injection_trigger.length > 0) {
+			codes.push("generation-trigger");
+			note("st-prompt-triggers", "ST prompt 的生成类型触发条件在 DSH 不等价，保留在 stSource.triggers", {
+				entryId: sourceId,
+				field: "injection_trigger"
+			});
+		}
+		if (base.enabled === false) codes.push(ordered && orderIndex.get(rawId) === void 0 ? "not-in-order-group" : "disabled");
+		if (!preStep) {
+			configs.push({
+				...base,
+				layer: "system-section",
+				mergeMode: "merged"
+			});
+			systemSectionCount += 1;
+		} else configs.push({
+			...base,
+			layer: "pre-step",
+			mergeMode: "merged",
+			role,
+			position: prompt.injection_position === 0 ? "before-all" : "after-user",
+			dedupe: "none"
+		});
+		recordEntry({
+			sourceId,
+			sourceIndex: index,
+			targetId: id,
+			layer: preStep ? "pre-step" : "system-section",
+			order: base.order,
+			role: preStep ? role : void 0,
+			position: preStep ? prompt.injection_position === 0 ? "before-all" : "after-user" : void 0,
+			classification: codes.includes("depth-collapsed") || codes.includes("generation-trigger") || roleDowngraded ? "degraded" : "equivalent",
+			codes
+		});
+	}
+	const modules = ["prompt-config-engine", "character-tools"];
+	if (configs.some((config) => config.strategy === "world-book")) modules.push("world-book-tools");
+	modules.push("session-var-tools", "tool-config-engine");
+	const moduleConfigs = {};
+	const persona = systemSectionCount > 0 ? {
+		prefix: "",
+		complete: false
+	} : void 0;
+	if (record.enable_web_search === true) {
+		modules.push("tool-web");
+		moduleConfigs["tool-web"] = { fetch: true };
+	} else if (record.enable_web_search === false) triggers.push({
+		id: "st-web-assembly",
+		channel: "system-prompt/assemble",
+		do: {
+			kind: "assembly",
+			target: { tools: { deny: [...ST_WEB_TOOLS] } }
+		}
+	}, {
+		id: "st-web-sdk-strip",
+		channel: "system-prompt/assemble",
+		do: {
+			kind: "sdk-strip",
+			mask: { deny: [...ST_WEB_TOOLS] }
+		}
+	}, {
+		id: "st-web-guard",
+		channel: "system-prompt/assemble",
+		do: {
+			kind: "guard",
+			mask: { deny: [...ST_WEB_TOOLS] }
+		}
+	});
+	const moduleId = stModuleId(baseName);
+	for (const config of configs) {
+		if (config.layer !== "pre-step" || config.role === ST_PRE_STEP_ROLE) continue;
+		const requested = config.role;
+		config.role = ST_PRE_STEP_ROLE;
+		noteInfo("st-pre-step-role-fallback", `DSH pre-step 只接受 user 角色：${String(config.id)} 声明的 ${JSON.stringify(requested)} 已降级为 user`, {
+			entryId: String(config.id),
+			field: "role"
+		});
+	}
+	const RUNTIME_MACROS = /* @__PURE__ */ new Set([
+		"lastusermessage",
+		"lastcharmessage",
+		"charifnotgroup",
+		"time",
+		"date",
+		"weekday",
+		"isotime",
+		"isodate",
+		"random",
+		"pick",
+		"roll",
+		"chance",
+		"newline",
+		"pipe"
+	]);
+	const BUILTIN_KEYS = /* @__PURE__ */ new Set([
+		"DSH_HOME",
+		"WORKSPACE",
+		"CWD"
+	]);
+	const MACRO_RE = /\{\{([A-Za-z0-9_.\u4e00-\u9fff-]+)\}\}/g;
+	const declaredKeys = new Set(Object.keys(variables).map((key) => key.toLowerCase()));
+	const knownKeys = new Set(declaredKeys);
+	const hasMacroSource = (key) => declaredKeys.has(key.toLowerCase()) || RUNTIME_MACROS.has(key.toLowerCase()) || BUILTIN_KEYS.has(key);
+	/** 登记未定义宏为空占位；返回识别到的未解析宏名（空数组表示全部已有来源）。 */
+	const registerMacros = (raw) => {
+		const missing = [];
+		MACRO_RE.lastIndex = 0;
+		for (const match of String(raw).matchAll(MACRO_RE)) {
+			const key = match[1];
+			if (hasMacroSource(key)) continue;
+			missing.push(key);
+			const lower = key.toLowerCase();
+			if (!knownKeys.has(lower)) {
+				knownKeys.add(lower);
+				variables[key] = "";
+			}
+		}
+		return missing;
+	};
+	/** 键宏诊断文案：不记录键正文与卡片内容，只说明失效原因与恢复路径。 */
+	const KEY_MACRO_MESSAGE = "世界书触发键含未解析的 ST 宏：已登记为空占位，在「模板变量」中赋值后该键才会命中";
+	for (const config of configs) {
+		config.params = {
+			...config.params,
+			stMacros: true
+		};
+		const configRecord = config;
+		const texts = [
+			...typeof config.text === "string" && config.text.length > 0 ? [config.text] : [],
+			...Array.isArray(config.texts) ? config.texts : [],
+			...typeof configRecord.params?.text === "string" ? [configRecord.params.text] : []
+		];
+		for (const raw of texts) registerMacros(raw);
+		if (config.strategy === "world-book") {
+			const entryId = worldBookSources.get(String(config.id));
+			for (const [field, value] of [["keys", configRecord.params?.keys], ["secondaryKeys", configRecord.params?.secondaryKeys]]) if ((Array.isArray(value) ? value : []).flatMap((key) => registerMacros(key)).length > 0 && entryId !== void 0) note("st-key-macro", KEY_MACRO_MESSAGE, {
+				entryId,
+				field
+			});
+		}
+	}
+	const stWarnings = [...warnings];
+	const report = {
+		converter: ST_CONVERTER_VERSION,
+		sourceName: baseName,
+		orderGroups,
+		entries: reportEntries,
+		diagnostics,
+		summary: {
+			inputs: sourceInputs,
+			converted: configs.length,
+			disabled: configs.filter((config) => config.enabled === false).length,
+			excluded: classifications.excluded,
+			unsupported: classifications.unsupported,
+			degraded: classifications.degraded,
+			needsReview
+		},
+		...reportTruncated ? { truncated: true } : {}
+	};
+	return {
+		spec: {
+			id: moduleId,
+			name: `${cardName || baseName}（SillyTavern 转换）`,
+			version: "1.0.0",
+			engineCompat: ">=0.4.2",
+			meta: {
+				source: "sillytavern",
+				...stWarnings.length > 0 ? { stWarnings } : {},
+				...droppedMarkers.length > 0 ? { stDroppedMarkers: droppedMarkers } : {}
+			},
+			...Object.keys(variables).length > 0 ? { variables } : {},
+			...persona === void 0 ? {} : { persona },
+			modules: [...new Set(modules.map((name) => name === "prompt-config-engine" || name === "declared-triggers" ? "rule-engine" : name))],
+			moduleConfigs,
+			rules: convertLegacyModuleRules({
+				promptConfigs: configs,
+				triggers
+			}).rules
+		},
+		report
+	};
+}
+/**
+* 多文件导入合并各自报告：条目/诊断有界截断、计数求和。
+*
+* 传入 `sources` 时，条目的 `targetId` 被重写为**合并后的最终 id**（消费
+* `mergeStModulesWithReport` 的同一份映射），并补上来源显示名与来源序号；
+* 诊断的 `targetId` 同样按映射定位。不传时保持旧行为（不重写）。
+*/
+function mergeStConversionReports(reports, sources = []) {
+	const finalIdOf = (sourceIndex, entry) => {
+		if (entry.targetIndex === void 0) return void 0;
+		return sources[sourceIndex]?.idMap?.get(entry.targetIndex);
+	};
+	const entries = reports.flatMap((report, sourceIndex) => report.entries.map((entry) => {
+		const source = sources[sourceIndex];
+		const finalId = finalIdOf(sourceIndex, entry);
+		return {
+			...entry,
+			...source === void 0 ? {} : {
+				sourceName: source.sourceName,
+				sourceFileIndex: sourceIndex
+			},
+			...finalId === void 0 ? {} : { targetId: finalId }
+		};
+	})).slice(0, REPORT_ENTRY_LIMIT);
+	const diagnostics = reports.flatMap((report, sourceIndex) => report.diagnostics.map((item) => {
+		if (item.entryId === void 0) return item;
+		const entry = report.entries.find((candidate) => candidate.sourceId === item.entryId);
+		const finalId = entry === void 0 ? void 0 : finalIdOf(sourceIndex, entry);
+		return finalId === void 0 ? item : {
+			...item,
+			targetId: finalId
+		};
+	})).slice(0, REPORT_DIAGNOSTIC_LIMIT);
+	const total = (pick) => reports.reduce((sum, report) => sum + pick(report.summary), 0);
+	return {
+		converter: ST_CONVERTER_VERSION,
+		sourceName: reports.map((report) => report.sourceName).join(" + "),
+		orderGroups: reports.flatMap((report) => report.orderGroups),
+		entries,
+		diagnostics,
+		summary: {
+			inputs: total((summary) => summary.inputs),
+			converted: total((summary) => summary.converted),
+			disabled: total((summary) => summary.disabled),
+			excluded: total((summary) => summary.excluded),
+			unsupported: total((summary) => summary.unsupported),
+			degraded: total((summary) => summary.degraded),
+			needsReview: total((summary) => summary.needsReview)
+		},
+		...reports.some((report) => report.truncated === true) || reports.flatMap((report) => report.entries).length > entries.length || reports.flatMap((report) => report.diagnostics).length > diagnostics.length ? { truncated: true } : {}
+	};
+}
+/** ST 导入预设 id：必须是官方 agent-presets 可发现的目录名（PRESET_ID =
+*  /^[a-z0-9][a-z0-9-]*$/——含中文的目录会被宿主 discovery 静默跳过，会话
+*  resume 报 preset not found）。文件名 slug 化（去中文）；纯中文名退化为
+*  st-<文件名短哈希>（唯一且合法）；显示名 name 仍保留中文原名。 */
+function stModuleId(baseName) {
+	return baseName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || `st-${createHash("sha1").update(baseName).digest("hex").slice(0, 6)}`;
+}
+//#endregion
+//#region src/host/import-source.ts
+const MAX_ASSET_FILE_BYTES = MAX_ASSET_BYTES;
+const MAX_ASSET_TOTAL_BYTES = MAX_ASSET_BYTES;
+function isRecord$2(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function decodeAssetFile(file) {
+	if (typeof file.content !== "string") throw new Error(`${file.path}: 文件内容必须是字符串`);
+	if (file.encoding === void 0 && /\.(png|jpe?g|gif|webp|zip|ico|pdf|woff2?|bin)$/i.test(file.path)) throw new Error(`${file.path}: 二进制文件缺少编码标记，请刷新页面后重新选择文件`);
+	if (file.encoding !== void 0 && file.encoding !== "utf8" && file.encoding !== "base64") throw new Error(`${file.path}: 未知文件编码`);
+	if (file.content.length > 89478489.33333333) throw new Error(`${file.path}: 文件大小超限`);
+	if (file.encoding === "base64" && (file.content.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(file.content))) throw new Error(`${file.path}: 非法 base64`);
+	const bytes = Buffer.from(file.content, file.encoding === "base64" ? "base64" : "utf8");
+	if (bytes.length > MAX_ASSET_FILE_BYTES) throw new Error(`${file.path}: 文件大小超限`);
+	return bytes;
+}
+/** 校验传输路径和字节；外层目录由载体入口剥离一次，显式来源顺序保持不变。 */
+function normalizeAssetFiles(files) {
+	if (!Array.isArray(files) || files.length === 0 || files.length > 2048) throw new Error("导入文件数量为空或超限");
+	const seen = /* @__PURE__ */ new Set();
+	let total = 0;
+	const normalized = files.map((file) => {
+		if (!isRecord$2(file) || typeof file.path !== "string") throw new Error("文件路径必须是字符串");
+		const path = file.path;
+		const segments = path.split("/");
+		if (path.length > 1024 || path.includes("\\") || [...path].some((char) => char.charCodeAt(0) < 32) || segments.some((segment) => segment === "" || segment === "." || segment === ".." || /[<>:"|?*]/.test(segment) || /[. ]$/.test(segment) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(segment))) throw new Error(`非法文件路径：${file.path}`);
+		const key = path.normalize("NFC").toLowerCase();
+		if (seen.has(key)) throw new Error(`文件路径重复或大小写冲突：${file.path}`);
+		seen.add(key);
+		const bytes = decodeAssetFile(file);
+		total += bytes.length;
+		if (total > MAX_ASSET_TOTAL_BYTES) throw new Error("导入总大小超限");
+		return {
+			path,
+			content: file.content,
+			...file.encoding === void 0 ? {} : { encoding: file.encoding }
+		};
+	});
+	for (const path of seen) {
+		const segments = path.split("/");
+		while (segments.length > 1) {
+			segments.pop();
+			if (seen.has(segments.join("/"))) throw new Error(`文件与目录路径冲突：${path}`);
+		}
+	}
+	return normalized;
+}
+function assetSourceDigest(files) {
+	const hash = createHash("sha256");
+	for (const file of files) {
+		const bytes = decodeAssetFile(file);
+		hash.update(JSON.stringify([file.path, bytes.length])).update(bytes);
+	}
+	return hash.digest("hex");
+}
+/** 角色片段只接受自包含配置，验证时不得读取上传来源以外的磁盘文件。 */
+function validateCharacterSpec(spec) {
+	assertCanonicalRuleSource(spec);
+	readModuleLayerSettings(spec);
+	for (const field of [
+		"composition",
+		"customTools",
+		"content",
+		"subagentToolPolicy",
+		"moduleConfigs"
+	]) {
+		const value = spec[field];
+		if (value !== void 0 && !(Array.isArray(value) && value.length === 0) && !(isRecord$2(value) && Object.keys(value).length === 0)) throw new Error(`角色片段不支持 ${field}；请从预设页导入完整预设`);
+	}
+	if (spec.persona !== void 0 && (spec.persona.prefix || spec.persona.suffix || spec.persona.complete === true)) throw new Error("角色片段的 persona 正文请改为 rules 中的注入动作，或从模块页导入完整模块");
+	for (const rule of spec.rules ?? []) assertSafeConfigId(rule.id);
+	for (const { config } of ruleInjections(spec.rules)) {
+		if (config.templateFile !== void 0) throw new Error(`角色配置 ${String(config.id)} 的 templateFile 外部文件不受支持`);
+		if (isRecord$2(config.params) && config.params.file !== void 0) throw new Error(`角色配置 ${String(config.id)} 的 params.file 外部文件不受支持`);
+		if (config.text !== void 0 && typeof config.text !== "string") throw new Error(`角色配置 ${String(config.id)} 的 text 必须是字符串`);
+	}
+	compileRules(spec.rules ?? []);
+}
+function classify(raw, target) {
+	if (!isRecord$2(raw)) throw new Error("内容必须是已知格式的对象，不能是 null 或数组");
+	const native = [
+		"modules",
+		"rules",
+		"promptConfigs",
+		"layerSettings",
+		"params",
+		"engineCompat",
+		"composition",
+		"content"
+	].some((key) => key in raw) || typeof raw.id === "string" && typeof raw.name === "string";
+	const prompts = "prompts" in raw;
+	const data = isRecord$2(raw.data) ? raw.data : raw;
+	const character = /^chara_card_v[23]$/.test(String(raw.spec)) || isRecord$2(raw.data) && typeof data.name === "string" || [
+		"personality",
+		"first_mes",
+		"mes_example",
+		"character_book",
+		"alternate_greetings"
+	].some((key) => key in data) || typeof data.name === "string" && typeof data.description === "string" && !native;
+	const worldBook = "entries" in raw;
+	if ([
+		native,
+		prompts,
+		character,
+		worldBook
+	].filter(Boolean).length !== 1) throw new Error("无法识别内容，或包含互相矛盾的原生／SillyTavern 结构");
+	if (/^chara_card_v[23]$/.test(String(raw.spec)) && !isRecord$2(raw.data)) throw new Error("chara_card_v2/v3 的 data 必须是对象");
+	if (native) {
+		assertCanonicalRuleSource(raw);
+		for (const field of [
+			"rules",
+			"modules",
+			"customTools"
+		]) if (raw[field] !== void 0 && !Array.isArray(raw[field])) throw new Error(`${field} 必须是数组`);
+		for (const field of [
+			"layerSettings",
+			"params",
+			"meta",
+			"variables",
+			"moduleConfigs",
+			"content"
+		]) if (raw[field] !== void 0 && !isRecord$2(raw[field])) throw new Error(`${field} 必须是对象`);
+		readModuleLayerSettings(raw);
+		if (raw.modules !== void 0 && raw.modules.some((value) => typeof value !== "string")) throw new Error("modules 必须是字符串数组");
+		return target === "character" ? "native-character" : "native-preset";
+	}
+	if (prompts) {
+		if (!Array.isArray(raw.prompts) || raw.prompts.some((prompt) => !isRecord$2(prompt))) throw new Error("prompts 必须是对象数组");
+		return "st-preset";
+	}
+	if (worldBook) {
+		if (!isRecord$2(raw.entries) && !Array.isArray(raw.entries)) throw new Error("entries 必须是对象或数组");
+		return "world-book";
+	}
+	return "st-character";
+}
+/** 字节集合 → 同一规范化候选；没有目标写入和静默的未知 JSON 回退。 */
+function prepareImport(input, target, choices = {}) {
+	const files = normalizeAssetFiles(input);
+	const sourceDigest = assetSourceDigest(files);
+	const named = files.filter((file) => /^(?:module|preset|converted)\.ya?ml$/i.test(file.path));
+	if (named.length > 1) throw new Error(`存在多个定义候选：${named.map((file) => file.path).join("、")}`);
+	const topFiles = files.filter((file) => !file.path.includes("/"));
+	const structured = topFiles.filter((file) => /\.(json|ya?ml)$/i.test(file.path));
+	const native = named.length === 0 ? structured.filter((file) => {
+		try {
+			const raw = decodeAssetFile(file).toString("utf8");
+			return classify(/\.json$/i.test(file.path) ? JSON.parse(raw) : parseDocument(raw).toJS({ maxAliasCount: 100 }), target).startsWith("native-");
+		} catch {
+			return false;
+		}
+	}) : [];
+	if (native.length > 1) throw new Error(`存在多个原生定义候选：${native.map((file) => file.path).join("、")}`);
+	const candidates = named.length === 1 ? named : native.length === 1 ? native : topFiles.filter((file) => structured.includes(file) || isPngBuffer(decodeAssetFile(file)) && !(structured.length === 1 && /^avatar\.png$/i.test(file.path)));
+	if (candidates.length === 0) throw new Error(`${files[0].path}: 未发现可识别的预设或角色内容`);
+	if (target === "character" && candidates.length !== 1) throw new Error("角色库每次只能导入一张角色卡，请逐张预览");
+	const parts = [];
+	for (const file of candidates) try {
+		const bytes = decodeAssetFile(file);
+		const png = isPngBuffer(bytes) ? decodePngCharacterCard(bytes) : void 0;
+		const sourceText = png?.jsonText ?? new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+		if (png !== void 0 || /\.json$/i.test(file.path)) JSON.parse(sourceText);
+		const doc = parseDocument(sourceText, { logLevel: "silent" });
+		if (doc.errors.length > 0 || !(doc.contents instanceof YAMLMap)) throw new Error(doc.errors[0]?.message ?? "内容必须是已知格式的对象");
+		const raw = doc.toJS({ maxAliasCount: 100 });
+		let kind = classify(raw, target);
+		if (kind === "native-preset" && isRecord$2(raw)) {
+			const fragment = Array.isArray(raw.rules) && ![
+				"version",
+				"engineCompat",
+				"modules",
+				"composition",
+				"customTools",
+				"persona",
+				"content"
+			].some((key) => key in raw);
+			let selfContained = false;
+			try {
+				validateCharacterSpec(raw);
+				selfContained = true;
+			} catch {}
+			if (selfContained && fragment && !/^(?:module|preset)\.ya?ml$/i.test(file.path) && !/^converted\.ya?ml$/i.test(file.path) && choices.sourceKind === void 0) return {
+				state: "needs-kind-selection",
+				kinds: ["native-preset", "native-character"],
+				sourceName: file.path
+			};
+			if (choices.sourceKind === "native-character" || /^converted\.ya?ml$/i.test(file.path)) {
+				validateCharacterSpec(raw);
+				kind = "native-character";
+			}
+		}
+		if (target === "character" && kind !== "st-character" && kind !== "native-character") throw new Error("角色库只接受角色卡；预设和独立世界书请从预设页导入");
+		if (choices.sourceKind !== void 0 && choices.sourceKind !== kind) throw new Error(`所选类型 ${choices.sourceKind} 与实际 ${kind} 不一致`);
+		const options = { characterId: choices.promptOrderCharacterId };
+		if (kind === "st-preset") {
+			const state = stOrderSelectionState(raw, options);
+			if (state.needsSelection) return {
+				state: "needs-order-selection",
+				candidates: state.candidates,
+				sourceName: file.path
+			};
+			if (state.error !== void 0) throw new Error(state.error);
+		}
+		let spec;
+		let report;
+		if (kind.startsWith("native-")) {
+			spec = raw;
+			if (spec.id === void 0) doc.set("id", stModuleId(posix.basename(file.path).replace(/\.[^.]+$/, "")));
+			if (spec.name === void 0) doc.set("name", String(doc.get("id")));
+			if (spec.modules === void 0 && spec.composition === void 0) {
+				const legacyComposition = files.find((item) => item.path === "agent.cordis.yml");
+				if (legacyComposition) doc.set("composition", decodeAssetFile(legacyComposition).toString("utf8"));
+			}
+			if (kind === "native-character" && spec.modules === void 0 && spec.composition === void 0) {
+				const hasWorldBook = (spec.rules ?? []).some((rule) => rule.then.some((action) => action.kind === "inject-text" && action.config?.strategy === "world-book"));
+				doc.set("modules", hasWorldBook ? ["world-book-tools"] : []);
+			}
+			if (doc.hasIn(["meta", "characterMemories"])) doc.deleteIn(["meta", "characterMemories"]);
+			spec = doc.toJS();
+		} else {
+			const converted = convertStToModuleWithReport(raw, posix.basename(file.path).replace(/\.[^.]+$/, ""), options);
+			spec = converted.spec;
+			report = converted.report;
+		}
+		if (target === "character") validateCharacterSpec(spec);
+		parts.push({
+			spec,
+			report,
+			kind,
+			yaml: kind.startsWith("native-") ? doc.toString() : stringify(spec, { lineWidth: 0 }),
+			file,
+			sourceText,
+			...png === void 0 ? {} : { avatar: png.avatar }
+		});
+	} catch (error) {
+		throw new Error(`${file.path}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (parts.length > 1 && parts.some((part) => part.kind.startsWith("native-"))) throw new Error(`多个定义候选不能自动合并：${candidates.map((file) => file.path).join("、")}`);
+	const first = parts[0];
+	let yaml = first.yaml;
+	let report = first.report;
+	if (parts.length > 1) {
+		const merged = mergeStModulesWithReport(parts.map((part) => part.spec));
+		yaml = stringify(merged.spec, { lineWidth: 0 });
+		report = mergeStConversionReports(parts.map((part) => part.report), parts.map((part, index) => ({
+			sourceName: part.file.path,
+			idMap: merged.idMap.get(index)
+		})));
+	}
+	const doc = parseDocument(yaml);
+	if (choices.targetId !== void 0) doc.set("id", choices.targetId);
+	if (choices.targetName !== void 0) doc.set("name", choices.targetName);
+	const spec = doc.toJS();
+	try {
+		assertModuleId(spec.id);
+	} catch (error) {
+		throw new Error(`${first.file.path}: ${String(error)}`);
+	}
+	if (typeof spec.name !== "string" || spec.name.trim().length === 0) throw new Error(`${first.file.path}: 名称必须为非空字符串`);
+	yaml = doc.toString();
+	const resources = files.filter((file) => !candidates.includes(file));
+	if (target === "character" && resources.some((file) => !/^avatar\.png$/i.test(file.path))) throw new Error("角色片段只支持内嵌内容和 avatar.png；其他附件请从预设页导入");
+	const avatarFile = resources.find((file) => /^avatar\.png$/i.test(file.path));
+	const avatar = first.avatar ?? (avatarFile === void 0 ? void 0 : decodeAssetFile(avatarFile));
+	if (avatar !== void 0 && !isPngBuffer(avatar)) throw new Error("avatar.png 必须提供显式编码的 PNG 原始字节");
+	const preparedFiles = [{
+		path: MODULE_DEFINITION_FILE,
+		content: yaml,
+		encoding: "utf8"
+	}, ...resources];
+	if ((first.kind === "st-character" || first.kind === "native-character") && !resources.some((file) => file.path === "card.json")) preparedFiles.push({
+		path: "card.json",
+		content: first.sourceText,
+		encoding: "utf8"
+	});
+	if (first.avatar !== void 0 && !resources.some((file) => file.path.toLowerCase() === "avatar.png")) preparedFiles.push({
+		path: "avatar.png",
+		content: first.avatar.toString("base64"),
+		encoding: "base64"
+	});
+	return {
+		state: "ready",
+		kind: first.kind,
+		spec,
+		yaml,
+		files: preparedFiles,
+		sourceName: candidates.map((file) => file.path).join("、"),
+		sourceDigest,
+		...report === void 0 ? {} : { report },
+		...avatar === void 0 ? {} : { avatar },
+		sourceText: first.sourceText
+	};
+}
+//#endregion
+//#region src/host/characters.ts
+/** 角色卡只是普通模块的导入来源；历史角色库仅用于分享过滤的只读核验。 */
+function isRecord$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** 检查祖先与最终文件，避免 junction 或单文件链接越界。 */
+function assertNoLinks(path) {
+	const absolute = resolve(path);
+	const parent = dirname(absolute);
+	if (parent !== absolute) assertNoLinks(parent);
+	if (modulePathExists(absolute) && lstatSync(absolute).isSymbolicLink()) throw new Error(`模块路径包含链接：${absolute}`);
+}
+function memoryFile(moduleDir) {
+	assertNoLinks(moduleDir);
+	return join(assertModuleDirectory(dirname(moduleDir), basename(moduleDir)), "memory.md");
+}
+/** 模块记忆与条目同归当前模块；来源和 id 前缀不改变位置。 */
+function appendModuleMemory(moduleDir, note) {
+	const content = note.trim();
+	if (content.length === 0) return;
+	const file = memoryFile(moduleDir);
+	assertNoLinks(file);
+	const line = `\n- [${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ")}] ${content}\n`;
+	if (modulePathExists(file)) appendFileSync(file, line, "utf8");
+	else writeFileSync(file, `# 本地记忆\n${line}`, "utf8");
+}
+/** 每次显式读取最新字节；缺失为空，链接与读取失败原样报错。 */
+function readModuleMemory(moduleDir) {
+	const file = memoryFile(moduleDir);
+	assertNoLinks(file);
+	return modulePathExists(file) ? readFileSync(file, "utf8") : "";
+}
+function loadSpecFile(file) {
+	assertNoLinks(file);
+	if (!modulePathExists(file)) return void 0;
+	const parsed = parse(readFileSync(file, "utf8"), { logLevel: "silent" });
+	if (!isRecord$1(parsed)) throw new Error(`模块定义不是对象：${file}`);
+	assertCanonicalRuleSource(parsed);
+	return parsed;
+}
+function loadModuleSource(root, id) {
+	assertModuleId(id);
+	const dir = join(root, id);
+	assertNoLinks(dir);
+	if (!modulePathExists(dir)) return void 0;
+	return loadSpecFile(join(assertModuleDirectory(root, id), MODULE_DEFINITION_FILE));
+}
+const CHARACTER_MEMORIES_KEY = "characterMemories";
+function contentHash(value) {
+	const canonical = (item) => Array.isArray(item) ? item.map(canonical) : isRecord$1(item) ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, canonical(item[key])])) : item;
+	return createHash("sha256").update(JSON.stringify(canonical(value))).digest("hex");
+}
+function memoryRecords(meta) {
+	if (!isRecord$1(meta) || !isRecord$1(meta[CHARACTER_MEMORIES_KEY])) return {};
+	return Object.fromEntries(Object.entries(meta[CHARACTER_MEMORIES_KEY]).filter(([id, record]) => isRecord$1(record) && record.characterId === id && typeof record.configId === "string" && typeof record.contentHash === "string"));
+}
+function importPrefixes(id) {
+	return [`module-${id}-`, `chara-${id}-`];
+}
+/** 分享副本只排除可核验的历史自动记忆；来源缺失或被编辑时须明确选择。 */
+function projectCharacterMemories(source, choices = {}, moduleRoot) {
+	const doc = source.clone();
+	const spec = doc.toJS();
+	const records = memoryRecords(spec.meta);
+	const imported = [.../* @__PURE__ */ new Set([...Array.isArray(spec.meta?.importedCharacters) ? spec.meta.importedCharacters.filter((id) => typeof id === "string") : [], ...Object.keys(readMergedModules(spec.meta))])];
+	const conflicts = [];
+	const excluded = /* @__PURE__ */ new Set();
+	assertCanonicalRuleSource(spec);
+	for (const [index, config] of (spec.rules ?? []).entries()) {
+		if (!isRecord$1(config) || typeof config.id !== "string") continue;
+		const id = config.id;
+		const proof = Object.values(records).find((record) => record.configId === id);
+		if (proof !== void 0 && proof.contentHash === contentHash(config)) {
+			excluded.add(index);
+			continue;
+		}
+		const cardId = imported.find((card) => importPrefixes(card).some((base) => id === `${base}memory` || id.startsWith(`${base}memory-`))) ?? proof?.characterId;
+		if (cardId === void 0) continue;
+		if (moduleRoot !== void 0) {
+			assertModuleId(cardId);
+			const legacyDir = join(dirname(moduleRoot), ".characters", cardId);
+			const normal = loadModuleSource(moduleRoot, cardId);
+			const original = normal ?? loadSpecFile(join(legacyDir, "converted.yml"));
+			if (original?.rules?.some((entry) => importPrefixes(cardId).some((base) => `${base}${entry.id}` === id))) continue;
+			const file = join(normal === void 0 ? legacyDir : join(moduleRoot, cardId), "memory.md");
+			assertNoLinks(file);
+			const memory = modulePathExists(file) ? readFileSync(file, "utf8").trim() : "";
+			if (original !== void 0 && memory.length > 0) {
+				const entry = buildWorldBookEntry({
+					name: "角色记忆",
+					enabled: true,
+					order: 3e3,
+					text: `【${original.name} 的关系记忆】\n${memory}`,
+					constant: true
+				});
+				if (contentHash(promptConfigToRule({
+					...entry,
+					id
+				})) === contentHash(config)) {
+					excluded.add(index);
+					continue;
+				}
+			}
+		}
+		if (choices[id] === "exclude") excluded.add(index);
+		else if (choices[id] !== "include") conflicts.push({
+			id,
+			name: String(config.name ?? id)
+		});
+	}
+	const configs = doc.get("rules", true);
+	if (configs instanceof YAMLSeq) for (const index of [...excluded].sort((a, b) => b - a)) configs.delete(index);
+	else if (excluded.size > 0) doc.set("rules", (spec.rules ?? []).filter((_, index) => !excluded.has(index)));
+	if (doc.hasIn(["meta", CHARACTER_MEMORIES_KEY])) doc.deleteIn(["meta", CHARACTER_MEMORIES_KEY]);
+	return {
+		doc,
+		excludedMemoryCount: excluded.size,
+		memoryConflicts: conflicts
+	};
+}
+function importChoices(options) {
+	return {
+		...options,
+		promptOrderCharacterId: options.promptOrderCharacterId ?? options.characterId
+	};
+}
+/** 复用普通模块候选校验、版本保护和目录交换，不生成角色专属存储。 */
+async function importCharacterCard(root, files, options = {}) {
+	try {
+		const prepared = prepareImport(files, "character", importChoices(options));
+		if (prepared.state !== "ready") return {
+			ok: false,
+			message: "请先选择角色内容类型或提示顺序组"
+		};
+		const moduleFiles = prepared.files;
+		const { moduleImportPreview, installModulePackage } = await import("./module-package-CHPFweqK.mjs");
+		const request = {
+			...importChoices(options),
+			sourceKind: "native-character"
+		};
+		const preview = moduleImportPreview(root, moduleFiles, request);
+		if (!("prepared" in preview)) return {
+			ok: false,
+			message: "请先选择角色内容类型或提示顺序组"
+		};
+		if (preview.summary.exists && options.overwrite === true) readModuleMemory(join(root, preview.summary.targetId));
+		const installed = await installModulePackage(root, moduleFiles, {
+			...request,
+			expectedSourceDigest: preview.sourceDigest,
+			expectedPreviewRevision: preview.previewRevision
+		}, { preserveAssets: true });
+		return {
+			ok: true,
+			id: installed.id,
+			name: preview.summary.targetName,
+			...installed.backupPath === void 0 ? {} : { warning: `模块已安装；旧备份保留在 ${installed.backupPath}` }
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: `角色卡导入失败：${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+async function importCharacterCardFile(root, filePath, fileName = basename(filePath), options = {}) {
+	try {
+		const buffer = readFileSync(filePath);
+		return await importCharacterCard(root, [{
+			path: basename(fileName),
+			content: buffer.toString("base64"),
+			encoding: "base64"
+		}], options);
+	} catch (error) {
+		return {
+			ok: false,
+			message: `角色卡转换失败：${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+/** 旧登记仅在此读边界转换，新写入只落 mergedModules。 */
+function readMergedModules(meta) {
+	if (!isRecord$1(meta)) return {};
+	if (isRecord$1(meta.mergedModules)) return Object.fromEntries(Object.entries(meta.mergedModules).filter(([, value]) => isRecord$1(value) && typeof value.active === "boolean" && Array.isArray(value.capabilities)).map(([id, value]) => {
+		const row = value;
+		return [id, {
+			active: row.active === true,
+			capabilities: row.capabilities.filter((item) => typeof item === "string")
+		}];
+	}));
+	const active = Array.isArray(meta.importedCharacters) ? meta.importedCharacters.filter((id) => typeof id === "string") : [];
+	const old = isRecord$1(meta.characterModules) ? meta.characterModules : {};
+	return Object.fromEntries([.../* @__PURE__ */ new Set([...active, ...Object.keys(old)])].map((id) => [id, {
+		active: active.includes(id),
+		capabilities: Array.isArray(old[id]) ? old[id].filter((item) => typeof item === "string") : []
+	}]));
+}
+function writeMergedModules(doc, records) {
+	doc.setIn(["meta", "mergedModules"], records);
+	for (const key of ["importedCharacters", "characterModules"]) if (doc.hasIn(["meta", key])) doc.deleteIn(["meta", key]);
+}
+function declaredCapabilities(spec) {
+	return Array.isArray(spec.modules) ? [...new Set(spec.modules.filter((item) => typeof item === "string" && item.length > 0))] : [];
+}
+function readCapabilities(doc) {
+	return declaredCapabilities(doc.toJS());
+}
+function capabilityStillNeeded(capability, spec, active) {
+	const configs = ruleInjections(spec.rules ?? []).map(({ config }) => config);
+	switch (capability) {
+		case "rule-engine": return (spec.rules?.length ?? 0) > 0;
+		case "prompt-config-engine": return configs.length > 0;
+		case "world-book-tools": return configs.some((config) => config.strategy === "world-book");
+		case "session-var-tools": return configs.some((config) => isRecord$1(config.params) && config.params.stMacros === true);
+		case "tool-config-engine": return (spec.customTools?.length ?? 0) > 0;
+		case "character-tools": return active.length > 0 || configs.some((config) => /^(module|chara)-/.test(String(config.id ?? "")));
+		default: return true;
+	}
+}
+/** 通用并入保留既有带前缀往返行为，不复制本地记忆。 */
+function mergeModuleIntoModule(root, targetId, sourceId) {
+	try {
+		if (sourceId === targetId) throw new Error("不能把模块并入自身");
+		const dir = assertModuleDirectory(root, targetId);
+		const spec = loadModuleSource(root, sourceId);
+		if (spec === void 0) throw new Error(`模块 ${sourceId} 不存在`);
+		validateCharacterSpec(spec);
+		const prefix = `module-${sourceId}-`;
+		let count = 0;
+		let personaOpened = false;
+		withModuleDefinition(dir, (doc) => {
+			const current = doc.toJS();
+			assertCanonicalRuleSource(current);
+			if (ruleInjections(spec.rules).some(({ config }) => config.layer === "system-section") && current.persona?.complete === true) {
+				doc.setIn(["persona", "complete"], false);
+				personaOpened = true;
+			}
+			const existing = (current.rules ?? []).filter((rule) => !importPrefixes(sourceId).some((base) => rule.id.startsWith(base)));
+			const added = (spec.rules ?? []).map((rule) => mapRuleInjections({
+				...rule,
+				id: `${prefix}${rule.id}`
+			}, (config) => ({
+				...config,
+				id: `${prefix}${config.id}`,
+				variables: {
+					...spec.variablesEnabled === false ? {} : spec.variables,
+					...config.variables
+				}
+			})));
+			for (const [key, value] of Object.entries(readModuleLayerSettings(spec))) doc.setIn(engineParamPath(key), value);
+			const merged = [...existing, ...added];
+			compileRules(merged, { promptConfigOptions: rulePromptConfigOptions(dir) });
+			const before = readCapabilities(doc);
+			const required = ["rule-engine", ...ruleInjections(merged).some(({ config }) => config.strategy === "world-book") ? ["world-book-tools"] : []];
+			appendModuleCapabilities(doc, [.../* @__PURE__ */ new Set([...declaredCapabilities(spec), ...required])]);
+			const records = readMergedModules(current.meta);
+			records[sourceId] = {
+				active: true,
+				capabilities: [.../* @__PURE__ */ new Set([...records[sourceId]?.capabilities ?? [], ...readCapabilities(doc).filter((capability) => !before.includes(capability))])]
+			};
+			writeMergedModules(doc, records);
+			doc.set("rules", merged);
+			if (Array.isArray(spec.meta?.stWarnings) && spec.meta.stWarnings.length > 0) {
+				const warnings = Array.isArray(current.meta?.stWarnings) ? current.meta.stWarnings : [];
+				doc.setIn(["meta", "stWarnings"], [...new Set([...warnings, ...spec.meta.stWarnings].filter((value) => typeof value === "string"))]);
+			}
+			count = added.length;
+		});
+		return {
+			ok: true,
+			count,
+			...personaOpened ? { personaOpened: true } : {}
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: `并入失败：${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+/** 撤销并入内容；旧 chara 前缀可撤销，能力归属只写一份登记。 */
+function removeMergedModule(root, targetId, sourceId) {
+	try {
+		assertModuleId(sourceId);
+		const dir = assertModuleDirectory(root, targetId);
+		const spec = loadModuleSource(root, sourceId);
+		let removed = 0;
+		withModuleDefinition(dir, (doc) => {
+			const current = doc.toJS();
+			assertCanonicalRuleSource(current);
+			const kept = (current.rules ?? []).filter((rule) => !importPrefixes(sourceId).some((base) => rule.id.startsWith(base)));
+			removed = (current.rules?.length ?? 0) - kept.length;
+			compileRules(kept, { promptConfigOptions: rulePromptConfigOptions(dir) });
+			doc.set("rules", kept);
+			for (const rule of current.rules ?? []) if (!kept.some((item) => item.id === rule.id) && doc.hasIn(["configOrder", rule.id])) doc.deleteIn(["configOrder", rule.id]);
+			if (doc.hasIn([
+				"meta",
+				CHARACTER_MEMORIES_KEY,
+				sourceId
+			])) doc.deleteIn([
+				"meta",
+				CHARACTER_MEMORIES_KEY,
+				sourceId
+			]);
+			for (const [key, value] of Object.entries(spec === void 0 ? {} : readModuleLayerSettings(spec))) {
+				const path = engineParamPath(key);
+				if (doc.getIn(path) === value) doc.deleteIn(path);
+			}
+			const records = readMergedModules(current.meta);
+			if (records[sourceId] !== void 0) records[sourceId].active = false;
+			const active = Object.keys(records).filter((id) => records[id].active);
+			const claimed = /* @__PURE__ */ new Set();
+			for (const id of active) {
+				for (const capability of records[id].capabilities) claimed.add(capability);
+				const other = loadModuleSource(root, id);
+				if (other !== void 0) for (const capability of declaredCapabilities(other)) claimed.add(capability);
+			}
+			const introduced = new Set(Object.values(records).flatMap((record) => record.capabilities));
+			const next = readCapabilities(doc).filter((capability) => !introduced.has(capability) || claimed.has(capability) || capabilityStillNeeded(capability, doc.toJS(), active));
+			doc.set("modules", next);
+			for (const [id, record] of Object.entries(records)) {
+				record.capabilities = record.capabilities.filter((capability) => next.includes(capability));
+				if (!record.active && record.capabilities.length === 0) delete records[id];
+			}
+			writeMergedModules(doc, records);
+		});
+		return {
+			ok: true,
+			count: removed
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: `移除失败：${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+//#endregion
+//#region src/host/asset-archive.ts
+/** ZIP 仅负责载体，不决定资产语义或写入目标。 */
+function safeAssetPath(path) {
+	if (typeof path !== "string" || path.length === 0 || path.length > 1024 || path.includes("\\") || path.startsWith("/") || /[\p{Cc}<>:"|?*]/u.test(path)) throw new Error(`非法资源路径：${path}`);
+	if (path.split("/").some((part) => part === "" || part === "." || part === ".." || /[. ]$/.test(part) || /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part))) throw new Error(`非法资源路径：${path}`);
+	return path;
+}
+async function unpackZip(bytes) {
+	if (bytes.length > 67108864) throw new Error("ZIP 超过 64 MiB 上限");
+	const reader = new ZipReader(new Uint8ArrayReader(bytes), { useWebWorkers: false });
+	const files = [];
+	const seen = /* @__PURE__ */ new Set();
+	let total = 0;
+	let entries = 0;
+	try {
+		for await (const entry of reader.getEntriesGenerator()) {
+			if (++entries > 2048) throw new Error("ZIP 文件数超过上限");
+			const path = safeAssetPath(entry.filename.replace(/\/$/, ""));
+			const key = path.normalize("NFC").toLowerCase();
+			if (seen.has(key)) throw new Error(`ZIP 路径重复：${path}`);
+			seen.add(key);
+			const fileType = entry.externalFileAttributes >>> 16 & 61440;
+			if (entry.encrypted || entry.symlink || ![
+				0,
+				32768,
+				16384
+			].includes(fileType)) throw new Error(`ZIP 不允许加密项、链接或特殊文件：${path}`);
+			if (entry.directory) continue;
+			if (entry.uncompressedSize > 67108864 || total + entry.uncompressedSize > 67108864) throw new Error("ZIP 解压大小超过 64 MiB");
+			const chunks = [];
+			let size = 0;
+			await entry.getData(new WritableStream({ write(chunk) {
+				size += chunk.length;
+				total += chunk.length;
+				if (total > 67108864) throw new Error("ZIP 实际解压大小超过 64 MiB");
+				chunks.push(Buffer.from(chunk));
+			} }), { checkSignature: true });
+			if (size !== entry.uncompressedSize) throw new Error(`ZIP 长度不符：${path}`);
+			files.push({
+				path,
+				encoding: "base64",
+				content: Buffer.concat(chunks).toString("base64")
+			});
+		}
+	} finally {
+		await reader.close();
+	}
+	if (files.length === 0) throw new Error("ZIP 没有可导入文件");
+	return files;
+}
+async function packZip(files) {
+	const writer = new ZipWriter(new Uint8ArrayWriter(), { useWebWorkers: false });
+	for (const file of files) await writer.add(safeAssetPath(file.path), new Uint8ArrayReader(file.bytes));
+	return writer.close();
+}
+//#endregion
+//#region src/host/preview-revision.ts
+/**
+* 导入预览版本（previewRevision）：把「这次预览代表哪一次输入」压成稳定摘要。
+*
+* 预览身份与写入凭证是两件事：`sourceDigest` 只证明「提交的文件内容与预览时相同」，
+* 而 `previewRevision` 还绑定**实际选组**、**转换器版本**与**目标身份（含目标当前版本）**，
+* 因此换组、换文件、换目标或预览期间目标被改动都会失配。版本永远由服务端计算，
+* 客户端只回传；凭据不构成写入授权，服务端每次提交都重算。
+*/
+/** 预览协议版本：字段语义变化时递增，纳入 revision 计算。 */
+const PREVIEW_PROTOCOL_VERSION = "st-preview/1";
+/** 文件顺序参与身份（多文件合并结果依赖顺序），因此不做排序。 */
+function fileFingerprint(entry) {
+	return [entry.path, createHash("sha256").update(entry.content).digest("hex")];
+}
+/** 结构化、确定序列化后的 SHA-256：同输入必得同值，任一绑定项变化即改变。 */
+function computePreviewRevision(input) {
+	const canonical = JSON.stringify([
+		PREVIEW_PROTOCOL_VERSION,
+		input.converter,
+		input.files.map(fileFingerprint),
+		input.orderCharacterId ?? null,
+		[
+			input.target.kind,
+			input.target.targetId,
+			input.target.targetVersion,
+			input.target.ownerPreset
+		]
+	]);
+	return createHash("sha256").update(canonical).digest("hex");
+}
+/**
+* 目录内容版本：按相对路径排序后逐个摘要文件内容，目录不存在返回 `null`。
+* 只用于目标身份的"是否被改过"判断，不持久化、不缓存。
+*/
+function directoryVersionOf(dir) {
+	try {
+		if (!lstatSync(dir).isDirectory() || lstatSync(dir).isSymbolicLink()) throw new Error("目标不是普通目录");
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+	const hash = createHash("sha256");
+	const walk = (current, prefix) => {
+		for (const entry of readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+			if (entry.isSymbolicLink()) throw new Error(`目标包含链接：${entry.name}`);
+			const rel = prefix.length === 0 ? entry.name : `${prefix}/${entry.name}`;
+			if (entry.isDirectory()) {
+				hash.update(`D\u0000${rel}\u0000`);
+				walk(join(current, entry.name), rel);
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			hash.update(`F\u0000${rel}\u0000`);
+			hash.update(readFileSync(join(current, entry.name)));
+		}
+	};
+	walk(dir, "");
+	return hash.digest("hex");
+}
+//#endregion
+//#region engine/tool-definition.mjs
+/** 自定义工具物化定义的纯校验：host 保存/物化与运行时共用，不加载宿主服务。 */
+const TOOL_NAME_RE = /^[a-z][a-z0-9_]*$/;
+const JSON_SCHEMA_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"integer",
+	"boolean",
+	"null",
+	"array",
+	"object"
+]);
+const JSON_SCHEMA_ANNOTATIONS = /* @__PURE__ */ new Set([
+	"description",
+	"title",
+	"default",
+	"examples"
+]);
+/** JSON Schema 结构校验；DSL 转换与官方 registry 仍负责 enforced subset 校验。 */
+function validateJsonSchemaNode(node, path, seen = /* @__PURE__ */ new Set()) {
+	if (node === null || typeof node !== "object" || Array.isArray(node)) throw new TypeError(`${path} must be an object`);
+	if (seen.has(node)) throw new TypeError(`${path} is circular`);
+	seen.add(node);
+	try {
+		if (node.type !== void 0) {
+			if (!JSON_SCHEMA_TYPES.has(node.type)) throw new TypeError(`${path}.type must be one of ${[...JSON_SCHEMA_TYPES].join("/")} (dsh-tools DSL 形态 'json'/'oneOf' 未在物化时转换)`);
+			if (node.type === "object") {
+				if (node.properties !== void 0) {
+					if (node.properties === null || typeof node.properties !== "object" || Array.isArray(node.properties)) throw new TypeError(`${path}.properties must be an object of schemas`);
+					for (const [key, child] of Object.entries(node.properties)) validateJsonSchemaNode(child, `${path}.properties.${key}`, seen);
+				}
+				if (node.required !== void 0) {
+					if (!Array.isArray(node.required) || node.required.some((item) => typeof item !== "string")) throw new TypeError(`${path}.required must be an array of property names`);
+				}
+				if (node.additionalProperties !== void 0 && typeof node.additionalProperties !== "boolean") throw new TypeError(`${path}.additionalProperties must be a boolean`);
+			}
+			if (node.type === "array" && node.items !== void 0) validateJsonSchemaNode(node.items, `${path}.items`, seen);
+		} else if (Array.isArray(node.oneOf)) {
+			if (node.oneOf.length < 2) throw new TypeError(`${path}.oneOf needs at least two branches`);
+			for (const [index, branch] of node.oneOf.entries()) validateJsonSchemaNode(branch, `${path}.oneOf[${index}]`, seen);
+		} else if (!Object.keys(node).every((key) => JSON_SCHEMA_ANNOTATIONS.has(key))) throw new TypeError(`${path} must declare type or oneOf (or contain annotations only)`);
+	} finally {
+		seen.delete(node);
+	}
+}
+/** 完整定义校验；保存方拒绝写盘，writer / runtime 按单条告警跳过。 */
+function validateDefinition(def) {
+	if (def === null || typeof def !== "object" || Array.isArray(def)) throw new TypeError("tool definition must be an object");
+	if (typeof def.id !== "string" || def.id.trim().length === 0) throw new TypeError("tool definition needs a non-empty string id");
+	if (typeof def.name !== "string" || !TOOL_NAME_RE.test(def.name)) throw new TypeError(`tool name ${JSON.stringify(def.name)} must match ${TOOL_NAME_RE}`);
+	if (typeof def.description !== "string" || def.description.trim().length === 0) throw new TypeError(`tool ${def.id}: description is required`);
+	if (def.scope !== void 0) throw new TypeError(`tool ${def.id}: customTools.scope is not supported (subagent tool policy is configured via subagentToolPolicy, not per-tool scope)`);
+	if (def.parameters !== void 0) validateJsonSchemaNode(def.parameters, `tool ${def.id}: parameters`);
+	const output = def.output;
+	if (output === null || typeof output !== "object" || Array.isArray(output)) throw new TypeError(`tool ${def.id}: output is required`);
+	validateJsonSchemaNode(output.schema, `tool ${def.id}: output.schema`);
+	const exec = def.execute;
+	if (exec === null || typeof exec !== "object" || Array.isArray(exec)) throw new TypeError(`tool ${def.id}: execute is required`);
+	if (typeof exec.kind !== "string" || ![
+		"shell",
+		"http",
+		"delegate",
+		"fs",
+		"ask-user"
+	].includes(exec.kind)) throw new TypeError(`tool ${def.id}: execute.kind must be shell/http/delegate/fs/ask-user`);
+	if (exec.kind === "shell" && (typeof exec.command !== "string" || exec.command.trim().length === 0)) throw new TypeError(`tool ${def.id}: execute.command is required for shell`);
+	if (exec.kind === "http" && (typeof exec.url !== "string" || exec.url.trim().length === 0)) throw new TypeError(`tool ${def.id}: execute.url is required for http`);
+	if (exec.kind === "delegate" && (typeof exec.tool !== "string" || exec.tool.length === 0)) throw new TypeError(`tool ${def.id}: execute.tool is required for delegate`);
+	if (exec.kind === "fs" && (typeof exec.action !== "string" || ![
+		"read",
+		"write",
+		"append",
+		"list",
+		"delete"
+	].includes(exec.action) && !exec.action.includes("{{args."))) throw new TypeError(`tool ${def.id}: execute.action must be read/write/append/list/delete (or {{args.*}} template) for fs`);
+	if (def.enabled !== void 0 && typeof def.enabled !== "boolean") throw new TypeError(`tool ${def.id}: enabled must be a boolean`);
+	if (def.timeoutMs !== void 0 && (!Number.isSafeInteger(def.timeoutMs) || def.timeoutMs <= 0 || def.timeoutMs > 2147483647)) throw new TypeError(`tool ${def.id}: timeoutMs must be an integer from 1 to 2147483647`);
+	for (const field of [
+		"command",
+		"shell",
+		"url",
+		"method",
+		"tool",
+		"action",
+		"path",
+		"content",
+		"question"
+	]) if (exec[field] !== void 0 && typeof exec[field] !== "string") throw new TypeError(`tool ${def.id}: execute.${field} must be a string`);
+	if (exec.shell !== void 0 && (exec.shell.trim().length === 0 || exec.shell.includes("\0"))) throw new TypeError(`tool ${def.id}: execute.shell must be a non-empty executable name or path without NUL`);
+	if (exec.method !== void 0 && !/^\{\{args\.[A-Za-z0-9_.]+\}\}$/.test(exec.method) && (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(exec.method) || [
+		"CONNECT",
+		"TRACE",
+		"TRACK"
+	].includes(exec.method.toUpperCase()))) throw new TypeError(`tool ${def.id}: execute.method must be a supported HTTP method token`);
+	if (exec.kind === "fs" && (typeof exec.path !== "string" || exec.path.includes("\0"))) throw new TypeError(`tool ${def.id}: execute.path must be a string without NUL for fs`);
+	for (const field of [
+		"env",
+		"headers",
+		"args"
+	]) {
+		const value = exec[field];
+		if (value === void 0) continue;
+		if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`tool ${def.id}: execute.${field} must be an object`);
+		if (field !== "args" && Object.values(value).some((entry) => typeof entry !== "string")) throw new TypeError(`tool ${def.id}: execute.${field} values must be strings`);
+		if (field === "env" && Object.entries(value).some(([key, entry]) => key.length === 0 || /[=\0]/.test(key) || entry.includes("\0"))) throw new TypeError(`tool ${def.id}: execute.env must contain valid environment names and values`);
+		if (field === "headers") try {
+			new Headers(value);
+		} catch {
+			throw new TypeError(`tool ${def.id}: execute.headers must contain valid HTTP names and values`);
+		}
+	}
+	let serialized;
+	try {
+		serialized = JSON.stringify(def);
+	} catch {
+		throw new TypeError(`tool ${def.id}: definition must be JSON serializable`);
+	}
+	if (Buffer.byteLength(serialized, "utf8") > 1048576) throw new TypeError(`tool ${def.id}: definition must not exceed 1048576 UTF-8 bytes`);
+}
+//#endregion
+//#region src/host/custom-tools.ts
+/** 自定义工具的保存校验与物化：只编译定义，不注册或执行工具，不修改输入。 */
+/** 官方 DSL → 运行时 JSON Schema；非法字段抛错，id 必填，空 name 回落 id。 */
+function compileCustomTool(tool) {
+	if (tool === null || typeof tool !== "object" || Array.isArray(tool)) throw new TypeError("custom tool must be an object");
+	const id = typeof tool.id === "string" ? tool.id.trim() : "";
+	assertSafeConfigId(id);
+	const name = typeof tool.name === "string" ? tool.name.trim() || id : tool.name === void 0 ? id : tool.name;
+	const next = {
+		...tool,
+		id,
+		name
+	};
+	if (tool.parameters !== void 0) try {
+		next.parameters = parameterSchemaSpecToJsonSchema(tool.parameters);
+	} catch (error) {
+		throw new TypeError(`parameters: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const output = tool.output;
+	if (output === null || typeof output !== "object" || Array.isArray(output)) throw new TypeError("output.schema is required");
+	const outputRecord = output;
+	try {
+		next.output = {
+			...outputRecord,
+			schema: valueSchemaSpecToJsonSchema(outputRecord.schema)
+		};
+	} catch (error) {
+		throw new TypeError(`output.schema: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	validateDefinition(next);
+	return next;
+}
+/** 先拒绝非法/重复身份，再完整编译每条定义（包括停用条目），供 bridge 写盘前调用。 */
+function validateCustomTools(tools) {
+	const errors = validateCustomToolIdentities(tools);
+	if (errors.length > 0) return errors;
+	for (const [index, tool] of tools.entries()) try {
+		compileCustomTool(tool);
+	} catch (error) {
+		errors.push(`customTools[${index}]: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return errors;
+}
+//#endregion
+//#region engine/subagent-tool-policy-core.mjs
+/** 解析字符串列表（数组或逗号/空格分隔字符串），非字符串项报错。 */
+function stringList(value, path, errors, { allowEmpty = true } = {}) {
+	if (value === void 0 || value === null) return [];
+	const raw = Array.isArray(value) ? value : typeof value === "string" ? value.split(/[,\s]+/) : void 0;
+	if (raw === void 0) {
+		errors.push(`${path} must be an array of strings`);
+		return [];
+	}
+	const out = [];
+	for (const item of raw) {
+		if (typeof item !== "string" || item.trim().length === 0) {
+			errors.push(`${path} must contain only non-empty strings`);
+			continue;
+		}
+		if (!out.includes(item.trim())) out.push(item.trim());
+	}
+	return out;
+}
+/** 校验策略；返回错误列表（空 = 合法）。 */
+function validateSubagentToolPolicy(raw) {
+	const errors = [];
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return ["subagentToolPolicy must be an object"];
+	const defaultProfile = raw.defaultProfile;
+	if (typeof defaultProfile !== "string" || defaultProfile.length === 0) errors.push("subagentToolPolicy.defaultProfile is required");
+	const ceiling = raw.ceiling;
+	if (ceiling === null || typeof ceiling !== "object" || Array.isArray(ceiling)) errors.push("subagentToolPolicy.ceiling is required");
+	const ceilingAllow = ceiling !== null && typeof ceiling === "object" && !Array.isArray(ceiling) ? stringList(ceiling.allow, "ceiling.allow", errors) : [];
+	if (ceilingAllow.length === 0) errors.push("subagentToolPolicy.ceiling.allow must be a non-empty list");
+	ceiling !== null && typeof ceiling === "object" && !Array.isArray(ceiling) && stringList(ceiling.deny, "ceiling.deny", errors);
+	const profileIds = /* @__PURE__ */ new Set();
+	const profiles = Array.isArray(raw.profiles) ? raw.profiles : [];
+	if (profiles.length === 0) errors.push("subagentToolPolicy.profiles must declare at least one profile");
+	for (const [index, profile] of profiles.entries()) {
+		const path = `profiles[${index}]`;
+		if (profile === null || typeof profile !== "object" || Array.isArray(profile)) {
+			errors.push(`${path} must be an object`);
+			continue;
+		}
+		if (typeof profile.id !== "string" || profile.id.length === 0) errors.push(`${path}.id is required`);
+		else {
+			if (profileIds.has(profile.id)) errors.push(`${path}.id ${JSON.stringify(profile.id)} is duplicated`);
+			profileIds.add(profile.id);
+		}
+		if (typeof profile.name !== "string" || profile.name.length === 0) errors.push(`${path}.name is required`);
+		const allow = stringList(profile.allow, `${path}.allow`, errors);
+		const deny = stringList(profile.deny, `${path}.deny`, errors);
+		for (const tool of allow) if (!ceilingAllow.includes(tool)) errors.push(`${path}.allow tool ${JSON.stringify(tool)} exceeds ceiling.allow`);
+		for (const tool of deny) if (!ceilingAllow.includes(tool)) errors.push(`${path}.deny tool ${JSON.stringify(tool)} is not in ceiling.allow`);
+		if (typeof profile.modelSelectable !== "undefined" && typeof profile.modelSelectable !== "boolean") errors.push(`${path}.modelSelectable must be a boolean`);
+	}
+	const characterIds = /* @__PURE__ */ new Set();
+	const characterBindings = Array.isArray(raw.characterBindings) ? raw.characterBindings : [];
+	for (const [index, binding] of characterBindings.entries()) {
+		const path = `characterBindings[${index}]`;
+		if (binding === null || typeof binding !== "object" || Array.isArray(binding)) {
+			errors.push(`${path} must be an object`);
+			continue;
+		}
+		if (typeof binding.characterId !== "string" || binding.characterId.length === 0) errors.push(`${path}.characterId is required`);
+		else {
+			if (characterIds.has(binding.characterId)) errors.push(`${path}.characterId ${JSON.stringify(binding.characterId)} is duplicated`);
+			characterIds.add(binding.characterId);
+		}
+		if (typeof binding.profile !== "string" || !profileIds.has(binding.profile)) errors.push(`${path}.profile ${JSON.stringify(binding.profile)} must reference an existing profile`);
+	}
+	const taskIds = /* @__PURE__ */ new Set();
+	const taskRules = Array.isArray(raw.taskRules) ? raw.taskRules : [];
+	for (const [index, rule] of taskRules.entries()) {
+		const path = `taskRules[${index}]`;
+		if (rule === null || typeof rule !== "object" || Array.isArray(rule)) {
+			errors.push(`${path} must be an object`);
+			continue;
+		}
+		if (typeof rule.id !== "string" || rule.id.length === 0) errors.push(`${path}.id is required`);
+		else {
+			if (taskIds.has(rule.id)) errors.push(`${path}.id ${JSON.stringify(rule.id)} is duplicated`);
+			taskIds.add(rule.id);
+		}
+		if (typeof rule.pattern !== "string" || rule.pattern.length === 0) errors.push(`${path}.pattern is required`);
+		else try {
+			new RegExp(rule.pattern);
+		} catch (error) {
+			errors.push(`${path}.pattern is not a valid regular expression: ${String(error.message ?? error)}`);
+		}
+		if (typeof rule.order !== "number" || !Number.isSafeInteger(rule.order)) errors.push(`${path}.order must be an integer`);
+		if (typeof rule.profile !== "string" || !profileIds.has(rule.profile)) errors.push(`${path}.profile ${JSON.stringify(rule.profile)} must reference an existing profile`);
+	}
+	const expansion = raw.modelExpansion;
+	if (expansion !== void 0 && expansion !== null) {
+		const expansionPath = "modelExpansion";
+		if (typeof expansion !== "object" || Array.isArray(expansion)) errors.push(`${expansionPath} must be an object`);
+		else {
+			const expansionAllow = stringList(expansion.allow, `${expansionPath}.allow`, errors);
+			for (const tool of expansionAllow) if (!ceilingAllow.includes(tool)) errors.push(`${expansionPath}.allow tool ${JSON.stringify(tool)} exceeds ceiling.allow`);
+			if (expansion.maxAdditionalTools !== void 0 && (!Number.isSafeInteger(expansion.maxAdditionalTools) || expansion.maxAdditionalTools < 0)) errors.push(`${expansionPath}.maxAdditionalTools must be a non-negative safe integer`);
+		}
+	}
+	if (defaultProfile !== void 0 && typeof defaultProfile === "string" && defaultProfile.length > 0 && !profileIds.has(defaultProfile)) errors.push(`subagentToolPolicy.defaultProfile ${JSON.stringify(defaultProfile)} must reference an existing profile`);
+	return errors;
+}
+//#endregion
+//#region src/host/write-preset.ts
+/** 模块完整定义校验、运行切片恢复与隔离导入候选。普通重建不交换用户目录。 */
+const LEGACY_ARTIFACTS = [
+	"configs",
+	"rules.yml",
+	"agent.cordis.yml",
+	"custom-tools",
+	"subagent-tools",
+	"triggers.yml"
+];
+function validateModule(directory, warn) {
+	assertModuleTree(directory);
+	const snapshot = loadModuleDefinition(directory);
+	const spec = {
+		...snapshot.source,
+		id: snapshot.source.id ?? basename(snapshot.dir),
+		rules: snapshot.rules,
+		configOrder: snapshot.configOrder,
+		variables: snapshot.variables,
+		variablesEnabled: snapshot.variablesEnabled
+	};
+	assertCompositionArray(renderComposition(spec, {}, directory), spec);
+	if (spec.customTools !== void 0 && !Array.isArray(spec.customTools)) throw new TypeError("customTools must be an array");
+	const toolErrors = validateCustomTools(spec.customTools ?? []);
+	if (toolErrors.length > 0) throw new Error(`invalid customTools: ${toolErrors.join("; ")}`);
+	if (spec.subagentToolPolicy !== void 0 && spec.subagentToolPolicy !== null) {
+		const policyErrors = validateSubagentToolPolicy(spec.subagentToolPolicy);
+		if (policyErrors.length > 0) throw new Error(`invalid subagentToolPolicy: ${policyErrors.join("; ")}`);
+	}
+	if (Array.isArray(spec.meta?.stWarnings)) {
+		for (const warning of spec.meta.stWarnings) if (typeof warning === "string") warn?.(`prompt-tool: ST 导入兼容提示：${warning}`);
+	}
+}
+function removeLegacyArtifacts(directory) {
+	for (const name of LEGACY_ARTIFACTS) rmSync(join(directory, name), {
+		recursive: true,
+		force: true
+	});
+}
+/** 只有明确传入的非空内容才更新旧内容资产；空值保留原文件。 */
+function writeContentAssets(directory, prompt, agentsText) {
+	for (const [file, content] of [["preset.md", prompt], ["agents.md", agentsText]]) {
+		if (typeof content !== "string" || content.trim().length === 0) continue;
+		const path = join(directory, file);
+		if (!existsSync(path) || readFileSync(path, "utf8") !== content) atomicWriteTextFile(path, content);
+	}
+}
+/** 按模块身份原地恢复切片；用户资产、正文与完整定义均不重写。 */
+function ensureModuleReady(id, options) {
+	const root = options.modulesRoot ?? options.moduleDir ?? MODULES_DIR;
+	const directory = assertModuleDirectory(root, id);
+	validateModule(directory, options.warn);
+	if (enabledModuleIds(root).includes(id)) appendModuleConfigOrder(root, id);
+	ensureModuleSlices(directory);
+	withModuleLock(root, id, () => {
+		assertModuleDirectory(root, id);
+		removeLegacyArtifacts(directory);
+	});
+	return directory;
+}
+/** 已有同一模块只恢复切片；导入/复制先完整生成合法身份候选，再交换目标。 */
+function writeModule(prompt, options) {
+	const root = options.modulesRoot.trim().length > 0 ? options.modulesRoot : MODULES_DIR;
+	assertModuleId(options.moduleId);
+	const targetId = options.targetModuleId ?? options.moduleId;
+	assertModuleId(targetId);
+	const source = options.sourceDir ?? resolveModuleDir(options.moduleId, root);
+	validateModule(source, options.warn);
+	const target = assertModuleDirectory(root, targetId, true);
+	const targetVersion = options.stageOnly ? void 0 : directoryVersionOf(target);
+	if (!options.stageOnly && resolve(source) === resolve(target)) {
+		ensureModuleSlices(target);
+		withModuleLock(root, targetId, () => {
+			assertModuleDirectory(root, targetId);
+			writeContentAssets(target, prompt, options.agentsInstructionText);
+			removeLegacyArtifacts(target);
+		});
+		return target;
+	}
+	mkdirSync(root, { recursive: true });
+	const stageRoot = mkdtempSync(join(root, `.${targetId}.stage-`));
+	const candidate = join(stageRoot, targetId);
+	try {
+		mkdirSync(candidate);
+		for (const entry of readdirSync(source, { withFileTypes: true })) {
+			if (LEGACY_ARTIFACTS.includes(entry.name) || entry.name === "rules") continue;
+			cpSync(join(source, entry.name), join(candidate, entry.name), {
+				recursive: entry.isDirectory(),
+				force: true
+			});
+		}
+		const file = join(candidate, MODULE_DEFINITION_FILE);
+		const text = readFileSync(file, "utf8");
+		const doc = parseDocument(text, { logLevel: "silent" });
+		if (doc.get("id") !== targetId) {
+			doc.set("id", targetId);
+			validateModuleDefinitionText(candidate, doc.toString());
+			atomicWriteTextFile(file, doc.toString());
+		}
+		writeContentAssets(candidate, prompt, options.agentsInstructionText);
+		validateModule(candidate);
+		ensureModuleSlices(candidate);
+		if (options.stageOnly) return candidate;
+		withModuleLock(root, targetId, () => {
+			assertModuleDirectory(root, targetId, true);
+			if (directoryVersionOf(target) !== targetVersion) throw new ModuleRulesError("模块安装期间目标已变化，未覆盖", 409, "rules-conflict");
+			const backup = join(stageRoot, "previous");
+			const hadTarget = existsSync(target);
+			if (hadTarget) renameSync(target, backup);
+			try {
+				renameSync(candidate, target);
+			} catch (error) {
+				if (hadTarget) try {
+					renameSync(backup, target);
+				} catch (restoreError) {
+					throw new Error(`模块安装失败且恢复失败；原目录保留在 ${backup}: ${String(restoreError)}`, { cause: error });
+				}
+				throw error;
+			}
+		});
+		rmSync(stageRoot, {
+			recursive: true,
+			force: true
+		});
+		return target;
+	} catch (error) {
+		if (!existsSync(join(stageRoot, "previous"))) rmSync(stageRoot, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
+}
+/** @deprecated 使用 writeModule；旧字段仅在此边界适配。 */
+function writePreset(prompt, options) {
+	if ((options.promptConfigs?.length ?? 0) > 0) throw new Error("旧 promptConfigs 物化覆盖已退出，请先离线迁移为 rules");
+	const moduleId = options.presetTemplate?.trim() || "ponytail";
+	if (!/^[a-z0-9][a-z0-9-]*$/.test(moduleId)) throw new Error(`invalid presetTemplate ${JSON.stringify(moduleId)}`);
+	return writeModule(prompt, {
+		modulesRoot: options.moduleDir,
+		moduleId,
+		targetModuleId: options.outputId,
+		sourceDir: options.sourceDir,
+		stageOnly: options.materializeOnly,
+		agentsInstructionText: options.agentsInstructionText,
+		warn: options.warn
+	});
+}
+//#endregion
+//#region src/host/module-package.ts
+/** 模块交换：有界资源、完整候选与可恢复提交，Web 和 CLI 共用。 */
+const MANIFEST = "prompt-tool-package.json";
+const PACKAGE_VERSION = 1;
+const STORAGE_VERSION = 6;
+/**
+* 包内定义文件名：写入用新名，**读取接受历史名**。
+*
+* 包是可分享的外部产物，用户手里可能有旧版导出的包（清单 `definition: preset.yml`）；
+* 导入是信任边界，拒绝它等于把用户已有的包判为损坏。
+*/
+const DEFINITION_NAMES = [MODULE_DEFINITION_FILE, "preset.yml"];
+const sha = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var AssetTransferError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+function stale() {
+	throw new AssetTransferError("module-preview-stale", "预览已过期，请重新预览后再导入");
+}
+function assertTransferId(id) {
+	assertModuleId(id);
+	if (id.length > 128) throw new Error("预设 id 过长");
+}
+function ownedFile(path) {
+	const root = path.split("/")[0];
+	if (root.startsWith(".") || [
+		"configs",
+		"custom-tools",
+		"subagent-tools",
+		"skills"
+	].includes(root)) return false;
+	if (path === "variables.yml" || path === MANIFEST) return false;
+	return path === "agents.md" || !/^(?:AGENTS|CLAUDE)(?:\.local)?\.md$/i.test(basename(path));
+}
+/** 先筛选再读取：派生切片和不分享的私有资产不参与读取、配额或导出版本。 */
+function shareableFile(path) {
+	const root = path.split("/")[0].toLowerCase();
+	return ![
+		"rules",
+		"rules.yml",
+		"agent.cordis.yml",
+		"triggers.yml",
+		"memory.md"
+	].includes(root) && ownedFile(path);
+}
+function packageTemplate(files, missing) {
+	const entries = new Map(files.map((file) => [file.path, file.bytes]));
+	return (file) => {
+		if (file === void 0 || file === "") return void 0;
+		if (typeof file !== "string") throw new Error("templateFile 必须是字符串");
+		const path = posix.normalize(file);
+		if (file.includes("\\") || file.includes(":") || posix.isAbsolute(path) || path === ".." || path.startsWith("../") || path === "rules" || path.startsWith("rules/")) throw new Error("非法或外部模板资源：" + file);
+		safeAssetPath(path);
+		const bytes = entries.get(path);
+		if (bytes === void 0) {
+			if (missing) {
+				missing.add("缺失资源：" + path);
+				return;
+			}
+			throw new Error("缺失模板资源：" + path);
+		}
+		const raw = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+		if (/\.json$/i.test(path)) {
+			const value = JSON.parse(raw);
+			return typeof value === "string" ? { text: value } : value;
+		}
+		if (/\.ya?ml$/i.test(path)) {
+			const doc = parseDocument(raw, { logLevel: "silent" });
+			if (doc.errors.length > 0) throw new Error("模板 YAML 无效：" + path);
+			const value = doc.toJS();
+			return typeof value === "string" ? { text: value } : value;
+		}
+		return { text: raw };
+	};
+}
+function validatePackageDefinition(directory, text, files, missing) {
+	const snapshot = validateModuleDefinitionText(directory, text, { loadTemplate: packageTemplate(files, missing) });
+	const spec = snapshot.source;
+	readModuleLayerSettings(spec);
+	if (spec.customTools !== void 0) {
+		if (!Array.isArray(spec.customTools)) throw new Error("customTools 必须是数组");
+		const errors = validateCustomTools(spec.customTools);
+		if (errors.length > 0) throw new Error(errors.join("\n"));
+	}
+	if (spec.subagentToolPolicy !== void 0 && spec.subagentToolPolicy !== null) {
+		const errors = validateSubagentToolPolicy(spec.subagentToolPolicy);
+		if (errors.length > 0) throw new Error(errors.join("\n"));
+	}
+	return snapshot;
+}
+async function expandModuleSource(input) {
+	let files = input;
+	if (files.length === 1 && /\.zip$/i.test(files[0].path)) files = await unpackZip(decodeAssetFile(files[0]));
+	files = normalizeAssetFiles(files);
+	const first = files[0]?.path.split("/")[0];
+	let sourceFolder;
+	if (first !== void 0 && files.every((file) => file.path.startsWith(first + "/"))) {
+		sourceFolder = first;
+		files = files.map((file) => ({
+			...file,
+			path: file.path.slice(first.length + 1)
+		}));
+	}
+	const seen = /* @__PURE__ */ new Set();
+	let size = 0;
+	for (const file of files) {
+		safeAssetPath(file.path);
+		const key = file.path.normalize("NFC").toLowerCase();
+		if (seen.has(key)) throw new Error(`重复资源路径：${file.path}`);
+		seen.add(key);
+		size += decodeAssetFile(file).length;
+		if (size > 67108864 || files.length > 2048) throw new Error("资源包超过大小或数量上限");
+		if (file.path !== MANIFEST && !ownedFile(file.path)) throw new Error(`资源不属于预设交换范围：${file.path}`);
+	}
+	const manifest = files.find((file) => file.path === MANIFEST);
+	if (manifest !== void 0) {
+		const value = JSON.parse(decodeAssetFile(manifest).toString("utf8"));
+		if (!isRecord(value) || value.version !== PACKAGE_VERSION || typeof value.definition !== "string" || !DEFINITION_NAMES.includes(value.definition) || !isRecord(value.files)) throw new Error("不支持或损坏的预设包清单");
+		if (isRecord(value.requires) && typeof value.requires.renderVersion === "number" && value.requires.renderVersion > STORAGE_VERSION) throw new Error("模块包需要较新的 Prompt Tool");
+		const entries = files.filter((file) => file !== manifest);
+		if (Object.keys(value.files).length !== entries.length) throw new Error("包清单与文件集合不一致");
+		for (const file of entries) if (value.files[file.path] !== sha(decodeAssetFile(file))) throw new Error(`包文件摘要不符：${file.path}`);
+		files = entries;
+	}
+	const yaml = files.filter((file) => !file.path.includes("/") && /\.ya?ml$/i.test(file.path) && file.path !== "agent.cordis.yml");
+	const definition = yaml.find((file) => /^(?:module|preset)\.ya?ml$/i.test(file.path)) ?? (yaml.length === 1 ? yaml[0] : void 0);
+	if (definition !== void 0) {
+		const doc = parseDocument(decodeAssetFile(definition).toString("utf8"), { logLevel: "silent" });
+		const value = doc.errors.length === 0 ? doc.toJS({ maxAliasCount: 100 }) : void 0;
+		if (isRecord(value) && value.id === void 0 && !("prompts" in value) && !("spec" in value) && ([
+			"modules",
+			"composition",
+			"rules",
+			"params",
+			"content"
+		].some((key) => key in value) || typeof value.name === "string" && files.some((file) => file.path === "agent.cordis.yml"))) {
+			doc.set("id", sourceFolder ?? "imported-preset");
+			definition.content = doc.toString();
+			definition.encoding = "utf8";
+		}
+	}
+	return files;
+}
+function targetId(root, wanted, request) {
+	assertTransferId(wanted);
+	if (request.targetId !== void 0 || request.overwrite) return wanted;
+	let id = wanted;
+	for (let n = 1; existsSync(join(root, id)); n++) id = `${wanted}-copy${n === 1 ? "" : "-" + n}`;
+	return id;
+}
+function moduleImportPreview(root, files, request) {
+	const prepared = prepareImport(files, "preset", {
+		...request,
+		targetId: void 0,
+		targetName: void 0
+	});
+	if (prepared.state !== "ready") return prepared;
+	validatePackageDefinition(join(root, prepared.spec.id), prepared.yaml, prepared.files.map((file) => ({
+		path: file.path,
+		bytes: decodeAssetFile(file)
+	})));
+	const id = targetId(root, request.targetId ?? prepared.spec.id, request);
+	const version = directoryVersionOf(assertModuleDirectory(root, id, true));
+	const sourceDigest = assetSourceDigest(files);
+	return {
+		prepared,
+		sourceDigest,
+		previewRevision: computePreviewRevision({
+			files: [{
+				path: "source",
+				content: sourceDigest
+			}, {
+				path: "choices",
+				content: JSON.stringify([
+					id,
+					request.targetName ?? "",
+					request.overwrite === true,
+					request.sourceKind ?? null
+				])
+			}],
+			...request.promptOrderCharacterId === void 0 ? {} : { orderCharacterId: request.promptOrderCharacterId },
+			converter: "asset-import/1",
+			target: {
+				kind: "preset-package",
+				targetId: id,
+				targetVersion: version,
+				ownerPreset: root
+			}
+		}),
+		summary: {
+			sourceName: prepared.sourceName,
+			kind: prepared.kind,
+			targetId: id,
+			targetName: request.targetName ?? prepared.spec.name,
+			exists: version !== null,
+			files: files.map((file) => ({
+				path: file.path,
+				bytes: decodeAssetFile(file).length
+			})),
+			configCount: prepared.spec.rules?.length ?? 0,
+			warnings: []
+		}
+	};
+}
+/** 同一进程的同目标安装串行；磁盘版本复检保护其他写入者。 */
+const installs = /* @__PURE__ */ new Map();
+async function installModulePackage(root, files, request, options = {}) {
+	root = canonicalModulesRoot(root, true);
+	const initial = moduleImportPreview(root, files, request);
+	if (!("prepared" in initial)) throw new Error("请先完成来源和顺序组选择");
+	const target = join(root, initial.summary.targetId);
+	const run = (installs.get(target) ?? Promise.resolve()).catch(() => {}).then(() => {
+		const preview = moduleImportPreview(root, files, request);
+		if (!("prepared" in preview)) throw new Error("来源选择已失效");
+		if (!request.expectedPreviewRevision || request.expectedPreviewRevision !== preview.previewRevision || request.expectedSourceDigest !== preview.sourceDigest) stale();
+		if (preview.summary.exists && request.overwrite !== true) throw new Error("目标已存在，请明确选择更新或另存");
+		mkdirSync(root, { recursive: true });
+		const stage = mkdtempSync(join(root, ".import-"));
+		const source = join(stage, preview.summary.targetId);
+		mkdirSync(source);
+		let generated;
+		let generatedRoot;
+		let moved = false;
+		const backup = join(stage, "previous");
+		try {
+			if ((options.preserveAssets || preview.prepared.kind === "st-character" || preview.prepared.kind === "native-character") && preview.summary.exists) for (const entry of readdirSync(target)) {
+				if ([
+					"module.yml",
+					"rules",
+					"configs",
+					"rules.yml",
+					"agent.cordis.yml",
+					"custom-tools",
+					"subagent-tools"
+				].includes(entry)) continue;
+				const path = join(target, entry);
+				assertModuleTree(path);
+				cpSync(path, join(source, entry), { recursive: true });
+			}
+			for (const file of preview.prepared.files.filter((file) => file.path !== MANIFEST && !DEFINITION_NAMES.includes(file.path))) {
+				const path = join(source, safeAssetPath(file.path));
+				mkdirSync(dirname(path), { recursive: true });
+				if (file.path === "memory.md" && existsSync(path)) continue;
+				writeFileSync(path, decodeAssetFile(file));
+			}
+			const doc = parseDocument(preview.prepared.yaml);
+			setModuleDefinitionId(doc, preview.summary.targetId);
+			doc.set("name", preview.summary.targetName);
+			writeFileSync(join(source, MODULE_DEFINITION_FILE), doc.toString(), "utf8");
+			generated = writeModule(existsSync(join(source, "preset.md")) ? readFileSync(join(source, "preset.md"), "utf8") : "", {
+				modulesRoot: root,
+				moduleId: preview.summary.targetId,
+				targetModuleId: preview.summary.targetId,
+				sourceDir: source,
+				stageOnly: true
+			});
+			generatedRoot = dirname(generated);
+			withModuleLock(root, preview.summary.targetId, () => {
+				const now = moduleImportPreview(root, files, request);
+				if (!("prepared" in now) || now.previewRevision !== preview.previewRevision) stale();
+				if (existsSync(target)) {
+					renameSync(target, backup);
+					moved = true;
+				}
+				try {
+					renameSync(generated, target);
+					generated = void 0;
+				} catch (error) {
+					if (moved) try {
+						renameSync(backup, target);
+						moved = false;
+					} catch {
+						throw new AssetTransferError("module-recovery-required", `安装失败且恢复未完成，原目录保留在 ${backup}`);
+					}
+					throw error;
+				}
+			});
+			invalidateModuleSpec(target);
+			try {
+				rmSync(stage, {
+					recursive: true,
+					force: true
+				});
+				moved = false;
+			} catch {
+				return {
+					id: preview.summary.targetId,
+					backupPath: stage
+				};
+			}
+			return { id: preview.summary.targetId };
+		} finally {
+			if (generated !== void 0) rmSync(generated, {
+				recursive: true,
+				force: true
+			});
+			if (generatedRoot !== void 0) rmSync(generatedRoot, {
+				recursive: true,
+				force: true
+			});
+			if (!moved) rmSync(stage, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+	installs.set(target, run);
+	try {
+		return await run;
+	} finally {
+		if (installs.get(target) === run) installs.delete(target);
+	}
+}
+function collectFiles(dir) {
+	const files = [];
+	const seen = /* @__PURE__ */ new Set();
+	let total = 0;
+	const walk = (current, prefix) => {
+		for (const entry of readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+			if (!shareableFile(prefix + entry.name)) continue;
+			const path = safeAssetPath(prefix + entry.name);
+			const key = path.normalize("NFC").toLowerCase();
+			if (seen.has(key)) throw new Error(`导出路径大小写或规范化冲突：${path}`);
+			seen.add(key);
+			if (entry.isSymbolicLink()) throw new Error(`不能导出链接：${path}`);
+			const absolute = join(current, entry.name);
+			if (entry.isDirectory()) {
+				walk(absolute, path + "/");
+				continue;
+			}
+			const stat = lstatSync(absolute);
+			if (!stat.isFile()) throw new Error(`不能导出特殊文件：${path}`);
+			total += stat.size;
+			if (total > 67108864 || files.length >= 2048) throw new Error("导出超过大小或数量上限");
+			const bytes = readFileSync(absolute);
+			if (bytes.length !== stat.size) throw new Error("导出期间文件发生变化");
+			files.push({
+				path,
+				bytes
+			});
+		}
+	};
+	walk(dir, "");
+	return files;
+}
+function dependencyErrors(files, spec) {
+	const paths = new Set(files.map((file) => file.path));
+	const errors = /* @__PURE__ */ new Set();
+	const check = (ref, from) => {
+		const rel = posix.normalize(posix.join(posix.dirname(from), ref));
+		if (rel.startsWith("../") || posix.isAbsolute(rel) || ref.includes(":")) errors.add(`外部资源：${ref}`);
+		else if (!paths.has(rel)) errors.add(`缺失资源：${rel}`);
+	};
+	for (const { config } of ruleInjections(spec.rules)) if (typeof config.templateFile === "string") check(config.templateFile, MODULE_DEFINITION_FILE);
+	if (!Array.isArray(spec.modules) && typeof spec.composition === "string") {
+		let raw = spec.composition;
+		if (raw.startsWith("./")) {
+			check(raw, MODULE_DEFINITION_FILE);
+			raw = files.find((file) => file.path === posix.normalize(raw))?.bytes.toString("utf8") ?? "";
+		}
+		if (raw.includes("\n")) {
+			const doc = parseDocument(raw, { logLevel: "silent" });
+			if (doc.errors.length > 0) errors.add("模块组合 YAML 无效");
+			else {
+				const visit = (value) => {
+					if (Array.isArray(value)) {
+						value.forEach(visit);
+						return;
+					}
+					if (!isRecord(value)) return;
+					if (typeof value.name === "string" && value.name.startsWith(".")) check(value.name, MODULE_DEFINITION_FILE);
+					Object.values(value).forEach((child) => {
+						if (typeof child === "object") visit(child);
+					});
+				};
+				visit(doc.toJS());
+			}
+		}
+	}
+	for (const file of files) if (/\.[cm]?js$/i.test(file.path)) {
+		const code = file.bytes.toString("utf8");
+		for (const match of code.matchAll(/(?:from\s*|import\s*\(|require\s*\()\s*['"](\.[^'"]+)['"]/g)) check(match[1], file.path);
+	}
+	return [...errors];
+}
+function sharingSnapshot(dir, id, root, choices) {
+	const files = collectFiles(dir);
+	const definition = files.find((file) => file.path === MODULE_DEFINITION_FILE);
+	if (!definition) throw new Error("缺少模块定义");
+	const originalText = new TextDecoder("utf-8", { fatal: true }).decode(definition.bytes);
+	const missing = /* @__PURE__ */ new Set();
+	const original = validatePackageDefinition(dir, originalText, files, missing).doc;
+	if (original.get("id") === void 0) original.set("id", id);
+	const source = files.map((file) => [file.path, sha(file.bytes)]);
+	const projection = projectCharacterMemories(original, choices, root);
+	definition.bytes = Buffer.from(projection.doc.toString());
+	const spec = validatePackageDefinition(dir, definition.bytes.toString("utf8"), files, missing).source;
+	const revision = sha(JSON.stringify([
+		source,
+		definition.bytes.toString("utf8"),
+		projection.memoryConflicts,
+		projection.excludedMemoryCount
+	]));
+	return {
+		files,
+		definition,
+		spec,
+		projection,
+		missing: [...missing],
+		revision
+	};
+}
+async function exportModulePackage(root, request) {
+	assertTransferId(request.id);
+	const resolved = resolveModuleDir(request.id, root);
+	const dir = assertModuleDirectory(dirname(resolved), request.id);
+	if (!modulePathExists(dir)) throw new Error("模块不存在");
+	const choices = request.memoryChoices ?? {};
+	const { files, definition, spec, projection, missing, revision: before } = sharingSnapshot(dir, request.id, root, choices);
+	const blockers = [.../* @__PURE__ */ new Set([...missing, ...dependencyErrors(files, spec)])];
+	if (projection.memoryConflicts.length > 0) blockers.push("请明确选择来源不明的记忆条目是否分享");
+	const mode = request.mode ?? "definition";
+	const revision = sha(JSON.stringify([
+		before,
+		mode,
+		request.memoryChoices ?? {}
+	]));
+	const result = {
+		id: request.id,
+		name: spec.name || request.id,
+		content: "",
+		revision,
+		filename: `${request.id}.${mode === "zip" ? "zip" : MODULE_DEFINITION_FILE}`,
+		files: files.map((file) => ({
+			path: file.path,
+			bytes: file.bytes.length
+		})),
+		warnings: ["不包含工作区指令、角色记忆文件、技能库；需要兼容的 Prompt Tool 与宿主。"],
+		blockers: mode === "zip" ? blockers : projection.memoryConflicts.length ? ["请先处理记忆条目"] : [],
+		memoryConflicts: projection.memoryConflicts,
+		excludedMemoryCount: projection.excludedMemoryCount
+	};
+	if (mode === "definition") result.warnings.push(...blockers);
+	if (mode === "definition" && files.length > 1) result.warnings.push(`仅导出定义，不包含 ${files.length - 1} 个附属文件。`);
+	const verify = () => {
+		if (sharingSnapshot(dir, request.id, root, choices).revision !== before) stale();
+	};
+	verify();
+	if (request.preview) return result;
+	if (request.expectedRevision !== void 0 && request.expectedRevision !== revision) stale();
+	if (result.blockers.length) throw new Error(result.blockers.join("\n"));
+	if (mode === "definition") return {
+		...result,
+		encoding: "utf8",
+		content: definition.bytes.toString("utf8")
+	};
+	const plugin = JSON.parse(readFileSync(join(dirname(packageEngineDir()), "package.json"), "utf8"));
+	const manifest = Buffer.from(JSON.stringify({
+		version: PACKAGE_VERSION,
+		definition: MODULE_DEFINITION_FILE,
+		requires: {
+			promptTool: plugin.version,
+			renderVersion: STORAGE_VERSION
+		},
+		files: Object.fromEntries(files.map((file) => [file.path, sha(file.bytes)]))
+	}, null, 2));
+	if (files.length + 1 > 2048) throw new Error("包含清单后的模块包超过文件数量上限");
+	if (files.reduce((sum, file) => sum + file.bytes.length, manifest.length) > 67108864) throw new Error("包含清单后的预设包超过 64 MiB");
+	const archive = await packZip([...files, {
+		path: MANIFEST,
+		bytes: manifest
+	}].map((file) => ({
+		...file,
+		path: `${request.id}/${file.path}`
+	})));
+	if (archive.length > 67108864) throw new Error("ZIP 超过 64 MiB，无法通过导入上限");
+	verify();
+	return {
+		...result,
+		encoding: "base64",
+		content: Buffer.from(archive).toString("base64")
+	};
+}
+//#endregion
+export { MAX_ASSET_BYTES as A, mergeStModulesWithReport as C, deleteWorldBookEntry as D, buildWorldBookEntry as E, DEFAULT_MODULE_ID as M, listWorldBookEntries as O, mergeStModules as S, stModuleId as T, readModuleMemory as _, installModulePackage as a, convertStToModule as b, writeModule as c, validateCustomTools as d, safeAssetPath as f, mergeModuleIntoModule as g, importCharacterCardFile as h, exportModulePackage as i, ruleInjections as j, upsertWorldBookEntry as k, writePreset as l, importCharacterCard as m, assertTransferId as n, moduleImportPreview as o, appendModuleMemory as p, expandModuleSource as r, ensureModuleReady as s, AssetTransferError as t, compileCustomTool as u, removeMergedModule as v, processStText as w, convertStToModuleWithReport as x, prepareImport as y };