dsh-prompt-customizer 0.3.0 → 0.4.0

package/client/client.js

@@ -14,7 +14,7 @@ window.__ModuleLoader__.load({
 				unavailable: "当前环境未启用本命名空间。",
 				tabsSections: "提示词",
 				tabsTools: "工具",
-				tabsPresets: "预设",
+				tabsPresets: "配置",
 				tabsPreview: "预览",
 				refresh: "刷新",
 				blockedOff: "未屏蔽",
@@ -44,17 +44,96 @@ window.__ModuleLoader__.load({
 				previewSections: "段",
 				previewTools: "工具预览",
 				previewToolCount: "个工具",
-				savePreset: "保存当前为预设",
-				presetName: "预设名称",
+				savePreset: "保存当前配置",
+				presetName: "配置名称",
+				saveAsPresetCard: "存为 agent 预设",
+				saveAsPresetHint: "整体复制「{name}」这个预设的组成为新预设（组成文件与伴生脚本一并带走），再把当前定制写进它的覆盖项 —— 新预设出现在顶部编辑目标里。",
+				agentPresetName: "新预设名",
+				forkSourceDefault: "默认预设",
+				saveAsPresetOk: "预设已创建，可在顶部的编辑目标选择器里选到它",
+				saveAsPresetFail: "保存预设失败",
 				save: "保存",
-				importPreset: "导入预设",
+				importPreset: "导入配置",
 				import: "导入",
 				apply: "应用",
 				export: "导出",
 				delete: "删除",
 				restore: "还原",
 				active: "使用中",
-				preset: "预设"
+				preset: "预设",
+				ioFailed: "导入/导出失败",
+				importInvalid: "无效的配置文件",
+				targetGlobal: "目标：全局默认",
+				targetHint: "选择编辑目标 —— 选中某个 agent 预设后，改动只对该预设生效（字段级覆盖）。",
+				broken: "损坏",
+				brokenPreset: "该 agent 预设当前无法挂载，仍可编辑其定制（修复预设后自动生效）。",
+				phaseBootstrap: "仅引导阶段",
+				phaseActive: "晋级后",
+				phaseCompaction: "压缩后",
+				phaseStageGuide: "引导期",
+				phaseStageResident: "常驻期",
+				phaseStageControlled: "压缩受控期",
+				toolsPartGuide: "引导期工具",
+				toolsPartResident: "常驻期工具",
+				toolsPartControlled: "压缩受控期工具",
+				allToolsTitle: "本系统全部工具",
+				sectionsPartGuide: "引导期提示词",
+				sectionsPartResident: "常驻期提示词",
+				sectionsPartControlled: "压缩受控期提示词",
+				allSectionsTitle: "本系统全部提示词",
+				toolsFourHint: "三个阶段各一份名单，互不继承：勾选 = 该阶段是否对模型可见；从「全部」拖入某阶段 = 让这一个工具在该阶段出现（若该阶段默认裁掉了它，就加回去）；在两个阶段之间拖动 = 复制（源阶段不动，目标阶段多一份，隐藏/启用状态一起带过去）；拖回「全部」= 从该阶段拿掉它。每个动作只影响被拖的那一个工具。",
+				sectionsFourHint: "拖拽双向：把「全部」里的段拖入上方阶段 = 加入该阶段并默认开启；从阶段拖回「全部」= 从该阶段移除。屏蔽段与普通段完全一样可拖拽 / 编辑，只是不注入模型。",
+				dragHint: "拖入 = 让该工具在这个阶段出现",
+				phaseShortGuide: "引",
+				phaseShortResident: "常",
+				phaseShortControlled: "压",
+				poolMarksHint: "每个名字后的三个标记 = 该工具在引导期 / 常驻期 / 压缩受控期的状态：绿=该阶段可见（或已加回），灰=该阶段已隐藏，暗=不在该阶段、也没加回。",
+				toolAddedTag: "加回",
+				toolAdded: "已把「{name}」加回{phase}：该阶段默认裁掉了它，保存后它会重新出现在该阶段（当前预设注册表里有它）。",
+				toolNotInRegistry: "「{name}」不在本预设的注册表里（它是别的预设独有的工具），当前预设没有它的定义，加不进来。",
+				toolCopied: "已把「{name}」复制到{to}：{from}那份保持不动，隐藏/启用状态一起带过去。",
+				toolShown: "「{name}」已在{to}显示。",
+				toolHiddenIn: "「{name}」已在{to}隐藏。",
+				sectionsTakenOver: "「{name}」段声明了 complete 整段接管（宿主在装配瀑布流之后强制还原为那一条段）。本插件默认的 forceSections 已绕开该机制，段级屏蔽 / 替换 / 注入 / 排序照常生效；此提示只会在 forceSections 关闭或强制覆盖失效时出现，开启 forceSections 即可恢复。",
+				sectionsLost: "本插件在该阶段产出的 {emitted} 个段里，只有 {survived} 个进入最终提示词：其余被下游装配规则丢弃，段级定制不会完全生效（工具过滤不受影响）。",
+				sectionBlockedStrip: "（本阶段已屏蔽，模型不可见）",
+				phaseSuppressed: "被抑制（不在任何阶段的装配中）",
+				sectionDynamicNoAdd: "「{name}」是运行时才生成的动态段，没法预先加进某个阶段（它的内容只有装配时才知道）。",
+				exportOk: "导出成功",
+				exportCancel: "已取消导出",
+				exportFail: "导出失败",
+				importOk: "导入完成",
+				importNone: "没有新增预设（同名已存在或文件为空）",
+				importCancel: "已取消导入",
+				importFail: "导入失败",
+				saveOk: "已保存",
+				saveFail: "保存失败",
+				discardConfirm: "有未保存的更改，离开将丢弃。确定离开吗？",
+				forceTitle: "强制覆盖（forceSections）",
+				forceHint: "开启后所有预设的提示词段一律以本插件为准（绕过 complete 整段接管与预设阶段裁段）；关闭后退回瀑布流内过滤，预设可能压过定制。「恢复初始状态」会自动关闭它。",
+				forceOn: "已开启",
+				forceOff: "已关闭",
+				envBlockTitle: "环境变量黑名单（envBlocklist）",
+				envBlockHint: "系统环境变量（process.env）已全量注册为提示词变量：段文本里写 {{env_键名小写}} 引用（如 {{env_path}}）；命中黑名单的键不注册——env 里常有密钥，进了提示词就会随请求发给模型。条目支持 * 通配、大小写不敏感。内置变量 {{date}} {{time}} {{datetime}} {{weekday}} {{hostname}} {{platform}} {{arch}} {{username}} {{home}} {{shell}} {{locale}} {{node_version}} 恒可用。",
+				envBlockAdd: "键名或通配，如 GITHUB_TOKEN 或 *_KEY*",
+				envBlockAddAction: "添加",
+				envBlockEmpty: "黑名单为空：所有环境变量都会被注册",
+				envVarsTitle: "已注册的提示词变量",
+				envVarsHint: "段文本里引用 {{变量名}}；引用未注册的名字会让整次渲染报错（宿主严格模式）。",
+				importBlockMerge: "，文件中的环境变量黑名单已并入（+{count} 条）",
+				resetTitle: "恢复初始状态",
+				resetHint: "清空全部定制（屏蔽 / 替换 / 注入 / 排序、阶段工具目录、配置快照、agent 预设覆盖），并关闭 forceSections —— 之后所有 AI 对话不再受本插件影响，与卸载插件等效，无需卸载或重启。此操作不可撤销；要重新启用定制，在上方打开「强制覆盖」开关即可。",
+				resetConfirm: "确定清空全部定制并恢复初始状态吗？\n\n将删除：屏蔽名单、段替换、注入段、阶段工具目录、配置快照、agent 预设覆盖；并关闭 forceSections。\n之后所有 AI 对话都不再受本插件影响（与卸载插件等效）。\n此操作不可撤销。",
+				resetAction: "清空全部定制",
+				resetOk: "已恢复初始状态：所有 AI 对话不再受本插件影响",
+				resetFail: "恢复初始状态失败",
+				scopeFallback: "该 agent 预设的常驻 scope 未能挂载，以下显示的是全局层内容（并非该预设的原生段与工具）。",
+				previewDegraded: "伪会话触发了某个预设插件的异常，本次预览已降级为无会话装配——预设原生的阶段裁剪规则未参与运行。",
+				previewFail: "该阶段装配失败（scope 挂载失败或预设插件异常），请切换目标或查看服务日志。",
+				phaseVisible: "阶段可见",
+				previewToolsHint: "模型实际可见的工具目录（按所选阶段运行预设的全部装配规则，含原生阶段裁剪）：",
+				previewToolsCount: "注册表",
+				saveAsPreset: "存为预设"
 			},
 			en: {
 				nav: "Prompt Customizer",
@@ -92,8 +171,14 @@ window.__ModuleLoader__.load({
 				previewSections: "sections",
 				previewTools: "Tools preview",
 				previewToolCount: "tools",
-				savePreset: "Save current as preset",
-				presetName: "Preset name",
+				savePreset: "Save current config",
+				presetName: "Config name",
+				saveAsPresetCard: "Save as agent preset",
+				saveAsPresetHint: "Copy the whole \"{name}\" preset into a new one (composition plus its companion scripts), then write the current customization into its override — the new preset shows up in the target selector above.",
+				agentPresetName: "New preset name",
+				forkSourceDefault: "the default preset",
+				saveAsPresetOk: "Preset created — pick it in the target selector above",
+				saveAsPresetFail: "Failed to save preset",
 				save: "Save",
 				importPreset: "Import preset",
 				import: "Import",
@@ -102,12 +187,85 @@ window.__ModuleLoader__.load({
 				delete: "Delete",
 				restore: "Restore",
 				active: "Active",
-				preset: "Preset"
+				preset: "Preset",
+				ioFailed: "Import/export failed",
+				importInvalid: "Invalid preset file",
+				targetGlobal: "Target: global default",
+				targetHint: "Pick an edit target — changes apply only to the chosen agent preset (field-level override).",
+				broken: "broken",
+				brokenPreset: "This agent preset cannot mount right now; its customization is still editable and applies once fixed.",
+				phaseBootstrap: "Bootstrap only",
+				phaseActive: "After promotion",
+				phaseCompaction: "Post-compaction",
+				phaseStageGuide: "Guide period",
+				phaseStageResident: "Resident period",
+				phaseStageControlled: "Compaction-controlled period",
+				toolsPartGuide: "Guide-period tools",
+				toolsPartResident: "Resident-period tools",
+				toolsPartControlled: "Compaction-controlled tools",
+				allToolsTitle: "All system tools",
+				sectionsPartGuide: "Guide-period sections",
+				sectionsPartResident: "Resident-period sections",
+				sectionsPartControlled: "Compaction-controlled sections",
+				allSectionsTitle: "All system sections",
+				toolsFourHint: "Each of the three periods keeps its own list, with no inheritance: the checkbox = visible to the model in that period; dragging a tool from \"All\" into a period makes it appear there (if the period trims it by default, it is added back); dragging between two periods copies it (the source is untouched, the target gains one, and the hidden/enabled state carries over); dragging it back to \"All\" removes it from that period. Every action touches only the tool you dragged.",
+				sectionsFourHint: "Drag both ways: drop a section from \"All\" onto a period part to enable it there; drag from a part back to \"All\" to remove it from that period. Blocked sections stay fully operable — they are just not injected.",
+				dragHint: "Drag in to make this tool appear in this period",
+				phaseShortGuide: "G",
+				phaseShortResident: "R",
+				phaseShortControlled: "C",
+				poolMarksHint: "The three marks after each name = this tool’s state in the guide / resident / compaction-controlled periods: green = visible there (or added back), grey = hidden there, dim = not present and not added.",
+				toolAddedTag: "added",
+				toolAdded: "Added \"{name}\" back to {phase}: the period trims it by default, so it will reappear there once saved (it exists in this preset’s registry).",
+				toolNotInRegistry: "\"{name}\" is not in this preset’s registry (it belongs to another preset). There is no definition for it here, so it cannot be added.",
+				toolCopied: "Copied \"{name}\" to {to}: the copy in {from} is left untouched, and its hidden/enabled state carries over.",
+				toolShown: "\"{name}\" is now visible in {to}.",
+				toolHiddenIn: "\"{name}\" is now hidden in {to}.",
+				sectionsTakenOver: "The \"{name}\" section declares a complete takeover (the host restores that single section after the assembly waterfall). This plugin’s forceSections (default on) bypasses that mechanism, so section-level blocking / replacement / injection / ordering still applies; this notice only appears when forceSections is off or the override fails — enable it to restore.",
+				sectionsLost: "Only {survived} of the {emitted} sections this plugin emitted for this phase reach the final prompt — the rest are dropped by downstream assembly rules, so section-level customization cannot fully apply (tool filtering is unaffected).",
+				sectionBlockedStrip: " (blocked in this period; invisible to the model)",
+				phaseSuppressed: "Suppressed (absent from every phase assembly)",
+				sectionDynamicNoAdd: "\"{name}\" is generated at runtime — it cannot be added to a phase ahead of time (its content is only known during assembly).",
+				exportOk: "Exported",
+				exportCancel: "Export cancelled",
+				exportFail: "Export failed",
+				importOk: "Import complete",
+				importNone: "Nothing imported (duplicate names or empty file)",
+				importCancel: "Import cancelled",
+				importFail: "Import failed",
+				saveOk: "Saved",
+				saveFail: "Save failed",
+				discardConfirm: "You have unsaved changes; leaving will discard them. Leave anyway?",
+				forceTitle: "Force override (forceSections)",
+				forceHint: "When on, every preset’s prompt sections always follow this plugin (bypassing complete takeover and preset phase pruning); when off, filtering falls back to the waterfall, where presets may override your customization. \"Restore initial state\" turns this off automatically.",
+				forceOn: "On",
+				forceOff: "Off",
+				envBlockTitle: "Environment variable blocklist (envBlocklist)",
+				envBlockHint: "All system environment variables (process.env) are registered as prompt variables: reference them in section text as {{env_lowercase_key}} (e.g. {{env_path}}); keys hit by the blocklist are not registered — env often carries secrets, and anything in the prompt is sent to the model. Entries support * wildcards, case-insensitive. Built-ins {{date}} {{time}} {{datetime}} {{weekday}} {{hostname}} {{platform}} {{arch}} {{username}} {{home}} {{shell}} {{locale}} {{node_version}} are always available.",
+				envBlockAdd: "Key or wildcard, e.g. GITHUB_TOKEN or *_KEY*",
+				envBlockAddAction: "Add",
+				envBlockEmpty: "Blocklist is empty: every environment variable gets registered",
+				envVarsTitle: "Registered prompt variables",
+				envVarsHint: "Reference {{name}} in section text; an unregistered name fails the whole render (host strict mode).",
+				importBlockMerge: ", the file’s env-variable blocklist was merged in (+{count} entries)",
+				resetTitle: "Restore initial state",
+				resetHint: "Clears all customization (blocking / replacement / injection / ordering, per-phase tool catalogs, config snapshots, agent-preset overrides) and turns forceSections off — every AI conversation goes back to being unaffected by this plugin, equivalent to uninstalling it, without uninstalling or restarting. This cannot be undone; to re-enable customization, turn the \"Force override\" switch above back on.",
+				resetConfirm: "Clear all customization and restore the initial state?\n\nThis will delete: block lists, section replacements, injected sections, per-phase tool catalogs, config snapshots, and agent-preset overrides; forceSections will be turned off.\nAfterwards no AI conversation is affected by this plugin (equivalent to uninstalling).\nThis cannot be undone.",
+				resetAction: "Clear all customization",
+				resetOk: "Initial state restored: no AI conversation is affected by this plugin anymore",
+				resetFail: "Failed to restore initial state",
+				scopeFallback: "This agent preset's standing scope could not be mounted; what you see is the global layer (not the preset's native sections/tools).",
+				previewDegraded: "A preset plugin threw on the synthetic session; this preview fell back to an agent-less assembly — native phase rules did not run.",
+				previewFail: "Assembly for this phase failed (scope mount error or a preset plugin threw); switch target or check the server log.",
+				phaseVisible: "visible in phase",
+				previewToolsHint: "Tool catalog as the model actually sees it (all assembly rules run for the selected phase, including native phase narrowing):",
+				previewToolsCount: "of registry",
+				saveAsPreset: "Save as preset"
 			}
 		};
 		//#endregion
 		//#region src/client/styles.ts
-		/** Inline styles shared by the prompt-customizer panel components. */
+		/** 提示词定制面板各组件共享的内联样式（颜色走半透明灰，随宿主主题自然适配）。 */
 		const s = (() => {
 			const flex = {
 				display: "flex",
@@ -331,6 +489,10 @@ window.__ModuleLoader__.load({
 					background: "transparent",
 					color: "inherit"
 				},
+				option: {
+					backgroundColor: "Canvas",
+					color: "CanvasText"
+				},
 				muted: {
 					color: "rgba(128,128,128,.75)",
 					fontSize: 12
@@ -339,19 +501,98 @@ window.__ModuleLoader__.load({
 					color: "#f85149",
 					fontSize: 12,
 					marginBottom: 6
+				},
+				noticeOk: {
+					color: "#3fb950",
+					fontSize: 12,
+					marginBottom: 6
+				},
+				noticeWarn: {
+					color: "#d29922",
+					fontSize: 12,
+					marginBottom: 6
+				},
+				groupTitle: {
+					display: "flex",
+					gap: 8,
+					alignItems: "baseline",
+					marginTop: 8,
+					marginBottom: 2,
+					color: "rgba(128,128,128,.9)",
+					fontSize: 12
+				},
+				saveBtn: {
+					padding: "4px 12px",
+					border: "1px solid rgba(128,128,128,.35)",
+					borderRadius: 6,
+					background: "transparent",
+					cursor: "pointer",
+					color: "inherit"
+				},
+				saveBtnDirty: {
+					padding: "4px 12px",
+					border: "1px solid #d29922",
+					borderRadius: 6,
+					background: "rgba(210,153,34,.15)",
+					cursor: "pointer",
+					color: "inherit"
 				}
 			};
 		})();
 		//#endregion
 		//#region src/client/presets.ts
+		/** 快照捕获的阶段 order 空间（always 之外的三个阶段）。 */
+		const CAPTURE_PHASES = [
+			"bootstrap",
+			"active",
+			"compaction"
+		];
+		/** 把一条有序名字转成相对链（每段记住它的前一段），text / custom 只给 custom 段。 */
+		function toChain(names, textOf, customOf, phase) {
+			return names.map((name, i) => ({
+				name,
+				after: i > 0 ? names[i - 1] : void 0,
+				text: customOf(name) ? textOf(name) ?? "" : "",
+				custom: customOf(name),
+				...phase !== void 0 ? { phase } : {}
+			}));
+		}
+		/**
+		* 从当前配置构建预设快照（完整捕获，含每阶段独立设定）。
+		*
+		* 全局相对链派生自合并后的完整段列表（而不仅是 `cfg.inject`），这样即使保存前
+		* 只是屏蔽了几个段（没有重排），预设仍会携带完整的有序集合，应用时才能得到一个
+		* 有意义的「激活列表」。在此之上，bootstrap / active / compaction 各再带一条自己
+		* 的相对链 —— 数据源就是 UI 逐阶段持久化的注入条目（每阶段独立的 order 空间），
+		* 否则阶段化的名单与排序在「导出 → 导入 → 应用」后就丢了。
+		*/
+		function buildPresetData(cfg, merged) {
+			const globalNames = merged.map((sec) => sec.name);
+			const textOf = new Map(merged.map((sec) => [sec.name, sec.text ?? ""]));
+			const customOf = new Map(merged.map((sec) => [sec.name, sec.source === "custom"]));
+			const order = toChain(globalNames, (n) => textOf.get(n) ?? "", (n) => customOf.get(n) === true);
+			for (const phase of CAPTURE_PHASES) {
+				const items = (cfg.inject ?? []).filter((item) => item.phase === phase).sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+				if (items.length === 0) continue;
+				order.push(...toChain(items.map((item) => item.name), (n) => items.find((item) => item.name === n)?.text ?? "", (n) => items.find((item) => item.name === n)?.custom === true, phase));
+			}
+			const data = {
+				sections: cfg.sections,
+				replace: cfg.replace,
+				order,
+				tools: cfg.tools
+			};
+			if ((cfg.sectionsBootstrap ?? []).length > 0) data.sectionsBootstrap = cfg.sectionsBootstrap;
+			if ((cfg.sectionsCompaction ?? []).length > 0) data.sectionsCompaction = cfg.sectionsCompaction;
+			return data;
+		}
 		/**
-		* Merge the inventory sections with the user's inject list, sorted by order.
-		* Sections read from the inventory (other plugins) are `system`; sections this
-		* plugin generated carry a hidden `custom` marker and are `custom`. The source
-		* is decided by the hidden marker — never by name collisions — so a custom
-		* section keeps its identity (and its deletability) even when its name happens
-		* to match an inventory section, and across preset switches. Custom sections
-		* always render their own text; they can never be "<动态生成>".
+		* 把宿主清单段与用户注入列表按 order 合并、排序。
+		* 读自清单（其他插件产出）的段标记为 `system`；本插件生成的段带隐藏的
+		* `custom` 标记，标记为 `custom`。来源只由隐藏标记决定——绝不靠名字碰撞
+		* 判断——因此即使自定义段恰好与某个清单段重名，它也能保住自己的身份
+		* （以及可删除性），并在切换预设后依然成立。自定义段始终渲染自己的文本，
+		* 永远不会显示为「<动态生成>」。
 		*/
 		function mergeSections(inv, cfg, blockedNames) {
 			const map = /* @__PURE__ */ new Map();
@@ -387,21 +628,13 @@ window.__ModuleLoader__.load({
 			}));
 		}
 		/**
-		* Resolve a preset's relative order into an absolute ordered list (0..n-1).
-		* Sections with no anchor (or whose anchor is absent) come first in preset
-		* order; each anchored section is inserted right after its anchor; any
-		* remaining sections (cycles) are appended.
+		* 把一条相对链解析为绝对有序名字（0..n-1）。
+		* 没有锚点（或锚点不在本组内）的名字按原始顺序排在最前；每个带锚点的名字
+		* 插到其锚点之后；剩余的名字（存在环）追加到末尾。
 		*/
-		function resolveOrder(presetOrder) {
-			const list = presetOrder ?? [];
+		function resolveChain(list) {
 			const afterMap = /* @__PURE__ */ new Map();
-			const textMap = /* @__PURE__ */ new Map();
-			const customMap = /* @__PURE__ */ new Map();
-			for (const sec of list) {
-				afterMap.set(sec.name, sec.after);
-				textMap.set(sec.name, sec.text);
-				customMap.set(sec.name, sec.custom === true);
-			}
+			for (const sec of list) afterMap.set(sec.name, sec.after);
 			const result = [];
 			const placed = /* @__PURE__ */ new Set();
 			for (const sec of list) {
@@ -428,45 +661,56 @@ window.__ModuleLoader__.load({
 				result.push(sec.name);
 				placed.add(sec.name);
 			}
-			return result.map((name, i) => ({
-				name,
-				order: i,
-				text: textMap.get(name) ?? "",
-				custom: customMap.get(name)
-			}));
+			return result;
 		}
 		/**
-		* Build a preset snapshot from the current config. The order list is derived
-		* from the MERGED section list (not just `cfg.inject`) so that a preset saved
-		* after only blocking sections (without reordering) still carries the full
-		* ordered set, and thus a meaningful "active list" when applied.
+		* 把快照里的相对顺序解析为注入条目列表。
+		*
+		* order 条目可以带 `phase`：同名而不同 phase 的多条 = 该段在多个阶段各有自己的
+		* 位置（每阶段有独立的 order 空间，与 UI 的 phaseInjectEntries 一致）。无 phase
+		* 的条目属于 always 组 —— 也就是旧快照的单一全局序，输出形状与旧实现逐键一致
+		* （刻意不写 phase 键，「保存 → 应用 = 不动点」的不变量依赖键形状完全相同）。
 		*/
-		function buildPresetData(cfg, merged) {
-			const order = merged.map((sec, i) => ({
-				name: sec.name,
-				after: i > 0 ? merged[i - 1].name : void 0,
-				text: sec.source === "custom" ? sec.text ?? "" : "",
-				custom: sec.source === "custom"
-			}));
-			return {
-				sections: cfg.sections,
-				replace: cfg.replace,
-				order,
-				tools: cfg.tools
-			};
+		function resolveOrder(presetOrder) {
+			const list = presetOrder ?? [];
+			const groups = /* @__PURE__ */ new Map([["always", []]]);
+			for (const sec of list) {
+				const phase = sec.phase ?? "always";
+				const group = groups.get(phase);
+				if (group) group.push(sec);
+				else groups.set(phase, [sec]);
+			}
+			const out = [];
+			for (const [phase, members] of groups) {
+				const textMap = new Map(members.map((x) => [x.name, x.text ?? ""]));
+				const customMap = new Map(members.map((x) => [x.name, x.custom === true]));
+				const names = resolveChain(members);
+				out.push(...names.map((name, i) => phase === "always" ? {
+					name,
+					order: i,
+					text: textMap.get(name) ?? "",
+					custom: customMap.get(name)
+				} : {
+					name,
+					order: i,
+					text: textMap.get(name) ?? "",
+					custom: customMap.get(name),
+					phase
+				}));
+			}
+			return out;
 		}
 		/**
-		* Compute the config patch when applying a preset:
-		*  - same-name sections are overridden (the order list drives this at runtime)
-		*  - preset sections missing from the current prompt are added
-		*  - current sections NOT in the preset's ordered list are disabled by default
-		*  - only the preset's ACTIVE sections (in the order list but not in its block
-		*    list) are unblocked; the preset's own blocked sections stay blocked.
+		* 计算应用预设时的配置补丁：
+		*  - 同名段被覆盖（顺序列表在运行时驱动这一行为）
+		*  - 预设中有、当前提示词中没有的段被添加
+		*  - 当前有、但不在预设有序列表中的段默认被屏蔽
+		*  - 只有预设的「激活段」（在 order 列表且不在其屏蔽名单中）被解除屏蔽；
+		*    预设自己屏蔽的段保持屏蔽。
 		*
-		* Custom injected sections that exist in the current config but are NOT in the
-		* preset's ordered list are preserved in the resulting inject list (so they
-		* stay visible) and disabled (added to the blocked set), rather than silently
-		* dropped — a preset must not make the user's own injected sections vanish.
+		* 当前配置里存在、但不在预设有序列表中的自定义注入段会被保留到结果的
+		* inject 列表中（因此仍然可见）并置为禁用（加入屏蔽集合），而不是被静默
+		* 丢弃——预设不能让用户自己注入的凭空消失。
 		*/
 		function applyPresetData(data, cfg, currentNames) {
 			const presetOrder = data.order ?? [];
@@ -490,7 +734,12 @@ window.__ModuleLoader__.load({
 				for (const name of currentNames) if (!presetNames.has(name)) blocked.add(name);
 				for (const name of activeNames) blocked.delete(name);
 			}
-			return {
+			const keptCatalogs = {};
+			const bootstrap = data.tools?.bootstrap !== void 0 ? data.tools.bootstrap : cfg.tools?.bootstrap;
+			const compaction = data.tools?.compaction !== void 0 ? data.tools.compaction : cfg.tools?.compaction;
+			if (bootstrap !== void 0) keptCatalogs.bootstrap = bootstrap;
+			if (compaction !== void 0) keptCatalogs.compaction = compaction;
+			const patch = {
 				sections: [...blocked],
 				replace: {
 					...cfg.replace ?? {},
@@ -499,42 +748,123 @@ window.__ModuleLoader__.load({
 				inject,
 				tools: {
 					exclude: data.tools?.exclude ?? [],
-					include: data.tools?.include ?? []
+					...keptCatalogs
 				}
 			};
+			if (Array.isArray(data.sectionsBootstrap)) patch.sectionsBootstrap = data.sectionsBootstrap;
+			if (Array.isArray(data.sectionsCompaction)) patch.sectionsCompaction = data.sectionsCompaction;
+			return patch;
 		}
+		/** 三个阶段部分的固定展示顺序：引导期 → 常驻期 → 压缩受控期。
+		*  恒定全部渲染 —— 预设没有某个阶段时该部分只是空的，绝不隐藏。 */
+		const PART_ORDER = [
+			"bootstrap",
+			"active",
+			"compaction"
+		];
 		/**
-		* Remove a custom (plugin-added) section from the config: it disappears from
-		* the inject list, is no longer forced into the blocked set, and any replace
-		* text for it is cleared. The remaining inject entries are re-indexed to a
-		* contiguous 0..n-1 order (the virtual index model), so removal never leaves
-		* holes. System sections read from the host inventory cannot be removed this
-		* way (they would just come back on the next inventory read).
+		* 一个阶段部分写回哪一份过滤配置：引导期 → `tools.bootstrap`、压缩受控期 →
+		* `tools.compaction`、常驻期 → 静态 `tools.exclude`。三份名单互不继承。
 		*/
-		function removeSection(name, cfg) {
-			const sections = (cfg.sections ?? []).filter((n) => n !== name);
-			const inject = (cfg.inject ?? []).filter((item) => item.name !== name).map((item, i) => ({
-				...item,
-				order: i
-			}));
-			const replace = { ...cfg.replace ?? {} };
-			delete replace[name];
+		function phaseConfigKey(key) {
+			return key === "active" ? "static" : key;
+		}
+		/**
+		* 把一个阶段的 exclude 名单写回整份工具配置，返回新对象（其余阶段原样保留）。
+		* 一次拖放可能要同时改两个阶段的名单（搬移 = 源阶段隐藏 + 目标阶段显示），必须
+		* 在同一个对象上连续套完再落一次写入 —— 分两次写会各自基于旧 cfg 计算而互相覆盖。
+		*/
+		function withPhaseExclude(tools, key, exclude) {
+			const base = tools ?? {};
+			const target = phaseConfigKey(key);
+			if (target === "bootstrap") return {
+				...base,
+				bootstrap: {
+					...base.bootstrap ?? {},
+					exclude
+				}
+			};
+			if (target === "compaction") return {
+				...base,
+				compaction: {
+					...base.compaction ?? {},
+					exclude
+				}
+			};
 			return {
-				sections,
-				inject,
-				replace
+				...base,
+				exclude
+			};
+		}
+		/**
+		* 把一个阶段的 add 名单（要加回该阶段的工具）写回整份工具配置，返回新对象。
+		* 与 withPhaseExclude 对称：常驻期写静态 `tools.add`，引导期写 `tools.bootstrap.add`，
+		* 压缩受控期写 `tools.compaction.add`，其余阶段原样保留。
+		*/
+		function withPhaseAdd(tools, key, add) {
+			const base = tools ?? {};
+			const target = phaseConfigKey(key);
+			if (target === "bootstrap") return {
+				...base,
+				bootstrap: {
+					...base.bootstrap ?? {},
+					add
+				}
+			};
+			if (target === "compaction") return {
+				...base,
+				compaction: {
+					...base.compaction ?? {},
+					add
+				}
+			};
+			return {
+				...base,
+				add
 			};
 		}
-		/** Serialize a preset for export (JSON-safe full snapshot). */
-		function serializePreset(preset) {
+		/** 某个工具在当前黑名单配置下是否被隐藏。 */
+		function isToolHidden(name, toolsCfg) {
+			return (toolsCfg?.exclude ?? []).includes(name);
+		}
+		/**
+		* 编辑目标的「显示视图」：全局目标返回原配置；agent 预设目标把该预设
+		* override 的字段叠在全局值之上展示（空缺字段显示全局继承值）。`presets`
+		* 与 `activePreset` 永远来自全局 —— 预设快照库本身不分作用域。
+		*/
+		function editView(cfg, target) {
+			if (!target) return cfg;
+			const ovr = cfg.overrides?.[target] ?? {};
 			return {
-				name: preset.name,
-				data: preset.data
+				sections: ovr.sections ?? cfg.sections,
+				sectionsBootstrap: ovr.sectionsBootstrap ?? cfg.sectionsBootstrap,
+				sectionsCompaction: ovr.sectionsCompaction ?? cfg.sectionsCompaction,
+				replace: ovr.replace ?? cfg.replace,
+				inject: ovr.inject ?? cfg.inject,
+				tools: {
+					exclude: ovr.tools?.exclude ?? cfg.tools?.exclude,
+					add: ovr.tools?.add ?? cfg.tools?.add,
+					bootstrap: ovr.tools?.bootstrap ?? cfg.tools?.bootstrap,
+					compaction: ovr.tools?.compaction ?? cfg.tools?.compaction
+				},
+				presets: cfg.presets,
+				activePreset: cfg.activePreset
 			};
 		}
 		/**
-		* Import preset(s): same-name presets are skipped, only distinct names are
-		* added. Returns a new presets list (or the original if nothing changed).
+		* Derive a safe default filename for a preset export. User-entered preset
+		* names may contain characters that are illegal in filenames (`/\:*?"<>|`,
+		* control chars) — those are replaced; a trailing dot/space is trimmed
+		* (invalid on Windows); an empty or all-illegal result falls back to
+		* `preset`.
+		*/
+		function presetExportFilename(name) {
+			const sanitized = String(name).replace(/[<>:"/\\|?*\u0000-\u001f]/g, "_").trim().replace(/[. ]+$/, "");
+			return `${sanitized === "" ? "preset" : sanitized}.json`;
+		}
+		/**
+		* 导入预设：同名的会被跳过，只追加名字不同的预设。返回新的预设列表
+		* （若没有任何变更则返回原列表）。
 		*/
 		function addImportedPresets(existing, parsed, makeId) {
 			const incoming = Array.isArray(parsed) ? parsed : [parsed];
@@ -546,236 +876,660 @@ window.__ModuleLoader__.load({
 			}));
 			return added.length > 0 ? [...existing, ...added] : existing;
 		}
-		/** Delete a preset, clearing the active id if it pointed at the removed one. */
+		/** 删除某个预设；若它正是当前激活的预设，则同时清除 activeId。 */
 		function removePreset(presets, id, activeId) {
 			return {
 				presets: presets.filter((p) => p.id !== id),
 				activeId: activeId === id ? void 0 : activeId
 			};
 		}
+		/** 生成预设 id：时间戳 + 随机段（base36），够用且无需额外依赖。 */
+		function genId() {
+			return "p_" + Date.now().toString(36) + Math.random().toString(36).slice(2, 7);
+		}
+		//#endregion
+		//#region lib/sectionOps.mjs
+		/**
+		* 提示词段面板的纯状态逻辑（无 React / 无 IO）。
+		* 与 src/client/SectionsTab.tsx 共享同一份实现（浏览器里随 client bundle
+		* 打包；node --test 直接 import 本文件跑单测），保证「测试即上线代码」。
+		*
+		* 阶段模型：引导期（bootstrap）/ 常驻期（active）/ 压缩受控期（compaction）
+		* 恒定全部显示（预设没有某个阶段时该部分就是空的），各自拥有独立的注入
+		* 名单与 order 空间；屏蔽按「每阶段独立名单」写回（引导期 →
+		* sectionsBootstrap，压缩受控期 → sectionsCompaction，常驻期 → 全局 sections）。
+		* 入参统一是名义阶段键，不再有「同形折叠组」这种把引导期当常驻期用的形态。
+		*/
+		/** 名义阶段键 → 屏蔽名单写回目标（常驻期用全局 sections）。 */
+		function sectionListOf(key) {
+			return key === "bootstrap" ? "bootstrap" : key === "compaction" ? "compaction" : "global";
+		}
+		/** 名义阶段键 → 注入阶段：压缩受控期是独立注入阶段（compaction）。 */
+		function injectPhaseOf(key) {
+			return key === "bootstrap" ? "bootstrap" : key === "active" ? "active" : "compaction";
+		}
+		/** 某注入段出现在哪些阶段部分：always 全阶段；bootstrap/compaction/active
+		*  仅各自对应的阶段（与服务端 filterInjectByPhase 的三态互相独立一致）。 */
+		function acceptsInjectFor(key, phase) {
+			if (phase === "always") return true;
+			return phase === key;
+		}
+		/** 该阶段生效的屏蔽名单（全局 + 阶段独立 的 union）。 */
+		function deniedNames(cfg, key) {
+			const list = sectionListOf(key);
+			const phase = list === "bootstrap" ? cfg.sectionsBootstrap ?? [] : list === "compaction" ? cfg.sectionsCompaction ?? [] : [];
+			return [...cfg.sections ?? [], ...phase];
+		}
+		/**
+		* 某个阶段部分当前的注入身份（含未保存草稿）。
+		*
+		* `names` = 本部分可见的注入段名（本阶段专属 + 跨阶段的 always）。post 视图来自
+		* 「上次保存」的服务端结果，删除只改草稿，所以 post 独有段必须有 names 背书才
+		* 能显示 —— 否则刚删掉的自定义段会以「系统段」复活（身份只认 custom 标记，条目
+		* 没了就被判成系统），再经一次重排就被写成 custom:false 空文本，用户填的内容被
+		* 抹平。`custom` 只收真正的自定义段，`order` 只收本阶段的草稿序。
+		*
+		* `text` = 本阶段生效的用户文本：自定义段自带的文本，以及**系统段在本阶段被
+		* 替换后的文本**（非空即替换）。系统段的文本必须按阶段存 —— 注入条目本来就带
+		* `phase`，服务端按阶段筛选，所以三个阶段各改各的文本互不影响；旧的全局
+		* `replace` 字典一份文本对三个阶段同时生效，已不承担界面编辑。
+		*/
+		function injectedAt(cfg, key) {
+			const phase = injectPhaseOf(key);
+			const names = /* @__PURE__ */ new Set();
+			const custom = /* @__PURE__ */ new Set();
+			const text = /* @__PURE__ */ new Map();
+			const order = /* @__PURE__ */ new Map();
+			for (const item of cfg.inject ?? []) {
+				if (item === null || typeof item !== "object" || typeof item.name !== "string") continue;
+				const itemPhase = item.phase ?? "always";
+				if (itemPhase === phase) order.set(item.name, item.order ?? 0);
+				if (!acceptsInjectFor(key, itemPhase)) continue;
+				names.add(item.name);
+				if (item.text && !text.has(item.name)) text.set(item.name, item.text);
+				if (item.custom === true) custom.add(item.name);
+			}
+			return {
+				phase,
+				names,
+				custom,
+				text,
+				order
+			};
+		}
+		/**
+		* 屏蔽/恢复一个段（当前阶段语义）：返回需要写盘的字段补丁。
+		* - 屏蔽：该阶段名单加入（常驻期直接加入全局 sections）。
+		* - 恢复：从该阶段名单与全局名单同时移除（union 语义 —— 否则仍会被另一
+		*   份名单挡住，恢复不生效）。
+		* 名单无变化时不产出字段（空补丁 = 不写盘），避免把继承值冻结成无意义的
+		* 空数组覆盖。
+		*/
+		function blockPatch(cfg, key, name, blocked) {
+			const list = sectionListOf(key);
+			const g = (cfg.sections ?? []).slice();
+			const gi = g.indexOf(name);
+			const patch = {};
+			if (list === "global") {
+				if (blocked) {
+					if (gi < 0) {
+						g.push(name);
+						patch.sections = g;
+					}
+				} else if (gi >= 0) {
+					g.splice(gi, 1);
+					patch.sections = g;
+				}
+				return patch;
+			}
+			const field = list === "bootstrap" ? "sectionsBootstrap" : "sectionsCompaction";
+			const phase = (cfg[field] ?? []).slice();
+			const pi = phase.indexOf(name);
+			if (blocked) {
+				if (pi < 0) {
+					phase.push(name);
+					patch[field] = phase;
+				}
+			} else {
+				if (pi >= 0) {
+					phase.splice(pi, 1);
+					patch[field] = phase;
+				}
+				if (gi >= 0) {
+					g.splice(gi, 1);
+					patch.sections = g;
+				}
+			}
+			return patch;
+		}
+		/**
+		* 重排/插入一个阶段的有序行列表：把 dragName 从列表中移除后，插入到
+		* targetName 行之上（pos='above'）或之下（pos='below'）；返回新列表。
+		* 拖入的新段由调用方以 newRow 提供，插入后保留在列表中（其余行保持原样）。
+		*/
+		function reorderInsert(rows, dragName, targetName, pos, newRow = null) {
+			const base = rows.filter((row) => row.name !== dragName);
+			const idx = base.findIndex((row) => row.name === targetName);
+			if (idx < 0) return null;
+			const insertAt = Math.max(0, Math.min(pos === "above" ? idx : idx + 1, base.length));
+			const entry = newRow ?? rows.find((row) => row.name === dragName);
+			if (!entry) return null;
+			base.splice(insertAt, 0, entry);
+			return base;
+		}
+		/**
+		* 持久化一个阶段的有序列表（v1 persistOrder 的逐阶段版）：把 rows（有序行）
+		* 写成该阶段的注入条目，order = 连续整数（0,1,2,…）——「虚拟 order 决定注入
+		* 顺序」；文本优先级 = 本阶段的用户替换文本（row.override）→ 自定义段自带的
+		* 文本（row.text）→ 空文本（= 仅 order 覆盖，服务端保留原文）。三者缺一不可：
+		* 重排走的就是这个函数，漏掉 override 会让一次拖动把用户在该阶段改的文本抹平。
+		* 其它阶段（含 always）的注入条目原样保留。
+		*/
+		function phaseInjectEntries(cfg, key, rows) {
+			const phase = injectPhaseOf(key);
+			const others = (cfg.inject ?? []).filter((item) => (item.phase ?? "always") !== phase);
+			const entries = rows.map((row, i) => ({
+				name: row.name,
+				order: i,
+				text: row.override || (row.custom ? row.text ?? "" : ""),
+				phase,
+				custom: row.custom
+			}));
+			return [...others, ...entries];
+		}
 		//#endregion
 		//#region src/client/SectionsTab.tsx
-		/** Prompt-sections tab: block / replace / inject / reorder prompt sections. */
-		function SectionsTab({ cfg, inv, scope, t }) {
-			const replace = cfg.replace ?? {};
-			const blockedNames = new Set(cfg.sections ?? []);
+		/** 提示词段 Tab：四个部分 —— 引导期 / 常驻期 / 压缩受控期（三个阶段恒定
+		*  显示，预设没有某个阶段时该部分只是空的）+ 本系统全部提示词（只读池）。
+		*
+		*  交互对齐提示词段初版（v1），并修复三类反馈缺失：
+		*  - 上三段每行 = 真实进入该阶段装配的段（post 视图，与预览一致 —— 预设
+		*    原生阶段插件裁剪掉的段不显示）∪ 被屏蔽的段 ∪ 配置里的自定义注入段，
+		*    顺序以 base 骨架为底再叠加草稿序；整行可拖拽，拖到某行上方/下方出现
+		*    插入指示线，松手即在该位置重排。
+		*  - 被屏蔽的段与普通段一模一样：留在列表原位、一样可操作（拖拽/箭头/替换/
+		*    恢复/删除），随时可互相转换，唯一区别是屏蔽勾选框与「已屏蔽」徽标 ——
+		*    屏蔽只意味着不注入模型，不剥夺任何编辑能力（v1 语义）。屏蔽勾选直接
+		*    绑定当前生效名单（deniedNames = 全局 + 该阶段名单，含未保存草稿），
+		*    点击立即反馈。
+		*  - 重排（拖入/箭头）走 `persistPhase`：把该阶段全部行重写为连续整数
+		*    虚拟 order（系统段写空文本 = 仅 order 覆盖，服务端保留原文；custom 段
+		*    保留文本）—— UI 行序叠加同一份 order 立即重排，拖动即时可见。
+		*  - 文本编辑（「编辑」/「还原」）同样按阶段生效：写的就是本阶段注入条目的
+		*    文本，三个阶段各改各的、互不影响（服务端让本阶段注入文本优先于全局
+		*    replace，否则一份文本会同时改坏三个阶段）。全局 replace 字典自此不再由
+		*    界面写入，只在「还原」时顺带清除遗留条目 —— 新界面没有别的出口能恢复它。
+		*  - 拖放搬移保留行对象（system/custom 身份与文本原样带走），绝不重建行 ——
+		*    重建会把系统段误标成 custom 并清空内容。只有从其它部分/全部池拖入的
+		*    新段才构造新行（身份取自拖拽源）。
+		*  - 拖放事件在行上处理并 stopPropagation，避免与阶段框二次处理对冲。
+		*  - 全部提示词 → 上三段：插入该段到目标位置（已存在则只是移动排序；该段
+		*    在目标阶段被屏蔽则同步解除屏蔽 —— 行立即出现）。上三段 → 全部：从该
+		*    阶段移除 —— custom 段删除注入条目；系统段等价于屏蔽该阶段（系统段是
+		*    装配的一部分，无法真正删除）。
+		*  - 解除屏蔽按份额归属分流写入：继承自全局名单的屏蔽直接改全局名单（立即
+		*    写盘通道）—— override 无法表达「比全局更宽松」（空名单回落全局，解除
+		*    会在保存后复现）；override 自报名单与阶段名单的份额走目标草稿。
+		*  - 每个阶段部分按自己那一阶段的装配结果给出警示：该 scope 有 complete 段
+		*    整段接管最终提示词，或本插件产出的段被下游装配规则丢弃时，明确写出
+		*    「段级定制不会（完全）进入模型看到的提示词」，避免提示词 Tab 与预览 Tab
+		*    各说各话。
+		*
+		*  全部阶段状态逻辑来自 lib/sectionOps.mjs（纯函数，node --test 单测直接
+		*  覆盖同一份代码）。
+		*/
+		/** 编辑态的键：段名之外还要带阶段，否则三个部分里同名的行会同时展开编辑器。 */
+		const editKey = (key, name) => `${key}:${name}`;
+		function SectionsTab({ cfg, inv, phases, target, globalSections, ownedSections, t, write, writeGlobalField }) {
 			const [editing, setEditing] = (0, react.useState)(null);
 			const [draft, setDraft] = (0, react.useState)("");
 			const [dragName, setDragName] = (0, react.useState)(null);
+			const [dragSource, setDragSource] = (0, react.useState)(null);
 			const [dropTarget, setDropTarget] = (0, react.useState)(null);
-			const merged = mergeSections(inv, cfg, blockedNames);
-			const toggleBlock = (name, currentlyBlocked) => {
-				const list = (cfg.sections ?? []).slice();
-				if (currentlyBlocked) {
-					const i = list.indexOf(name);
-					if (i >= 0) list.splice(i, 1);
-				} else list.push(name);
-				scope.set("sections", list);
-			};
-			const startReplace = (name, original) => {
-				setEditing(name);
-				setDraft(replace[name] ?? original);
-			};
-			const commitReplace = (name) => {
-				const next = { ...replace };
-				if (draft.trim() === "") delete next[name];
-				else next[name] = draft;
-				scope.set("replace", next);
-				setEditing(null);
+			const [notice, setNotice] = (0, react.useState)(null);
+			const scrollRef = (0, react.useRef)({
+				raf: 0,
+				clientY: 0
+			});
+			const stopAutoScroll = () => {
+				if (scrollRef.current.raf !== 0) {
+					cancelAnimationFrame(scrollRef.current.raf);
+					scrollRef.current.raf = 0;
+				}
+			};
+			const autoScrollTick = () => {
+				scrollRef.current.raf = 0;
+				const edge = 48;
+				const y = scrollRef.current.clientY;
+				const inner = window.innerHeight;
+				let node = rootRef.current?.parentElement;
+				while (node !== null && node !== void 0) {
+					if (node.scrollHeight > node.clientHeight) {
+						if (y < edge) node.scrollTop -= Math.max(6, (edge - y) / 2);
+						else if (y > inner - edge) node.scrollTop += Math.max(6, (y - (inner - edge)) / 2);
+						else return;
+						scrollRef.current.raf = requestAnimationFrame(autoScrollTick);
+						return;
+					}
+					node = node.parentElement;
+				}
+				if (y < edge) window.scrollBy({ top: -Math.max(6, (edge - y) / 2) });
+				else if (y > inner - edge) window.scrollBy({ top: Math.max(6, (y - (inner - edge)) / 2) });
+				if (y < edge || y > inner - edge) scrollRef.current.raf = requestAnimationFrame(autoScrollTick);
+			};
+			const rootRef = (0, react.useRef)(null);
+			const rootDragOver = (e) => {
+				if (!dragName) return;
+				scrollRef.current.clientY = e.clientY;
+				if (scrollRef.current.raf === 0) scrollRef.current.raf = requestAnimationFrame(autoScrollTick);
 			};
-			const restoreReplace = (name) => {
-				const next = { ...replace };
-				delete next[name];
-				scope.set("replace", next);
+			const parts = PART_ORDER;
+			const partNote = (key) => {
+				const view = phases?.[key];
+				if (view === void 0 || view === null) return null;
+				if (cfg.forceSections !== false) return null;
+				if (view.takenOverBy !== void 0) return (0, react.createElement)("div", { style: s.noticeWarn }, t("sectionsTakenOver", { name: view.takenOverBy }));
+				const lost = view.lostSections;
+				if (lost !== void 0) return (0, react.createElement)("div", { style: s.noticeWarn }, t("sectionsLost", {
+					emitted: lost.emitted,
+					survived: lost.survived
+				}));
+				return null;
 			};
-			const persistOrder = (ordered) => {
-				const list = ordered.map((sec, i) => {
-					const existing = (cfg.inject ?? []).find((x) => x.name === sec.name);
-					const isCustom = sec.source === "custom";
+			const rowsOf = (key) => {
+				const replace = cfg.replace ?? {};
+				const view = phases?.[key];
+				const denied = new Set(deniedNames(cfg, key));
+				const postByName = new Map((view?.sections ?? []).map((sec) => [sec.name, sec]));
+				const baseByName = new Map((view?.baseSections ?? []).map((sec) => [sec.name, sec]));
+				const { phase, names: injectedHere, custom: customNames, text, order: phaseOrder } = injectedAt(cfg, key);
+				const names = [];
+				const seen = /* @__PURE__ */ new Set();
+				const push = (name) => {
+					if (!seen.has(name)) {
+						seen.add(name);
+						names.push(name);
+					}
+				};
+				for (const sec of view?.baseSections ?? []) if (postByName.has(sec.name) || denied.has(sec.name) || sec.blocked === true) push(sec.name);
+				for (const name of postByName.keys()) if (baseByName.has(name) || injectedHere.has(name)) push(name);
+				for (const item of cfg.inject ?? []) {
+					if ((item.phase ?? "always") !== phase) continue;
+					if (item.custom === true || text.get(item.name) || baseByName.has(item.name) || postByName.has(item.name)) push(item.name);
+				}
+				for (const name of customNames) push(name);
+				const rows = names.map((name) => {
+					const override = text.get(name) ?? "";
 					return {
-						name: sec.name,
-						order: i,
-						text: isCustom ? sec.text ?? "" : existing?.text ?? "",
-						custom: isCustom
+						name,
+						text: postByName.get(name)?.text ?? baseByName.get(name)?.text ?? "",
+						replaced: override !== "" || Object.hasOwn(replace, name),
+						custom: customNames.has(name),
+						override,
+						blocked: denied.has(name)
 					};
 				});
-				scope.set("inject", list);
+				if (phaseOrder.size > 0) {
+					const fallback = new Map(rows.map((row, i) => [row.name, i]));
+					rows.sort((a, b) => (phaseOrder.get(a.name) ?? fallback.get(a.name) ?? 0) - (phaseOrder.get(b.name) ?? fallback.get(b.name) ?? 0));
+				}
+				return rows;
 			};
-			const removeCustom = (name) => {
-				const patch = removeSection(name, cfg);
-				scope.set("sections", patch.sections);
-				scope.set("inject", patch.inject);
-				scope.set("replace", patch.replace);
+			const applyBlock = (key, name, blocked) => {
+				if (blocked || !target) {
+					const patch = blockPatch(cfg, key, name, blocked);
+					for (const [field, value] of Object.entries(patch)) {
+						if (JSON.stringify(value) === JSON.stringify(cfg[field] ?? [])) continue;
+						write(field, value);
+					}
+					return;
+				}
+				const patch = blockPatch(cfg, key, name, false);
+				const effectiveOwned = ownedSections && ownedSections.length > 0 ? ownedSections : void 0;
+				for (const [field, value] of Object.entries(patch)) {
+					if (field === "sections") {
+						if ((globalSections ?? []).includes(name) && (!effectiveOwned || ownedSections.includes(name))) writeGlobalField("sections", (globalSections ?? []).filter((n) => n !== name));
+						if (effectiveOwned?.includes(name)) write("sections", value);
+						continue;
+					}
+					if (JSON.stringify(value) === JSON.stringify(cfg[field] ?? [])) continue;
+					write(field, value);
+				}
+			};
+			const toggleBlocked = (key, name) => applyBlock(key, name, !deniedNames(cfg, key).includes(name));
+			const inBaseOf = (key, name) => (phases?.[key]?.baseSections ?? []).some((sec) => sec.name === name);
+			const persistPhase = (key, rows) => {
+				write("inject", phaseInjectEntries(cfg, key, rows));
 			};
-			const moveOrder = (index, dir) => {
+			const moveRow = (key, index, dir) => {
+				const rows = rowsOf(key);
 				const target = index + dir;
-				if (target < 0 || target >= merged.length) return;
-				const next = merged.slice();
+				if (target < 0 || target >= rows.length) return;
+				const next = rows.slice();
 				const [item] = next.splice(index, 1);
 				next.splice(target, 0, item);
-				persistOrder(next);
+				persistPhase(key, next);
+			};
+			const removeFromPart = (key, name) => {
+				const phase = injectPhaseOf(key);
+				write("inject", (cfg.inject ?? []).filter((x) => {
+					if (x.name !== name) return true;
+					const itemPhase = x.phase ?? "always";
+					return !(itemPhase === phase || itemPhase === "always");
+				}));
+				applyBlock(key, name, false);
+			};
+			const startReplace = (key, row) => {
+				setEditing(editKey(key, row.name));
+				setDraft(row.override || row.text);
+			};
+			const commitReplace = (key, row) => {
+				const next = rowsOf(key).map((r) => r.name !== row.name ? r : {
+					...r,
+					override: draft,
+					text: draft
+				});
+				persistPhase(key, next);
+				setEditing(null);
+			};
+			const restoreReplace = (key, row) => {
+				const next = rowsOf(key).map((r) => r.name !== row.name ? r : {
+					...r,
+					override: "",
+					text: r.custom ? r.text : ""
+				});
+				persistPhase(key, next);
+				if (!row.custom && Object.hasOwn(cfg.replace ?? {}, row.name)) {
+					const rest = { ...cfg.replace ?? {} };
+					delete rest[row.name];
+					write("replace", rest);
+				}
 			};
-			const onDragStart = (e, name) => {
+			const addSection = (name, text, phase) => {
+				const inject = (cfg.inject ?? []).slice();
+				inject.push({
+					name,
+					order: 120 + inject.length,
+					text,
+					phase,
+					custom: true
+				});
+				write("inject", inject);
+			};
+			const startDrag = (e, name, source) => {
 				setDragName(name);
+				setDragSource(source);
 				e.dataTransfer.effectAllowed = "move";
 				try {
 					e.dataTransfer.setData("text/plain", name);
 				} catch {}
 			};
-			const onDragOver = (e, name) => {
+			const rowDragOver = (e, key, name) => {
 				if (!dragName || dragName === name) return;
 				e.preventDefault();
 				e.dataTransfer.dropEffect = "move";
 				const rect = e.currentTarget.getBoundingClientRect();
 				const pos = e.clientY < rect.top + rect.height / 2 ? "above" : "below";
 				setDropTarget({
+					part: key,
 					name,
 					pos
 				});
 			};
-			const onDrop = (e, target) => {
-				e.preventDefault();
-				if (!dragName || dragName === target.name) {
-					setDragName(null);
-					setDropTarget(null);
+			const carryFor = (key, source, name) => {
+				if (source.kind !== "all" || source.custom) return {
+					text: "",
+					blocked: false
+				};
+				if (inBaseOf(key, name)) return {
+					text: "",
+					blocked: false
+				};
+				if (source.text === "") return {
+					text: "",
+					blocked: true
+				};
+				return {
+					text: source.text,
+					blocked: false
+				};
+			};
+			const insertInto = (key, targetName, pos) => {
+				if (!dragName || !dragSource) return;
+				const carry = carryFor(key, dragSource, dragName);
+				if (carry.blocked) {
+					setNotice(t("sectionDynamicNoAdd", { name: dragName }));
 					return;
 				}
-				const dragged = merged.find((x) => x.name === dragName);
-				if (!dragged) {
-					setDragName(null);
-					setDropTarget(null);
-					return;
+				const rows = rowsOf(key);
+				const newRow = rows.find((row) => row.name === dragName) ?? {
+					name: dragName,
+					text: dragSource.custom ? dragSource.text : "",
+					replaced: Object.hasOwn(cfg.replace ?? {}, dragName),
+					custom: dragSource.custom,
+					override: carry.text,
+					blocked: false
+				};
+				const next = reorderInsert(rows, dragName, targetName, pos, newRow);
+				if (next === null) return;
+				if (dragSource.kind === "all" && inBaseOf(key, dragName) && deniedNames(cfg, key).includes(dragName)) applyBlock(key, dragName, false);
+				persistPhase(key, next);
+			};
+			const rowDrop = (e, key, name) => {
+				e.preventDefault();
+				e.stopPropagation();
+				if (dragName && dragName !== name) {
+					const pos = dropTarget?.part === key && dropTarget.name === name && dropTarget.pos ? dropTarget.pos : "below";
+					insertInto(key, name, pos);
 				}
-				const next = merged.filter((x) => x.name !== dragName);
-				const idx = next.findIndex((x) => x.name === target.name);
-				const pos = dropTarget?.name === target.name ? dropTarget.pos : "below";
-				next.splice(pos === "above" ? idx : idx + 1, 0, dragged);
-				persistOrder(next);
 				setDragName(null);
+				setDragSource(null);
 				setDropTarget(null);
 			};
-			const onDragEnd = () => {
+			const partDropEnd = (e, key) => {
+				e.preventDefault();
+				if (dragName && dragSource) {
+					const carry = carryFor(key, dragSource, dragName);
+					if (!carry.blocked) {
+						const rows = rowsOf(key);
+						const existing = rows.find((row) => row.name === dragName);
+						const next = rows.filter((row) => row.name !== dragName);
+						next.push(existing ?? {
+							name: dragName,
+							text: dragSource.custom ? dragSource.text : "",
+							replaced: Object.hasOwn(cfg.replace ?? {}, dragName),
+							custom: dragSource.custom,
+							override: carry.text,
+							blocked: false
+						});
+						if (dragSource.kind === "all" && inBaseOf(key, dragName) && deniedNames(cfg, key).includes(dragName)) applyBlock(key, dragName, false);
+						persistPhase(key, next);
+					} else setNotice(t("sectionDynamicNoAdd", { name: dragName }));
+				}
 				setDragName(null);
+				setDragSource(null);
 				setDropTarget(null);
 			};
-			const addSection = (name, order, text) => {
-				const next = merged.slice();
-				const entry = {
-					name,
-					order,
-					text,
-					active: true,
-					replaced: false,
-					source: "custom"
-				};
-				const existing = next.findIndex((x) => x.name === name);
-				if (existing >= 0) next[existing] = entry;
-				else {
-					const idx = next.findIndex((x) => x.order > order);
-					if (idx < 0) next.push(entry);
-					else next.splice(idx, 0, entry);
+			const allBoxDrop = (e) => {
+				e.preventDefault();
+				if (dragName && dragSource?.kind === "part" && dragSource.key) {
+					const src = dragSource.key;
+					const row = rowsOf(src).find((r) => r.name === dragName);
+					const addedSystem = !!row && !row.custom && !inBaseOf(src, dragName) && row.override !== "";
+					if (row && !row.custom && !addedSystem) applyBlock(src, dragName, true);
+					else removeFromPart(src, dragName);
 				}
-				persistOrder(next);
+				setDragName(null);
+				setDragSource(null);
+				setDropTarget(null);
 			};
-			return (0, react.createElement)("div", { style: s.list }, [
-				merged.length === 0 ? (0, react.createElement)("div", { style: s.muted }, t("empty")) : null,
-				merged.map((sec, index) => {
-					const blocked = blockedNames.has(sec.name);
-					const isEditing = editing === sec.name;
-					const isDragging = dragName === sec.name;
-					const isDropTarget = dropTarget?.name === sec.name;
-					const rowStyle = {
-						...s.row,
-						...isDragging ? s.rowDragging : {},
-						...isDropTarget && dropTarget.pos === "above" ? s.rowDropAbove : {},
-						...isDropTarget && dropTarget.pos === "below" ? s.rowDropBelow : {}
-					};
-					return (0, react.createElement)("div", {
-						key: sec.name,
-						style: rowStyle,
-						draggable: true,
-						onDragStart: (e) => onDragStart(e, sec.name),
-						onDragOver: (e) => onDragOver(e, sec.name),
-						onDrop: (e) => onDrop(e, sec),
-						onDragEnd
-					}, [
-						(0, react.createElement)("span", {
-							style: s.dragHandle,
-							title: t("drag")
-						}, "⠿"),
-						(0, react.createElement)("label", { style: s.switchWrap }, [(0, react.createElement)("input", {
-							type: "checkbox",
-							checked: blocked,
-							onChange: () => toggleBlock(sec.name, blocked)
-						}), (0, react.createElement)("span", { style: blocked ? s.badgeBlocked : s.badgeOk }, blocked ? t("blockedOn") : t("blockedOff"))]),
-						(0, react.createElement)("div", { style: s.rowBody }, [(0, react.createElement)("div", { style: s.rowTitle }, [
-							(0, react.createElement)("span", { style: s.code }, sec.name),
-							(0, react.createElement)("span", { style: s.orderTag }, "#" + index),
-							(0, react.createElement)("span", { style: sec.source === "custom" ? s.badgeCustom : s.badgeSystem }, sec.source === "custom" ? t("manual") : t("system")),
-							replace[sec.name] ? (0, react.createElement)("span", { style: s.badgeReplaced }, t("replaced")) : null
-						]), isEditing ? (0, react.createElement)("div", { style: s.editBox }, [(0, react.createElement)("textarea", {
-							style: s.editInput,
-							value: draft,
-							onChange: (e) => setDraft(e.target.value),
-							rows: 3
-						}), (0, react.createElement)("div", { style: s.injectRow }, [
-							(0, react.createElement)("button", {
-								style: s.mini,
-								onClick: () => commitReplace(sec.name)
-							}, t("save")),
-							(0, react.createElement)("button", {
-								style: s.mini,
-								onClick: () => setEditing(null)
-							}, t("clearInput")),
-							sec.source !== "custom" && replace[sec.name] ? (0, react.createElement)("button", {
-								style: s.mini,
-								onClick: () => restoreReplace(sec.name)
-							}, t("restore")) : null
-						])]) : (0, react.createElement)("div", { style: s.preview }, String(replace[sec.name] ?? sec.text ?? "").slice(0, 140) || (sec.source === "custom" ? t("empty") : t("dynamic")))]),
-						(0, react.createElement)("div", { style: s.arrowCol }, [(0, react.createElement)("button", {
-							style: s.arrow,
-							disabled: index === 0,
-							onClick: () => moveOrder(index, -1),
-							title: t("moveUp")
-						}, "↑"), (0, react.createElement)("button", {
-							style: s.arrow,
-							disabled: index === merged.length - 1,
-							onClick: () => moveOrder(index, 1),
-							title: t("moveDown")
-						}, "↓")]),
-						isEditing ? null : (0, react.createElement)("button", {
+			const endDrag = () => {
+				stopAutoScroll();
+				setDragName(null);
+				setDragSource(null);
+				setDropTarget(null);
+			};
+			const partNoun = (key) => key === "bootstrap" ? t("sectionsPartGuide") : key === "compaction" ? t("sectionsPartControlled") : t("sectionsPartResident");
+			const isEditing = (key, row) => editing === editKey(key, row.name);
+			const renderRow = (key, row, index, total) => {
+				const isDragging = dragName === row.name;
+				const isDropTarget = dropTarget?.part === key && dropTarget.name === row.name;
+				const rowStyle = {
+					...s.row,
+					...isDragging ? s.rowDragging : {},
+					...isDropTarget && dropTarget && dropTarget.pos === "above" ? s.rowDropAbove : {},
+					...isDropTarget && dropTarget && dropTarget.pos === "below" ? s.rowDropBelow : {},
+					cursor: "move"
+				};
+				return (0, react.createElement)("div", {
+					key: row.name,
+					style: rowStyle,
+					draggable: true,
+					onDragStart: (e) => startDrag(e, row.name, {
+						kind: "part",
+						key,
+						text: row.custom ? row.override || row.text : "",
+						custom: row.custom
+					}),
+					onDragOver: (e) => rowDragOver(e, key, row.name),
+					onDrop: (e) => rowDrop(e, key, row.name),
+					onDragEnd: endDrag
+				}, [
+					(0, react.createElement)("span", {
+						style: s.dragHandle,
+						title: t("drag")
+					}, "⠿"),
+					(0, react.createElement)("label", { style: s.switchWrap }, [(0, react.createElement)("input", {
+						type: "checkbox",
+						checked: row.blocked,
+						onChange: () => toggleBlocked(key, row.name)
+					}), (0, react.createElement)("span", { style: row.blocked ? s.badgeBlocked : s.badgeOk }, row.blocked ? t("blockedOn") : t("blockedOff"))]),
+					(0, react.createElement)("div", { style: s.rowBody }, [(0, react.createElement)("div", { style: s.rowTitle }, [
+						(0, react.createElement)("span", { style: s.code }, row.name),
+						(0, react.createElement)("span", { style: s.orderTag }, "#" + index),
+						(0, react.createElement)("span", { style: row.custom ? s.badgeCustom : s.badgeSystem }, row.custom ? t("manual") : t("system")),
+						row.replaced ? (0, react.createElement)("span", { style: s.badgeReplaced }, t("replaced")) : null
+					]), isEditing(key, row) ? (0, react.createElement)("div", { style: s.editBox }, [(0, react.createElement)("textarea", {
+						style: s.editInput,
+						value: draft,
+						onChange: (e) => setDraft(e.target.value),
+						rows: 3
+					}), (0, react.createElement)("div", { style: s.injectRow }, [
+						(0, react.createElement)("button", {
 							style: s.mini,
-							onClick: () => startReplace(sec.name, String(sec.text ?? ""))
-						}, t("replace")),
-						!isEditing && sec.source !== "custom" && replace[sec.name] ? (0, react.createElement)("button", {
+							onClick: () => commitReplace(key, row)
+						}, t("save")),
+						(0, react.createElement)("button", {
 							style: s.mini,
-							onClick: () => restoreReplace(sec.name)
-						}, t("restore")) : null,
-						sec.source === "custom" ? (0, react.createElement)("button", {
+							onClick: () => setDraft("")
+						}, t("clearInput")),
+						!row.custom && (row.override || Object.hasOwn(cfg.replace ?? {}, row.name)) ? (0, react.createElement)("button", {
 							style: s.mini,
-							onClick: () => removeCustom(sec.name),
-							title: t("delete")
-						}, t("delete")) : null
-					]);
-				}),
-				(0, react.createElement)("div", { style: s.injectBox }, [(0, react.createElement)("div", { style: s.rowTitle }, t("injectNew")), (0, react.createElement)(InjectForm, {
-					onAdd: addSection,
-					t
-				})])
+							onClick: () => restoreReplace(key, row)
+						}, t("restore")) : null
+					])]) : (0, react.createElement)("div", { style: s.preview }, String(row.override || row.text || "").slice(0, 140) || (row.custom ? t("empty") : t("dynamic")))]),
+					(0, react.createElement)("div", { style: s.arrowCol }, [(0, react.createElement)("button", {
+						style: s.arrow,
+						disabled: index === 0,
+						onClick: () => moveRow(key, index, -1),
+						title: t("moveUp")
+					}, "↑"), (0, react.createElement)("button", {
+						style: s.arrow,
+						disabled: index === total - 1,
+						onClick: () => moveRow(key, index, 1),
+						title: t("moveDown")
+					}, "↓")]),
+					isEditing(key, row) ? null : (0, react.createElement)("button", {
+						style: s.mini,
+						onClick: () => startReplace(key, row)
+					}, t("replace")),
+					!isEditing(key, row) && !row.custom && (row.override || Object.hasOwn(cfg.replace ?? {}, row.name)) ? (0, react.createElement)("button", {
+						style: s.mini,
+						onClick: () => restoreReplace(key, row)
+					}, t("restore")) : null,
+					row.custom ? (0, react.createElement)("button", {
+						style: s.mini,
+						onClick: () => removeFromPart(key, row.name),
+						title: t("delete")
+					}, t("delete")) : null
+				]);
+			};
+			const renderPart = (key) => {
+				const rows = rowsOf(key);
+				return (0, react.createElement)("div", {
+					key,
+					style: s.injectBox,
+					onDragOver: (e) => {
+						if (dragName) {
+							e.preventDefault();
+							e.dataTransfer.dropEffect = "move";
+						}
+					},
+					onDrop: (e) => partDropEnd(e, key)
+				}, [
+					(0, react.createElement)("div", { style: s.rowTitle }, [(0, react.createElement)("span", null, partNoun(key)), (0, react.createElement)("span", { style: s.orderTag }, `${t("phaseVisible")} ${rows.length}`)]),
+					partNote(key),
+					rows.map((row, i) => renderRow(key, row, i, rows.length)),
+					(0, react.createElement)(InjectForm, {
+						onAdd: (name, text) => addSection(name, text, injectPhaseOf(key)),
+						lockedPhase: injectPhaseOf(key),
+						t
+					})
+				]);
+			};
+			return (0, react.createElement)("div", {
+				style: s.list,
+				ref: rootRef,
+				onDragOver: rootDragOver
+			}, [
+				notice ? (0, react.createElement)("div", { style: s.noticeWarn }, notice) : null,
+				parts.map(renderPart),
+				(0, react.createElement)("div", {
+					style: s.injectBox,
+					onDragOver: (e) => {
+						if (dragName) {
+							e.preventDefault();
+							e.dataTransfer.dropEffect = "move";
+						}
+					},
+					onDrop: allBoxDrop
+				}, [
+					(0, react.createElement)("div", { style: s.rowTitle }, [t("allSectionsTitle"), (0, react.createElement)("span", { style: s.orderTag }, `${(inv?.sections ?? []).length}`)]),
+					(0, react.createElement)("div", { style: {
+						...s.muted,
+						marginBottom: 4
+					} }, t("sectionsFourHint")),
+					(inv?.sections ?? []).length === 0 ? (0, react.createElement)("div", { style: s.muted }, t("empty")) : null,
+					(inv?.sections ?? []).map((sec) => (0, react.createElement)("div", {
+						key: sec.name,
+						style: {
+							...s.row,
+							cursor: "copy",
+							opacity: .92
+						},
+						draggable: true,
+						onDragStart: (e) => startDrag(e, sec.name, {
+							kind: "all",
+							text: (sec.text ?? "").startsWith("<") || !sec.text ? "" : sec.text,
+							custom: false
+						}),
+						onDragEnd: endDrag
+					}, [(0, react.createElement)("div", { style: s.rowBody }, [(0, react.createElement)("div", { style: s.rowTitle }, (0, react.createElement)("span", { style: s.code }, sec.name)), (0, react.createElement)("div", { style: s.preview }, String(sec.text ?? "").slice(0, 140) || t("dynamic"))])]))
+				])
 			]);
 		}
-		function InjectForm({ onAdd, t }) {
+		/** 注入新段表单：阶段部分内联形态，阶段锁定为所在部分。 */
+		function InjectForm({ onAdd, lockedPhase, t }) {
 			const [name, setName] = (0, react.useState)("");
-			const [order, setOrder] = (0, react.useState)("120");
 			const [text, setText] = (0, react.useState)("");
 			const submit = () => {
 				if (!name.trim()) return;
-				onAdd(name.trim(), Number(order) || 120, text);
+				onAdd(name.trim(), text);
 				setName("");
 				setText("");
-				setOrder("120");
 			};
-			return (0, react.createElement)("div", {}, [(0, react.createElement)("div", { style: s.injectRow }, [
+			const phaseLabel = lockedPhase === "bootstrap" ? t("phaseStageGuide") : lockedPhase === "compaction" ? t("phaseStageControlled") : t("phaseStageResident");
+			return (0, react.createElement)("div", { style: s.injectRow }, [
 				(0, react.createElement)("input", {
 					style: {
 						...s.input,
@@ -785,22 +1539,12 @@ window.__ModuleLoader__.load({
 					value: name,
 					onChange: (e) => setName(e.target.value)
 				}),
-				(0, react.createElement)("input", {
-					style: {
-						...s.input,
-						width: "12%"
-					},
-					type: "number",
-					placeholder: t("order"),
-					value: order,
-					onChange: (e) => setOrder(e.target.value)
-				}),
 				(0, react.createElement)("input", {
 					style: {
 						...s.input,
 						flex: 1
 					},
-					placeholder: t("text"),
+					placeholder: `${t("text")}（${phaseLabel}）`,
 					value: text,
 					onChange: (e) => setText(e.target.value)
 				}),
@@ -808,63 +1552,442 @@ window.__ModuleLoader__.load({
 					style: s.mini,
 					onClick: submit
 				}, t("add"))
-			])]);
+			]);
 		}
 		//#endregion
 		//#region src/client/ToolsTab.tsx
-		/** Tools tab: hide tools from the model catalog (blacklist only — check = hide). */
-		function ToolsTab({ cfg, inv, scope, t }) {
-			const tools = inv?.tools ?? [];
-			const exclude = cfg.tools?.exclude ?? [];
-			const hidden = (name) => exclude.includes(name);
-			const toggle = (name, currentlyHidden) => {
-				const next = exclude.slice();
-				if (currentlyHidden) {
-					const i = next.indexOf(name);
-					if (i >= 0) next.splice(i, 1);
-				} else next.push(name);
-				scope.set("tools", {
-					exclude: next,
-					include: []
+		/** 工具 Tab：四个部分 —— 引导期 / 常驻期 / 压缩受控期（三个阶段恒定显示，
+		*  预设没有某个阶段时该部分只是空的）+ 本系统全部工具（只读池）。
+		*  - 上三段每行 = 该阶段进入过滤的目录 ∪ 用户加回的工具（预过滤视图，隐藏后
+		*    仍在列表可反选），勾选 = 该阶段可见 / 隐藏。三份名单互不继承。
+		*  - 「加回」：被该阶段默认裁掉、但仍在当前预设注册表里的工具，可以拖进来重新
+		*    出现（写该阶段的 add 名单，装配时从注册表查回 schema 追加）。注册表里根本
+		*    没有的（别的预设独有）加不进来，界面明确说明。
+		*  - 全部工具 = 跨预设累积的注册表并集（只读池），每行标出该工具在三个阶段的
+		*    状态；它按定义比任何单一预设都大，所以里面的工具完全可能不在当前预设注册表。
+		*  - 拖动：全部 → 某阶段 = 让该工具在这一阶段出现；阶段 → 阶段 = 搬移（源阶段
+		*    隐藏 + 目标阶段显示）；上三段 → 全部 = 在该阶段隐藏它。
+		*  - 只有黑名单，没有白名单：每个动作只作用于被拖 / 被点的那一个工具，绝不
+		*    因为「拖进了一个工具」而把该阶段其它工具一起关掉。 */
+		function ToolsTab({ cfg, inv, phases, t, write }) {
+			const [dragFrom, setDragFrom] = (0, react.useState)(null);
+			const [draggedName, setDraggedName] = (0, react.useState)(null);
+			const [dropHint, setDropHint] = (0, react.useState)(null);
+			const [notice, setNotice] = (0, react.useState)(null);
+			const excludeOf = (key) => {
+				const tools = cfg.tools ?? {};
+				return (key === "bootstrap" ? tools.bootstrap?.exclude : key === "compaction" ? tools.compaction?.exclude : tools.exclude) ?? [];
+			};
+			const addOf = (key) => {
+				const tools = cfg.tools ?? {};
+				return (key === "bootstrap" ? tools.bootstrap?.add : key === "compaction" ? tools.compaction?.add : tools.add) ?? [];
+			};
+			const writeLists = (key, exclude, add) => {
+				write("tools", withPhaseAdd(withPhaseExclude(cfg.tools ?? {}, key, exclude), key, add));
+			};
+			const catalogOf = (key) => (phases?.[key]?.baseTools ?? []).map((tool) => tool.name);
+			const isInCatalog = (key, name) => catalogOf(key).includes(name);
+			const registry = (() => {
+				const list = PART_ORDER.map((key) => phases?.[key]?.registryTools).find((x) => Array.isArray(x) && x.length > 0) ?? [];
+				return new Set(list);
+			})();
+			const isInRegistry = (name) => registry.has(name);
+			const addToPhase = (key, name, hidden) => {
+				let exclude = excludeOf(key);
+				let add = addOf(key);
+				if (!isInCatalog(key, name) && !add.includes(name)) add = [...add, name];
+				exclude = hidden ? exclude.includes(name) ? exclude : [...exclude, name] : exclude.filter((x) => x !== name);
+				writeLists(key, exclude, add);
+			};
+			const rowsOf = (key) => {
+				const filter = { exclude: excludeOf(key) };
+				const catalog = (phases?.[key]?.baseTools ?? []).map((tool) => ({
+					name: tool.name,
+					description: tool.description ?? "",
+					hidden: isToolHidden(tool.name, filter),
+					added: false
+				}));
+				const names = new Set(catalog.map((row) => row.name));
+				const added = addOf(key).filter((name) => !names.has(name)).map((name) => ({
+					name,
+					description: "",
+					hidden: false,
+					added: true
+				}));
+				return [...catalog, ...added];
+			};
+			const toggleHide = (key, name, currentlyHidden) => {
+				if (currentlyHidden) addToPhase(key, name, false);
+				else {
+					let exclude = excludeOf(key);
+					let add = addOf(key);
+					if (add.includes(name)) add = add.filter((x) => x !== name);
+					else if (!exclude.includes(name)) exclude = [...exclude, name];
+					writeLists(key, exclude, add);
+				}
+				setNotice(null);
+			};
+			const phaseNoun = (key) => key === "bootstrap" ? t("phaseStageGuide") : key === "compaction" ? t("phaseStageControlled") : t("phaseStageResident");
+			const dropOnPart = (dest, name, from) => {
+				if (!isInCatalog(dest, name) && !isInRegistry(name)) {
+					setNotice({
+						kind: "warn",
+						text: t("toolNotInRegistry", { name })
+					});
+					return;
+				}
+				const copied = from.kind === "part" && from.key !== dest;
+				const hidden = copied ? excludeOf(from.key).includes(name) : false;
+				addToPhase(dest, name, hidden);
+				setNotice({
+					kind: "ok",
+					text: copied ? t("toolCopied", {
+						name,
+						from: phaseNoun(from.key),
+						to: phaseNoun(dest)
+					}) : isInCatalog(dest, name) ? t("toolShown", {
+						name,
+						to: phaseNoun(dest)
+					}) : t("toolAdded", {
+						name,
+						phase: phaseNoun(dest)
+					})
 				});
 			};
-			const setAll = (hideAll) => {
-				scope.set("tools", {
-					exclude: hideAll ? tools.map((tool) => tool.name) : [],
-					include: []
+			const dropOnAll = (name, from) => {
+				if (from.kind !== "part") return;
+				const key = from.key;
+				let exclude = excludeOf(key);
+				let add = addOf(key);
+				if (add.includes(name)) add = add.filter((x) => x !== name);
+				else if (!exclude.includes(name)) exclude = [...exclude, name];
+				writeLists(key, exclude, add);
+				setNotice({
+					kind: "ok",
+					text: t("toolHiddenIn", {
+						name,
+						to: phaseNoun(key)
+					})
 				});
 			};
-			return (0, react.createElement)("div", {}, [(0, react.createElement)("div", { style: s.bar }, [(0, react.createElement)("button", {
-				style: s.mini,
-				onClick: () => setAll(true)
-			}, t("selectAll")), (0, react.createElement)("button", {
-				style: s.mini,
-				onClick: () => setAll(false)
-			}, t("selectNone"))]), (0, react.createElement)("div", { style: s.list }, [tools.length === 0 ? (0, react.createElement)("div", { style: s.muted }, t("empty")) : null, tools.map((tool) => {
-				const isHidden = hidden(tool.name);
+			const visibleCount = (key) => {
+				const rows = rowsOf(key);
+				return `${rows.filter((row) => !row.hidden).length} / ${rows.length}`;
+			};
+			const partNoun = (key) => key === "bootstrap" ? t("toolsPartGuide") : key === "compaction" ? t("toolsPartControlled") : t("toolsPartResident");
+			const startDrag = (e, from, name) => {
+				setDragFrom(from);
+				setDraggedName(name);
+				e.dataTransfer.effectAllowed = "copy";
+				try {
+					e.dataTransfer.setData("text/plain", name);
+				} catch {}
+			};
+			const zoneDragOver = (e, zone) => {
+				if (!dragFrom || !draggedName) return;
+				const same = zone === "all" ? dragFrom.kind === "all" : dragFrom.kind === "part" && dragFrom.key === zone.replace("part:", "");
+				if (zone === "all" && dragFrom.kind === "all") {
+					e.preventDefault();
+					return;
+				}
+				if (same) return;
+				e.preventDefault();
+				e.dataTransfer.dropEffect = "copy";
+				setDropHint(zone);
+			};
+			const zoneDrop = (e, zone) => {
+				e.preventDefault();
+				if (dragFrom && draggedName) {
+					if (zone === "all") dropOnAll(draggedName, dragFrom);
+					else {
+						const dest = zone.replace("part:", "");
+						if (PART_ORDER.includes(dest)) dropOnPart(dest, draggedName, dragFrom);
+					}
+				}
+				setDragFrom(null);
+				setDraggedName(null);
+				setDropHint(null);
+			};
+			const endDrag = () => {
+				setDragFrom(null);
+				setDraggedName(null);
+				setDropHint(null);
+			};
+			const zoneStyle = (zone) => dropHint === zone ? {
+				outline: "2px dashed #7aa7ff",
+				outlineOffset: 2
+			} : void 0;
+			const allTools = (inv?.tools ?? []).map((tool) => ({
+				name: tool.name,
+				description: typeof tool === "string" ? "" : tool.description ?? ""
+			}));
+			const renderPhasePart = (key) => {
+				const rows = rowsOf(key);
+				const zoneKey = `part:${key}`;
 				return (0, react.createElement)("div", {
-					key: tool.name,
-					style: s.row
-				}, [(0, react.createElement)("label", { style: s.switchWrap }, [(0, react.createElement)("input", {
+					key: zoneKey,
+					style: s.injectBox,
+					onDragOver: (e) => zoneDragOver(e, zoneKey),
+					onDrop: (e) => zoneDrop(e, zoneKey),
+					...zoneStyle(zoneKey) ?? {}
+				}, [(0, react.createElement)("div", { style: s.rowTitle }, [
+					(0, react.createElement)("span", null, partNoun(key)),
+					(0, react.createElement)("span", { style: s.orderTag }, `${t("phaseVisible")} ${visibleCount(key)}`),
+					rows.length === 0 ? (0, react.createElement)("span", { style: s.muted }, t("dragHint")) : null
+				]), (0, react.createElement)("div", { style: s.toolWrap }, rows.map((row) => (0, react.createElement)("span", {
+					key: row.name,
+					style: {
+						...s.toolChip,
+						cursor: "move",
+						display: "inline-flex",
+						alignItems: "center",
+						gap: 4
+					},
+					title: row.description.slice(0, 120),
+					draggable: true,
+					onDragStart: (e) => startDrag(e, {
+						kind: "part",
+						key
+					}, row.name),
+					onDragEnd: endDrag
+				}, [(0, react.createElement)("input", {
 					type: "checkbox",
-					checked: isHidden,
-					onChange: () => toggle(tool.name, isHidden)
-				}), (0, react.createElement)("span", { style: isHidden ? s.badgeBlocked : s.badgeOk }, isHidden ? t("hiddenOn") : t("hiddenOff"))]), (0, react.createElement)("div", { style: s.rowBody }, [(0, react.createElement)("div", { style: s.rowTitle }, (0, react.createElement)("span", { style: s.code }, tool.name)), (0, react.createElement)("div", { style: s.preview }, String(tool.description ?? "").slice(0, 140))])]);
-			})])]);
+					checked: !row.hidden,
+					onChange: () => toggleHide(key, row.name, row.hidden),
+					style: {
+						margin: 0,
+						cursor: "pointer"
+					}
+				}), (0, react.createElement)("span", { style: row.hidden ? s.badgeBlocked : s.badgeOk }, row.name)])))]);
+			};
+			return (0, react.createElement)("div", {}, [
+				(0, react.createElement)("div", { style: s.muted }, t("toolsFourHint")),
+				notice ? (0, react.createElement)("div", { style: notice.kind === "ok" ? s.noticeOk : s.noticeWarn }, notice.text) : null,
+				PART_ORDER.map(renderPhasePart),
+				(0, react.createElement)("div", {
+					style: s.injectBox,
+					onDragOver: (e) => zoneDragOver(e, "all"),
+					onDrop: (e) => zoneDrop(e, "all"),
+					...zoneStyle("all") ?? {}
+				}, [
+					(0, react.createElement)("div", { style: s.rowTitle }, [t("allToolsTitle"), (0, react.createElement)("span", { style: s.orderTag }, `${allTools.length}`)]),
+					allTools.length === 0 ? (0, react.createElement)("div", { style: s.muted }, t("empty")) : null,
+					(0, react.createElement)("div", { style: s.toolWrap }, allTools.map((tool) => (0, react.createElement)("span", {
+						key: tool.name,
+						style: {
+							...s.toolChip,
+							cursor: "copy"
+						},
+						title: tool.description.slice(0, 120),
+						draggable: true,
+						onDragStart: (e) => startDrag(e, { kind: "all" }, tool.name),
+						onDragEnd: endDrag
+					}, tool.name)))
+				])
+			]);
+		}
+		//#endregion
+		//#region src/client/preset-io.ts
+		/** 页面是否运行在 Tauri（v1 标记或 v2 桥）webview 内。 */
+		function isTauriEnv(win) {
+			if (win === null || win === void 0) return false;
+			const w = win;
+			return w.__TAURI_INTERNALS__ !== void 0 || w.__TAURI__ !== void 0;
+		}
+		/** 取可用的 Tauri v2 invoke 桥；不可用时返回 null。 */
+		function invokeOf(win) {
+			if (!isTauriEnv(win)) return null;
+			const internals = win.__TAURI_INTERNALS__;
+			return internals && typeof internals.invoke === "function" ? internals.invoke : null;
+		}
+		const JSON_FILTERS = [{
+			name: "JSON",
+			extensions: ["json"]
+		}];
+		/**
+		* 原生保存对话框 + 写文件。`cancelled` = 用户关闭了对话框（调用方绝不
+		* 得再回退到下载）；`unavailable` = 宿主无法提供 dialog/fs 插件（插件
+		* 缺失或被 ACL 拦截），调用方应当回退。
+		*/
+		async function tauriSaveText(invoke, defaultName, text) {
+			try {
+				const path = await invoke("plugin:dialog|save", {
+					defaultPath: defaultName,
+					filters: JSON_FILTERS
+				});
+				if (typeof path !== "string" || path === "") return { kind: "cancelled" };
+				await invoke("plugin:fs|write_text_file", {
+					path,
+					contents: text
+				});
+				return { kind: "saved" };
+			} catch {
+				return { kind: "unavailable" };
+			}
+		}
+		/** 原生打开对话框 + 读文件。`cancelled` = 用户关闭了对话框。 */
+		async function tauriOpenText(invoke) {
+			try {
+				const picked = await invoke("plugin:dialog|open", {
+					multiple: false,
+					directory: false,
+					filters: JSON_FILTERS
+				});
+				const path = Array.isArray(picked) ? picked[0] : picked;
+				if (typeof path !== "string" || path === "") return { kind: "cancelled" };
+				const text = await invoke("plugin:fs|read_text_file", { path });
+				if (typeof text !== "string") return { kind: "unavailable" };
+				return {
+					kind: "text",
+					text
+				};
+			} catch {
+				return { kind: "unavailable" };
+			}
+		}
+		/** Web 回退导出：Blob + object URL + <a download> + revoke。 */
+		function webDownload(target, filename, text) {
+			const blob = target.makeBlob(text);
+			const url = target.objectUrl(blob);
+			const anchor = target.makeAnchor();
+			anchor.href = url;
+			anchor.download = filename;
+			anchor.click();
+			target.revoke(url);
+		}
+		/** 把单个预设编码为导出文件的 JSON 格式（单对象格式）。`envBlocklist`
+		*  是全局环境变量黑名单的随行快照：导入端按并集并入（见 PresetsTab）。 */
+		function encodePresetExport(preset, envBlocklist) {
+			return JSON.stringify({
+				name: preset.name,
+				data: preset.data,
+				...Array.isArray(envBlocklist) ? { envBlocklist } : {}
+			}, null, 2);
+		}
+		/**
+		* 解析导出的预设文件：单个 { name, data } 对象或对象数组。空内容 /
+		* 非法 JSON 抛普通 Error，由调用方给出友好提示；条目级的过滤在
+		* addImportedPresets 里进行。
+		*/
+		function decodePresetExport(text) {
+			const trimmed = String(text).trim();
+			if (trimmed === "") throw new Error("EMPTY_EXPORT");
+			return JSON.parse(trimmed);
+		}
+		function browserDownloadTarget() {
+			const g = globalThis;
+			const doc = g.document;
+			const url = g.URL;
+			return {
+				makeAnchor: () => doc.createElement("a"),
+				makeBlob: (text) => new Blob([text], { type: "application/json" }),
+				objectUrl: (blob) => url.createObjectURL(blob),
+				revoke: (u) => url.revokeObjectURL(u)
+			};
+		}
+		/** 为当前 window 构建真实环境（在 Node 里调用也安全）。 */
+		function makeIoEnv(win) {
+			const invoke = invokeOf(win !== void 0 ? win : typeof window !== "undefined" ? window : void 0);
+			const tauri = invoke !== null;
+			return {
+				tauri,
+				saveText: (name, text) => tauri ? tauriSaveText(invoke, name, text) : Promise.resolve({ kind: "unavailable" }),
+				openText: () => tauri ? tauriOpenText(invoke) : Promise.resolve({ kind: "unavailable" }),
+				download: (name, text) => webDownload(browserDownloadTarget(), name, text)
+			};
+		}
+		/**
+		* 导出一个预设：宿主能提供原生对话框时走 tauri 保存（cancelled = 用户
+		* 拒绝，绝不回退下载）；否则走 Web 下载。
+		*/
+		async function exportPresetFile(preset, io, envBlocklist) {
+			const env = io ?? makeIoEnv();
+			try {
+				const text = encodePresetExport(preset, envBlocklist);
+				const filename = presetExportFilename(preset.name);
+				if (env.tauri) {
+					const out = await env.saveText(filename, text);
+					if (out.kind === "saved") return {
+						ok: true,
+						via: "tauri"
+					};
+					if (out.kind === "cancelled") return {
+						ok: false,
+						via: "tauri",
+						cancelled: true
+					};
+				}
+				env.download(filename, text);
+				return {
+					ok: true,
+					via: "browser"
+				};
+			} catch (e) {
+				return {
+					ok: false,
+					via: "browser",
+					message: e instanceof Error ? e.message : String(e)
+				};
+			}
+		}
+		/**
+		* 经原生 tauri 打开对话框导入一个预设；返回 `unavailable` 时由调用方
+		* 点击自己的隐藏文件输入（Web 回退）。
+		*/
+		async function importPresetFile(io) {
+			const env = io ?? makeIoEnv();
+			try {
+				if (env.tauri) {
+					const out = await env.openText();
+					if (out.kind === "text") return {
+						kind: "text",
+						text: out.text,
+						via: "tauri"
+					};
+					if (out.kind === "cancelled") return { kind: "cancelled" };
+				}
+			} catch {}
+			return { kind: "unavailable" };
 		}
 		//#endregion
 		//#region src/client/PresetsTab.tsx
-		/** Presets tab: save / apply / export / import complete customization snapshots. */
-		function PresetsTab({ cfg, inv, scope, t }) {
+		/** 配置 Tab：两种「预设」分开 ——
+		*  - 保存当前配置：本插件内的配置快照库（config.presets），可应用 / 导出 / 导入，
+		*    不会变成可选的 agent 预设；
+		*  - 存为 agent 预设：整体 fork 当前编辑目标的预设目录，并把当前定制写进它的
+		*    覆盖项，新预设随即出现在顶部的编辑目标选择器里。
+		*  导入导出经 preset-io 双端适配：Tauri 2 桌面走原生对话框，Web 走
+		*  下载 / 文件选择；成功 / 失败 / 取消都有面板内消息条提示。 */
+		function PresetsTab({ cfg, inv, phases, t, writePatch, writeGlobal, saveAsPreset, forkSource, onReset, envBlocklist }) {
 			const presets = cfg.presets ?? [];
 			const [name, setName] = (0, react.useState)("");
+			const [blockInput, setBlockInput] = (0, react.useState)("");
+			const [agentName, setAgentName] = (0, react.useState)("");
+			const [creating, setCreating] = (0, react.useState)(false);
+			const [notice, setNotice] = (0, react.useState)(null);
 			const fileRef = (0, react.useRef)(null);
-			const merged = mergeSections(inv, cfg, new Set(cfg.sections ?? []));
+			const noticeTimer = (0, react.useRef)(null);
+			(0, react.useEffect)(() => () => {
+				if (noticeTimer.current !== null) clearTimeout(noticeTimer.current);
+			}, []);
+			const show = (kind, text) => {
+				if (noticeTimer.current !== null) clearTimeout(noticeTimer.current);
+				setNotice({
+					kind,
+					text
+				});
+				noticeTimer.current = setTimeout(() => setNotice(null), 4e3);
+			};
+			const blockedNames = new Set(cfg.sections ?? []);
+			const assemblyNames = /* @__PURE__ */ new Set();
+			for (const key of PART_ORDER) for (const sec of phases?.[key]?.baseSections ?? []) assemblyNames.add(sec.name);
+			const mergedAll = mergeSections(inv, cfg, blockedNames);
+			const merged = assemblyNames.size === 0 ? mergedAll : mergedAll.filter((sec) => sec.source === "custom" || assemblyNames.has(sec.name));
 			const currentNames = new Set(merged.map((sec) => sec.name));
 			const saveCurrent = () => {
 				const presetName = name.trim() || `${t("preset")} ${presets.length + 1}`;
 				const data = buildPresetData(cfg, merged);
-				scope.set("presets", [...presets, {
+				writeGlobal("presets", [...presets, {
 					id: genId(),
 					name: presetName,
 					data
@@ -872,41 +1995,84 @@ window.__ModuleLoader__.load({
 				setName("");
 			};
 			const applyPreset = (preset) => {
-				const patch = applyPresetData(preset.data, cfg, currentNames);
-				scope.set("inject", patch.inject);
-				scope.set("replace", patch.replace);
-				scope.set("sections", patch.sections);
-				scope.set("tools", patch.tools);
-				scope.set("activePreset", preset.id);
+				writePatch(applyPresetData(preset.data, cfg, currentNames));
+				writeGlobal("activePreset", preset.id);
 			};
 			const deletePreset = (id) => {
 				const next = removePreset(presets, id, cfg.activePreset);
-				scope.set("presets", next.presets);
-				if (next.activeId === void 0 && cfg.activePreset === id) scope.unset("activePreset");
-			};
-			const exportPreset = (preset) => {
-				const blob = new Blob([JSON.stringify(serializePreset(preset), null, 2)], { type: "application/json" });
-				const url = URL.createObjectURL(blob);
-				const a = document.createElement("a");
-				a.href = url;
-				a.download = `${preset.name}.json`;
-				a.click();
-				URL.revokeObjectURL(url);
+				writeGlobal("presets", next.presets);
+				if (next.activeId === void 0 && cfg.activePreset === id) writeGlobal("activePreset", void 0);
+			};
+			const exportPreset = async (preset) => {
+				try {
+					const res = await exportPresetFile(preset, void 0, envBlocklist);
+					if (res.ok) show("ok", t("exportOk"));
+					else if (res.cancelled) show("ok", t("exportCancel"));
+					else show("error", `${t("exportFail")}${res.message ? ": " + res.message : ""}`);
+				} catch (e) {
+					show("error", `${t("exportFail")}: ${e instanceof Error ? e.message : String(e)}`);
+				}
+			};
+			const importParsed = (text) => {
+				try {
+					const parsed = decodePresetExport(text);
+					const next = addImportedPresets(presets, parsed, genId);
+					const added = next.length - presets.length;
+					const fresh = (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && Array.isArray(parsed.envBlocklist) ? (parsed.envBlocklist ?? []).filter((e) => typeof e === "string") : []).filter((e) => !envBlocklist.includes(e));
+					if (fresh.length > 0) writeGlobal("envBlocklist", [...envBlocklist, ...fresh]);
+					const mergedNote = fresh.length > 0 ? t("importBlockMerge", { count: fresh.length }) : "";
+					if (added <= 0) show("ok", t("importNone") + mergedNote);
+					else {
+						writeGlobal("presets", next);
+						show("ok", `${t("importOk")} (+${added})${mergedNote}`);
+					}
+				} catch (e) {
+					show("error", `${t("importFail")}: ${e instanceof Error ? e.message : String(e)}`);
+				}
+			};
+			const importPreset = async () => {
+				try {
+					const res = await importPresetFile();
+					if (res.kind === "text") {
+						importParsed(res.text);
+						return;
+					}
+					if (res.kind === "cancelled") {
+						show("ok", t("importCancel"));
+						return;
+					}
+					fileRef.current?.click();
+				} catch (e) {
+					show("error", `${t("importFail")}: ${e instanceof Error ? e.message : String(e)}`);
+				}
 			};
 			const onImportFile = (e) => {
 				const file = e.target.files?.[0];
+				e.target.value = "";
 				if (!file) return;
 				const reader = new FileReader();
-				reader.onload = () => {
-					try {
-						const parsed = JSON.parse(String(reader.result));
-						scope.set("presets", addImportedPresets(presets, parsed, genId));
-					} catch {}
-				};
+				reader.onload = () => importParsed(String(reader.result));
+				reader.onerror = () => show("error", t("importFail"));
 				reader.readAsText(file);
-				e.target.value = "";
+			};
+			const createAgentPreset = async () => {
+				const trimmed = agentName.trim();
+				if (trimmed.length === 0 || creating) return;
+				setCreating(true);
+				if (await saveAsPreset(trimmed)) setAgentName("");
+				setCreating(false);
+			};
+			const removeBlockEntry = (entry) => {
+				writeGlobal("envBlocklist", envBlocklist.filter((e) => e !== entry));
+			};
+			const addBlockEntry = () => {
+				const entry = blockInput.trim();
+				setBlockInput("");
+				if (entry === "" || envBlocklist.includes(entry)) return;
+				writeGlobal("envBlocklist", [...envBlocklist, entry]);
 			};
 			return (0, react.createElement)("div", { style: s.list }, [
+				notice ? (0, react.createElement)("div", { style: notice.kind === "ok" ? s.noticeOk : s.error }, notice.text) : null,
 				(0, react.createElement)("div", { style: s.injectBox }, [(0, react.createElement)("div", { style: s.rowTitle }, t("savePreset")), (0, react.createElement)("div", { style: s.injectRow }, [(0, react.createElement)("input", {
 					style: {
 						...s.input,
@@ -919,9 +2085,30 @@ window.__ModuleLoader__.load({
 					style: s.mini,
 					onClick: saveCurrent
 				}, t("save"))])]),
+				(0, react.createElement)("div", { style: s.injectBox }, [
+					(0, react.createElement)("div", { style: s.rowTitle }, t("saveAsPresetCard")),
+					(0, react.createElement)("div", { style: s.muted }, t("saveAsPresetHint", { name: forkSource ?? t("forkSourceDefault") })),
+					(0, react.createElement)("div", { style: s.injectRow }, [(0, react.createElement)("input", {
+						style: {
+							...s.input,
+							flex: 1
+						},
+						placeholder: t("agentPresetName"),
+						value: agentName,
+						onChange: (e) => setAgentName(e.target.value)
+					}), (0, react.createElement)("button", {
+						style: s.mini,
+						disabled: creating || agentName.trim().length === 0,
+						onClick: () => {
+							createAgentPreset();
+						}
+					}, t("saveAsPreset"))])
+				]),
 				(0, react.createElement)("div", { style: s.injectBox }, [(0, react.createElement)("div", { style: s.rowTitle }, t("importPreset")), (0, react.createElement)("div", { style: s.injectRow }, [(0, react.createElement)("button", {
 					style: s.mini,
-					onClick: () => fileRef.current?.click()
+					onClick: () => {
+						importPreset();
+					}
 				}, t("import")), (0, react.createElement)("input", {
 					ref: fileRef,
 					type: "file",
@@ -929,6 +2116,79 @@ window.__ModuleLoader__.load({
 					style: { display: "none" },
 					onChange: onImportFile
 				})])]),
+				(0, react.createElement)("div", { style: s.injectBox }, [
+					(0, react.createElement)("div", { style: s.rowTitle }, t("forceTitle")),
+					(0, react.createElement)("div", { style: s.muted }, t("forceHint")),
+					(0, react.createElement)("div", { style: s.injectRow }, [(0, react.createElement)("label", { style: s.switchWrap }, [(0, react.createElement)("input", {
+						type: "checkbox",
+						checked: cfg.forceSections !== false,
+						onChange: (e) => writeGlobal("forceSections", e.target.checked)
+					}), (0, react.createElement)("span", { style: cfg.forceSections !== false ? s.badgeOk : s.badgeBlocked }, cfg.forceSections !== false ? t("forceOn") : t("forceOff"))])])
+				]),
+				(0, react.createElement)("div", { style: s.injectBox }, [
+					(0, react.createElement)("div", { style: s.rowTitle }, t("envBlockTitle")),
+					(0, react.createElement)("div", { style: s.muted }, t("envBlockHint")),
+					(0, react.createElement)("div", { style: {
+						...s.toolWrap,
+						marginTop: 6
+					} }, envBlocklist.map((entry) => (0, react.createElement)("span", {
+						key: entry,
+						style: {
+							...s.toolChip,
+							display: "inline-flex",
+							alignItems: "center",
+							gap: 4
+						}
+					}, [entry, (0, react.createElement)("span", {
+						style: { cursor: "pointer" },
+						title: t("delete"),
+						onClick: () => removeBlockEntry(entry)
+					}, "×")]))),
+					envBlocklist.length === 0 ? (0, react.createElement)("div", { style: s.muted }, t("envBlockEmpty")) : null,
+					(0, react.createElement)("div", { style: {
+						...s.injectRow,
+						marginTop: 6
+					} }, [(0, react.createElement)("input", {
+						style: {
+							...s.input,
+							flex: 1
+						},
+						placeholder: t("envBlockAdd"),
+						value: blockInput,
+						onChange: (e) => setBlockInput(e.target.value)
+					}), (0, react.createElement)("button", {
+						style: s.mini,
+						disabled: blockInput.trim() === "",
+						onClick: addBlockEntry
+					}, t("envBlockAddAction"))]),
+					(0, react.createElement)("details", { style: { marginTop: 6 } }, [
+						(0, react.createElement)("summary", { style: {
+							...s.muted,
+							cursor: "pointer"
+						} }, `${t("envVarsTitle")} (${inv?.variables?.length ?? 0})`),
+						(0, react.createElement)("div", { style: {
+							...s.muted,
+							marginTop: 4
+						} }, t("envVarsHint")),
+						(0, react.createElement)("div", { style: {
+							...s.toolWrap,
+							marginTop: 4
+						} }, (inv?.variables ?? []).map((name) => (0, react.createElement)("span", {
+							key: name,
+							style: s.toolChip
+						}, `{{${name}}}`)))
+					])
+				]),
+				(0, react.createElement)("div", { style: s.injectBox }, [
+					(0, react.createElement)("div", { style: s.rowTitle }, t("resetTitle")),
+					(0, react.createElement)("div", { style: s.muted }, t("resetHint")),
+					(0, react.createElement)("div", { style: s.injectRow }, [(0, react.createElement)("button", {
+						style: s.mini,
+						onClick: () => {
+							if (window.confirm(t("resetConfirm"))) onReset();
+						}
+					}, t("resetAction"))])
+				]),
 				presets.length === 0 ? (0, react.createElement)("div", { style: s.muted }, t("empty")) : null,
 				presets.map((preset) => {
 					const active = cfg.activePreset === preset.id;
@@ -943,7 +2203,9 @@ window.__ModuleLoader__.load({
 						}, t("apply")),
 						(0, react.createElement)("button", {
 							style: s.mini,
-							onClick: () => exportPreset(preset)
+							onClick: () => {
+								exportPreset(preset);
+							}
 						}, t("export")),
 						(0, react.createElement)("button", {
 							style: s.mini,
@@ -953,15 +2215,12 @@ window.__ModuleLoader__.load({
 				})
 			]);
 		}
-		function genId() {
-			return "p_" + Date.now().toString(36) + Math.random().toString(36).slice(2, 7);
-		}
 		//#endregion
 		//#region src/client/PreviewTools.tsx
-		/** Tools preview: read-only whitelist-style list of the tools the current
-		*  preset will inject (the FINAL model-visible catalog after include/exclude).
-		*  A tool being listed means it is visible — there is no "blocked" state here.
-		*  This view never edits the blacklist/whitelist config. */
+		/** 工具预览：当前定制（黑名单过滤之后）最终对模型可见的工具目录，
+		*  只读、清单式呈现：列出即代表模型看得见 —— 这里没有「已屏蔽」状态。
+		*  本视图绝不修改黑名单配置。 */
+		/** 把字符串形态的条目补全为 { name, description: '' }。 */
 		function norm(tool) {
 			return typeof tool === "string" ? {
 				name: tool,
@@ -980,71 +2239,85 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region src/client/PreviewTab.tsx
-		/** Preview tab: two read-only sub-tabs — the FINAL assembled system prompt
-		*  after every plugin's filter, and the tools the current preset will inject
-		*  (whitelist-style, after include/exclude). Neither view edits config. */
-		const PREVIEW_URL = "/api/prompt-customizer/preview";
-		function PreviewTab({ scope, t, active, refreshId }) {
+		/** 预览 Tab：两个只读子视图 —— 所有插件过滤后的最终装配系统提示词，
+		*  以及当前定制（黑名单过滤之后）将注入的工具目录视图。
+		*  两个视图都不修改配置。预览目标跟随面板顶部的编辑目标（`target`）；
+		*  数据直接来自 Panel 并行拉取的三阶段装配（`phases`）—— 与提示词/
+		*  工具 Tab 同源（同一份 base + post 视图），杜绝三个视图数据不一致。
+		*  阶段按钮恒为引导期 / 常驻期 / 压缩受控期三个（与另两个 Tab 同源同形）。 */
+		function PreviewTab({ t, active, refreshId, target, version, phases }) {
 			const [sub, setSub] = (0, react.useState)("prompt");
-			const [data, setData] = (0, react.useState)(null);
-			const [error, setError] = (0, react.useState)(null);
-			const inFlight = (0, react.useRef)(false);
-			const load = () => {
-				if (inFlight.current) return;
-				inFlight.current = true;
-				setData(null);
-				fetch(`${PREVIEW_URL}?t=${Date.now()}`).then((r) => r.json()).then((body) => {
-					if (body && body.ok === false) throw new Error(body.error ?? "preview failed");
-					setData(body);
-					setError(null);
-				}).catch((e) => setError(String(e instanceof Error ? e.message : e))).finally(() => {
-					inFlight.current = false;
-				});
-			};
-			(0, react.useEffect)(load, []);
-			(0, react.useEffect)(() => scope.subscribe(load), [scope]);
-			(0, react.useEffect)(() => {
-				if (active) load();
-			}, [active, refreshId]);
+			const [phase, setPhase] = (0, react.useState)("bootstrap");
+			const data = phases?.[phase] ?? null;
+			const lossNote = data === null || data === void 0 ? null : data.takenOverBy !== void 0 ? t("sectionsTakenOver", { name: data.takenOverBy }) : data.lostSections !== void 0 ? t("sectionsLost", {
+				emitted: data.lostSections.emitted,
+				survived: data.lostSections.survived
+			}) : null;
+			const stageLabel = (p) => p === "bootstrap" ? t("phaseStageGuide") : p === "compaction" ? t("phaseStageControlled") : t("phaseStageResident");
 			return (0, react.createElement)("div", { style: s.list }, [
-				(0, react.createElement)("div", { style: s.bar }, [(0, react.createElement)("button", {
-					style: sub === "prompt" ? s.tabActive : s.tab,
-					onClick: () => setSub("prompt")
-				}, t("previewPrompt")), (0, react.createElement)("button", {
-					style: sub === "tools" ? s.tabActive : s.tab,
-					onClick: () => setSub("tools")
-				}, t("previewTools"))]),
-				error ? (0, react.createElement)("div", { style: s.error }, String(error)) : null,
-				data === null && !error ? (0, react.createElement)("div", { style: s.muted }, t("loading")) : null,
-				sub === "prompt" ? data ? [(0, react.createElement)("div", { style: s.rowTitle }, [(0, react.createElement)("span", { style: s.muted }, t("previewHint")), (0, react.createElement)("span", { style: s.orderTag }, `${data.sections.length} ${t("previewSections")}`)]), (0, react.createElement)("pre", { style: s.previewText }, data.text || t("empty"))] : null : data ? (0, react.createElement)(PreviewTools, {
+				(0, react.createElement)("div", { style: s.bar }, [
+					(0, react.createElement)("button", {
+						style: sub === "prompt" ? s.tabActive : s.tab,
+						onClick: () => setSub("prompt")
+					}, t("previewPrompt")),
+					(0, react.createElement)("button", {
+						style: sub === "tools" ? s.tabActive : s.tab,
+						onClick: () => setSub("tools")
+					}, t("previewTools")),
+					(0, react.createElement)("div", { style: {
+						marginLeft: "auto",
+						display: "flex",
+						gap: 4
+					} }, PART_ORDER.map((key) => (0, react.createElement)("button", {
+						key,
+						style: phase === key ? s.tabActive : s.tab,
+						onClick: () => setPhase(key)
+					}, stageLabel(key))))
+				]),
+				lossNote !== null ? (0, react.createElement)("div", { style: s.noticeWarn }, lossNote) : null,
+				data !== null && data.scopeResolved === false ? (0, react.createElement)("div", { style: s.noticeWarn }, t("scopeFallback")) : null,
+				data !== null && data.degraded === true ? (0, react.createElement)("div", { style: s.noticeWarn }, t("previewDegraded")) : null,
+				phases === null ? (0, react.createElement)("div", { style: s.muted }, t("loading")) : null,
+				phases !== null && data === null ? (0, react.createElement)("div", { style: s.error }, t("previewFail")) : null,
+				sub === "prompt" ? data ? [(0, react.createElement)("div", { style: s.rowTitle }, [(0, react.createElement)("span", { style: s.muted }, t("previewHint")), (0, react.createElement)("span", { style: s.orderTag }, `${data.sections.length} ${t("previewSections")}`)]), (0, react.createElement)("pre", { style: s.previewText }, data.text || t("empty"))] : null : data ? [(0, react.createElement)("div", { style: s.rowTitle }, [(0, react.createElement)("span", { style: s.muted }, t("previewToolsHint")), (0, react.createElement)("span", { style: s.orderTag }, `${data.tools.length} / ${data.registryTotal ?? "?"} ${t("previewToolsCount")}`)]), (0, react.createElement)(PreviewTools, {
 					tools: data.tools,
 					t
-				}) : null
+				})] : null
 			]);
 		}
 		//#endregion
 		//#region src/client/index.ts
 		/**
-		* dsh-prompt-customizer — browser half (TypeScript source).
+		* dsh-prompt-customizer — 浏览器端（TypeScript 源码）。
 		*
-		* Registers a "提示词定制" settings section (sidebar entry) and a plugin
-		* settings card. The panel fetches the effective section / tool inventory
-		* from the host `/api/prompt-customizer/inventory` and lets the user block,
-		* replace, inject prompt sections and hide tools. All writes go through the
-		* bound settings scope (`prompt-customizer` namespace) and apply live.
+		* 注册一个「提示词定制」设置分区（侧边栏入口）及插件设置卡片。面板从宿主
+		* 的 `/api/prompt-customizer/inventory` 拉取当前生效的段 / 工具清单，让用户
+		* 屏蔽、替换、注入提示词段并隐藏工具。所有写入都走绑定的设置作用域
+		* （`prompt-customizer` 命名空间），实时生效。
 		*
-		* Built by tsdown into the __ModuleLoader__ factory bundle at client/client.js;
-		* the only external is the loader module table's react entry.
+		* 由 tsdown 打包为 client/client.js（__ModuleLoader__ factory bundle）；
+		* 唯一的外部依赖是 loader 模块表中的 react 入口。
 		*/
 		const NS = "prompt-customizer";
 		const INVENTORY_URL = "/api/prompt-customizer/inventory";
+		const CONFIG_SET_URL = "/api/prompt-customizer/config/set";
+		const CONFIG_UNSET_URL = "/api/prompt-customizer/config/unset";
+		const CONFIG_APPLY_URL = "/api/prompt-customizer/config/apply";
+		const CONFIG_RESET_URL = "/api/prompt-customizer/config/reset";
+		const PRESETS_CREATE_URL = "/api/prompt-customizer/presets";
+		const PREVIEW_URL = "/api/prompt-customizer/preview";
+		/** 三套名义装配的共享布局：顺序固定，refresh 按此并行拉取。 */
+		const VIEW_KEYS = [
+			"bootstrap",
+			"compaction",
+			"active"
+		];
 		const name = "prompt-customizer";
 		const inject = ["slots", "locale"];
 		function apply(ctx) {
 			ctx.effect(() => ctx.locale.register(NS, DICT), "prompt-customizer: locale");
 			const t = ctx.locale.bind(NS);
-			ctx.inject(["settingsScope"], (scoped) => {
-				const scope = scoped.settingsScope.bind({ namespace: NS });
+			ctx.inject(["slots"], (scoped) => {
 				scoped.slots.inject("settings.section", () => scoped.slots.register({
 					name: "settings.section",
 					id: "prompt-customizer",
@@ -1052,81 +2325,275 @@ window.__ModuleLoader__.load({
 					label: () => t("nav"),
 					locale: NS,
 					inject: () => ({ t })
-				}, () => (0, react.createElement)(Panel, {
-					scope,
-					t
-				})));
+				}, () => (0, react.createElement)(Panel, { t })));
 			});
 		}
-		function Panel({ scope, t }) {
-			const [snap, setSnap] = (0, react.useState)(() => scope.getSnapshot());
+		function Panel({ t }) {
+			const [cfg, setCfg] = (0, react.useState)(null);
 			const [inv, setInv] = (0, react.useState)(null);
+			const [phases, setPhases] = (0, react.useState)(null);
+			const [agentPresets, setAgentPresets] = (0, react.useState)([]);
 			const [tab, setTab] = (0, react.useState)("sections");
 			const [error, setError] = (0, react.useState)(null);
 			const [refreshId, setRefreshId] = (0, react.useState)(0);
-			(0, react.useEffect)(() => scope.subscribe(() => setSnap(scope.getSnapshot())), [scope]);
+			const [target, setTarget] = (0, react.useState)(void 0);
+			const [version, setVersion] = (0, react.useState)(0);
+			const [draft, setDraft] = (0, react.useState)(null);
+			const [saving, setSaving] = (0, react.useState)(false);
+			const [flash, setFlash] = (0, react.useState)(null);
+			const [flashKind, setFlashKind] = (0, react.useState)("ok");
+			const flashTimer = (0, react.useRef)(null);
+			const load = () => {
+				fetch(`/api/prompt-customizer/config?t=${Date.now()}`).then((r) => r.json()).then((body) => {
+					if (body?.ok !== true) throw new Error(body?.error ?? "config failed");
+					setCfg(body.config);
+					setError(null);
+				}).catch((e) => setError(String(e instanceof Error ? e.message : e)));
+			};
+			(0, react.useEffect)(load, []);
 			const refresh = () => {
-				fetch(INVENTORY_URL).then((r) => r.json()).then((data) => {
-					setInv(data);
+				const qs = target ? `?scope=${encodeURIComponent(target)}` : "";
+				const params = (phase) => `${qs}${qs ? "&" : "?"}phase=${phase}&t=${Date.now()}`;
+				const grab = (phase) => fetch(PREVIEW_URL + params(phase)).then((r) => r.json()).then((body) => body?.ok === false ? null : body).catch(() => null);
+				Promise.all([...VIEW_KEYS.map(grab), fetch(INVENTORY_URL).then((r) => r.json())]).then(([boot, comp, act, inventoryData]) => {
+					setPhases({
+						bootstrap: boot,
+						compaction: comp,
+						active: act
+					});
+					setInv(inventoryData);
 					setError(null);
 					setRefreshId((n) => n + 1);
 				}).catch((e) => setError(String(e instanceof Error ? e.message : e)));
 			};
-			(0, react.useEffect)(refresh, []);
-			if (snap.status !== "ready" && snap.value === void 0) return (0, react.createElement)("div", { style: s.muted }, t("loading"));
-			const cfg = snap.value && typeof snap.value === "object" ? snap.value : {
-				sections: [],
-				replace: {},
-				inject: [],
-				tools: {
-					exclude: [],
-					include: []
+			(0, react.useEffect)(refresh, [target, version]);
+			const fetchPresets = () => {
+				fetch(`/api/prompt-customizer/agent-presets?t=${Date.now()}`).then((r) => r.json()).then((body) => setAgentPresets(Array.isArray(body?.presets) ? body.presets : [])).catch(() => setAgentPresets([]));
+			};
+			(0, react.useEffect)(() => {
+				fetchPresets();
+			}, []);
+			if (cfg === null) return (0, react.createElement)("div", { style: s.muted }, t("loading"));
+			const showFlash = (text, kind = "ok") => {
+				if (flashTimer.current !== null) clearTimeout(flashTimer.current);
+				setFlash(text);
+				setFlashKind(kind);
+				flashTimer.current = setTimeout(() => setFlash(null), 3200);
+			};
+			const base = editView(cfg, target);
+			const view = draft ? {
+				...base,
+				sections: draft.sections ?? base.sections,
+				sectionsBootstrap: draft.sectionsBootstrap ?? base.sectionsBootstrap,
+				sectionsCompaction: draft.sectionsCompaction ?? base.sectionsCompaction,
+				replace: draft.replace ?? base.replace,
+				inject: draft.inject ?? base.inject,
+				tools: draft.tools ?? base.tools
+			} : base;
+			const writeField = (field, value) => {
+				fetch(value === void 0 ? CONFIG_UNSET_URL : CONFIG_SET_URL, {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({
+						field,
+						value
+					})
+				}).then((r) => r.json()).then((body) => {
+					if (body?.ok !== true) throw new Error(body?.error ?? "write failed");
+					setCfg(body.config);
+					setError(null);
+					setVersion((n) => n + 1);
+				}).catch((e) => setError(String(e instanceof Error ? e.message : e)));
+			};
+			const edit = (field, value) => {
+				setDraft((d) => ({
+					...d ?? { dirty: false },
+					[field]: value,
+					dirty: true
+				}));
+			};
+			const save = () => {
+				if (draft === null || saving) return;
+				const EDITED_FIELDS = [
+					"sections",
+					"sectionsBootstrap",
+					"sectionsCompaction",
+					"replace",
+					"inject",
+					"tools"
+				];
+				const patch = {};
+				for (const field of EDITED_FIELDS) if (Object.hasOwn(draft, field)) patch[field] = draft[field];
+				setSaving(true);
+				fetch(CONFIG_APPLY_URL, {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({
+						target,
+						patch
+					})
+				}).then((r) => r.json()).then((body) => {
+					if (body?.ok !== true) throw new Error(body?.error ?? "save failed");
+					setCfg(body.config);
+					setDraft(null);
+					setError(null);
+					setVersion((n) => n + 1);
+					showFlash(t("saveOk"));
+				}).catch((e) => setError(`${t("saveFail")}: ${e instanceof Error ? e.message : String(e)}`)).finally(() => setSaving(false));
+			};
+			const writePatch = (patch) => {
+				fetch(CONFIG_APPLY_URL, {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({
+						target,
+						patch
+					})
+				}).then((r) => r.json()).then((body) => {
+					if (body?.ok !== true) throw new Error(body?.error ?? "apply failed");
+					setCfg(body.config);
+					setError(null);
+					setVersion((n) => n + 1);
+				}).catch((e) => setError(String(e instanceof Error ? e.message : e)));
+			};
+			const writeGlobal = writeField;
+			const writeGlobalField = writeField;
+			const resetAll = () => {
+				fetch(CONFIG_RESET_URL, {
+					method: "POST",
+					headers: { "content-type": "application/json" }
+				}).then((r) => r.json()).then((body) => {
+					if (body?.ok !== true) throw new Error(body?.error ?? "reset failed");
+					setCfg(body.config);
+					setDraft(null);
+					setError(null);
+					setVersion((n) => n + 1);
+					showFlash(t("resetOk"));
+				}).catch((e) => setError(`${t("resetFail")}: ${e instanceof Error ? e.message : String(e)}`));
+			};
+			const switchTab = (next) => {
+				if ((tab === "sections" || tab === "tools") && (next === "presets" || next === "preview")) {
+					if (draft?.dirty && !window.confirm(t("discardConfirm"))) return;
+					setDraft(null);
 				}
+				setTab(next);
+			};
+			const switchTarget = (next) => {
+				if (draft?.dirty && !window.confirm(t("discardConfirm"))) return;
+				setDraft(null);
+				setTarget(next);
+			};
+			const saveAsPreset = (presetName) => {
+				const name = presetName.trim();
+				if (name.length === 0) return Promise.resolve(false);
+				return fetch(PRESETS_CREATE_URL, {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({
+						name,
+						from: target,
+						config: {
+							sections: view.sections ?? [],
+							sectionsBootstrap: view.sectionsBootstrap ?? [],
+							sectionsCompaction: view.sectionsCompaction ?? [],
+							replace: view.replace ?? {},
+							inject: view.inject ?? [],
+							tools: view.tools ?? {}
+						}
+					})
+				}).then((r) => r.json()).then((body) => {
+					if (body?.ok !== true) throw new Error(body?.error ?? t("saveAsPresetFail"));
+					load();
+					fetchPresets();
+					showFlash(t("saveAsPresetOk"), "ok");
+					return true;
+				}).catch((e) => {
+					showFlash(`${t("saveAsPresetFail")}：${String(e instanceof Error ? e.message : e)}`, "err");
+					return false;
+				});
 			};
 			return (0, react.createElement)("div", { style: s.root }, [
 				(0, react.createElement)("div", { style: s.bar }, [
 					(0, react.createElement)("button", {
 						style: tab === "sections" ? s.tabActive : s.tab,
-						onClick: () => setTab("sections")
+						onClick: () => switchTab("sections")
 					}, t("tabsSections")),
 					(0, react.createElement)("button", {
 						style: tab === "tools" ? s.tabActive : s.tab,
-						onClick: () => setTab("tools")
+						onClick: () => switchTab("tools")
 					}, t("tabsTools")),
 					(0, react.createElement)("button", {
 						style: tab === "presets" ? s.tabActive : s.tab,
-						onClick: () => setTab("presets")
+						onClick: () => switchTab("presets")
 					}, t("tabsPresets")),
 					(0, react.createElement)("button", {
 						style: tab === "preview" ? s.tabActive : s.tab,
-						onClick: () => setTab("preview")
+						onClick: () => switchTab("preview")
 					}, t("tabsPreview")),
+					(0, react.createElement)("select", {
+						style: {
+							...s.input,
+							marginLeft: 6
+						},
+						value: target ?? "",
+						onChange: (e) => switchTarget(e.target.value || void 0),
+						title: t("targetHint")
+					}, [(0, react.createElement)("option", {
+						value: "",
+						style: s.option
+					}, t("targetGlobal")), ...agentPresets.map((p) => (0, react.createElement)("option", {
+						key: p.id,
+						value: p.id,
+						style: s.option
+					}, `${p.name}${p.broken ? ` (${t("broken")})` : ""}`))]),
+					(0, react.createElement)("button", {
+						style: draft?.dirty ? s.saveBtnDirty : s.saveBtn,
+						disabled: !draft?.dirty || saving,
+						onClick: save
+					}, t("save")),
 					(0, react.createElement)("button", {
 						style: s.refresh,
 						onClick: refresh
 					}, t("refresh"))
 				]),
 				error ? (0, react.createElement)("div", { style: s.error }, String(error)) : null,
+				flash ? (0, react.createElement)("div", { style: flashKind === "err" ? s.error : s.noticeOk }, flash) : null,
+				target && agentPresets.find((p) => p.id === target)?.broken ? (0, react.createElement)("div", { style: s.error }, t("brokenPreset")) : null,
+				inv?.scopeResolved === false ? (0, react.createElement)("div", { style: s.noticeWarn }, t("scopeFallback")) : null,
 				tab === "sections" ? (0, react.createElement)(SectionsTab, {
-					cfg,
+					cfg: view,
 					inv,
-					scope,
-					t
+					phases,
+					target,
+					globalSections: cfg.sections,
+					ownedSections: target ? cfg.overrides?.[target]?.sections : void 0,
+					t,
+					write: edit,
+					writeGlobalField
 				}) : tab === "tools" ? (0, react.createElement)(ToolsTab, {
-					cfg,
+					cfg: view,
 					inv,
-					scope,
-					t
+					phases,
+					t,
+					write: edit
 				}) : tab === "presets" ? (0, react.createElement)(PresetsTab, {
-					cfg,
+					cfg: view,
 					inv,
-					scope,
-					t
+					phases,
+					t,
+					writePatch,
+					writeGlobal,
+					saveAsPreset,
+					forkSource: target ? agentPresets.find((p) => p.id === target)?.name ?? target : void 0,
+					onReset: resetAll,
+					envBlocklist: cfg.envBlocklist ?? []
 				}) : (0, react.createElement)(PreviewTab, {
-					scope,
 					t,
 					active: tab === "preview",
-					refreshId
+					refreshId,
+					target,
+					version,
+					phases
 				})
 			]);
 		}