@lmzhen/dsh-evolution-ui 0.0.0 → 0.32.1

package/lib/client.js

@@ -0,0 +1,3656 @@
+window.__ModuleLoader__.load({
+	id: "@lmzhen/dsh-evolution-ui",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react = require("react");
+		let _deepseek_ai_dsh_evolution_merge_ui_client = require("@lmzhen/dsh-evolution-merge-ui/client");
+		//#region ../evolution-client-kit/src/generated/routes.generated.ts
+		/**
+		* Every family host path, generated from evolution-core's HOST_ROUTES (the ONE declaration).
+		* A browser half cannot import the host package at runtime (client bundles keep @deepseek-ai/*
+		* external), so the table is mirrored here mechanically; a rename in core regenerates all three
+		* client copies, and the generator's --check makes a stale copy red.
+		*/
+		const ROUTES = {
+			approval: {
+				pending: "/api/dsh-evolution/approval/pending",
+				preview: "/api/dsh-evolution/approval/preview",
+				approve: "/api/dsh-evolution/approval/approve",
+				reject: "/api/dsh-evolution/approval/reject"
+			},
+			"skill-history": {
+				skills: "/api/dsh-evolution/skill-history/skills",
+				versions: "/api/dsh-evolution/skill-history/versions",
+				diff: "/api/dsh-evolution/skill-history/versions/diff",
+				body: "/api/dsh-evolution/skill-history/versions/body",
+				undo: "/api/dsh-evolution/skill-history/undo",
+				health: "/api/dsh-evolution/skill-history/health"
+			},
+			"skill-health": { rows: "/api/dsh-evolution/skill-health/rows" },
+			merge: {
+				view: "/api/dsh-evolution/merge/view",
+				rows: "/api/dsh-evolution/merge/rows",
+				run: "/api/dsh-evolution/merge/run",
+				runs: "/api/dsh-evolution/merge/runs",
+				body: "/api/dsh-evolution/merge/body",
+				history: "/api/dsh-evolution/merge/history"
+			},
+			diagnostics: { view: "/api/dsh-evolution/diagnostics" }
+		};
+		//#endregion
+		//#region ../evolution-client-kit/src/generated/route-client.generated.ts
+		/** Classify a non-2xx status: 401/403/404 keep their own kind, everything else is a server answer. */
+		function classify(status) {
+			if (status === 401) return {
+				kind: "unauthenticated",
+				status: 401
+			};
+			if (status === 403) return {
+				kind: "forbidden",
+				status: 403
+			};
+			if (status === 404) return {
+				kind: "unmounted",
+				status: 404
+			};
+			return {
+				kind: "server",
+				status
+			};
+		}
+		/**
+		* One request, no retries and no body parsing for the platform's admission answers.
+		* @param doFetch - the fetch in use (the browser's, or a spec's stub).
+		* @param path - the exact route path from the generated ROUTES table.
+		* @param init - standard RequestInit.
+		* @returns the data, or the classified failure (network/parse failures read as 'server').
+		*/
+		async function requestJson(doFetch, path, init) {
+			let response;
+			try {
+				response = await doFetch(path, init);
+			} catch (error) {
+				return {
+					ok: false,
+					failure: {
+						kind: "server",
+						status: 0,
+						detail: error instanceof Error ? error.message : String(error)
+					}
+				};
+			}
+			if (!response.ok) return {
+				ok: false,
+				failure: classify(response.status)
+			};
+			let body;
+			try {
+				body = await response.json();
+			} catch {
+				return {
+					ok: false,
+					failure: {
+						kind: "server",
+						status: response.status
+					}
+				};
+			}
+			if (typeof body === "object" && body !== null) {
+				const record = body;
+				if (record.ok === true) return {
+					ok: true,
+					data: record.data
+				};
+				const nested = record.error;
+				const errorRecord = typeof nested === "object" && nested !== null ? nested : void 0;
+				const code = typeof record.code === "string" && record.code !== "" ? record.code : typeof errorRecord?.code === "string" ? errorRecord.code : void 0;
+				const message = typeof record.message === "string" && record.message !== "" ? record.message : typeof errorRecord?.message === "string" ? errorRecord.message : void 0;
+				if (record.ok === false && code !== void 0 && message !== void 0 && message !== "") return {
+					ok: false,
+					failure: {
+						kind: "refused",
+						code,
+						message
+					}
+				};
+			}
+			return {
+				ok: false,
+				failure: {
+					kind: "server",
+					status: response.status
+				}
+			};
+		}
+		/** The one-sentence rendering legacy callers attach to a classified failure. */
+		function failureMessage(failure) {
+			switch (failure.kind) {
+				case "refused": return failure.message;
+				case "server": return failure.status === 0 ? failure.detail === void 0 || failure.detail === "" ? "网络错误：无法连接宿主" : failure.detail : "HTTP " + String(failure.status);
+				case "unauthenticated": return "HTTP 401";
+				case "forbidden": return "HTTP 403";
+				case "unmounted": return "HTTP 404";
+			}
+		}
+		//#endregion
+		//#region src/panels/settings/api.ts
+		/**
+		* The approval routes this bundle calls, and the ONE place a request is made.
+		*
+		* Structural types on purpose: the browser half cannot import the host package at runtime, so the row
+		* shape is declared by what the route hands over. Every answer — including a refusal — is parsed the
+		* same way, because a refusal is a business answer the card shows as a sentence, not a transport error.
+		* @module @lmzhen/dsh-evolution-ui/panels/settings/client/api
+		*/
+		/**
+		* Build the approval face over one fetch implementation.
+		* @param doFetch - the fetch to use (the platform's global in the browser, a fake in a spec).
+		* @returns the three calls the pending card makes.
+		*/
+		function createApprovalApi(doFetch) {
+			const post = async (path, id) => await requestJson(doFetch, path, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({ id })
+			});
+			return {
+				pending: async (status) => await requestJson(doFetch, status === void 0 ? ROUTES.approval.pending : ROUTES.approval.pending + "?status=" + status),
+				approve: async (id) => await post(ROUTES.approval.approve, id),
+				reject: async (id) => await post(ROUTES.approval.reject, id),
+				preview: async (id) => await requestJson(doFetch, ROUTES.approval.preview + "?id=" + encodeURIComponent(id))
+			};
+		}
+		//#endregion
+		//#region src/panels/settings/generated-params.ts
+		const CLIENT_PARAM_SECTIONS = [
+			{
+				namespace: "evolution-approval",
+				seatKey: "evolution-approval",
+				fields: [
+					{
+						id: "evolution-approval.enabled",
+						group: "deployment",
+						doc: "Master approval switch: run the approval pipeline for foreground writes.",
+						label: "启用批准流水线",
+						hint: "关闭后前台写入不再经批准。",
+						control: "switch",
+						unit: "",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "evolution-approval.pendingTtlMs",
+						group: "deployment",
+						doc: "How long a staged write may wait before it expires: expired writes are closed as rejected and are NEVER executed; 0 (the default) means the window never expires.",
+						label: "待批过期时间",
+						hint: "一条待批写入最多等多久：超时就按「拒绝」关掉（不会执行，写效果不会落地）；0 = 永不过期（默认）。",
+						control: "number",
+						unit: "毫秒",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "approvalConfirm",
+						group: "write-caps",
+						doc: "What the confirmation before an APPROVE does: write straight through, ask first, or treat an unanswered prompt as a cancel. The same three words skillWriteConfirm uses for a skill write.",
+						label: "批准前先确认",
+						hint: "点「批准」时要不要再确认一次：直接执行 / 先确认 / 等待超时即取消。默认直接执行（不打断批量批准）。",
+						control: "select",
+						unit: "",
+						values: [
+							"auto",
+							"ask",
+							"timeout"
+						],
+						valueLabels: [
+							"直接执行",
+							"先确认",
+							"等待超时即取消"
+						],
+						atLeast: ""
+					}
+				]
+			},
+			{
+				namespace: "evolution-commands",
+				seatKey: "evolution-commands",
+				fields: [{
+					id: "evolution-commands.maintainHandoffOnSettle",
+					group: "deployment",
+					doc: "Hand the maintenance report to the model automatically once a scan settles successfully (the same injection as maintain handoff); off by default — enabling it costs one extra model call per successful run.",
+					label: "扫描完成后自动交接",
+					hint: "维护扫描成功结束后，自动把报告交给模型（等同 maintain handoff）；默认关闭，每次成功扫描会多花一次模型调用。",
+					control: "switch",
+					unit: "",
+					values: [],
+					valueLabels: [],
+					atLeast: ""
+				}]
+			},
+			{
+				namespace: "evolution-curator",
+				seatKey: "evolution-curator",
+				fields: [
+					{
+						id: "curatorIntervalHours",
+						group: "curator",
+						doc: "Minimum hours between deterministic curation passes.",
+						label: "自动整理间隔",
+						hint: "两次自动整理之间至少间隔多少小时。",
+						control: "number",
+						unit: "小时",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "staleAfterDays",
+						group: "curator",
+						doc: "Inactive days before a skill counts as stale.",
+						label: "多久没用算过时",
+						hint: "技能连续多少天没被用到就算过时。",
+						control: "number",
+						unit: "天",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "archiveAfterDays",
+						group: "curator",
+						doc: "Inactive days before a stale skill is archived (must be >= staleAfterDays).",
+						label: "过时后归档",
+						hint: "过时技能再过多少天移入归档（不能小于上一项）。",
+						control: "number",
+						unit: "天",
+						values: [],
+						valueLabels: [],
+						atLeast: "staleAfterDays"
+					},
+					{
+						id: "minIdleHours",
+						group: "curator",
+						doc: "Idle hours required before an automatic curation pass runs.",
+						label: "最少空闲时长",
+						hint: "你至少多少小时没用，才运行自动整理。",
+						control: "number",
+						unit: "小时",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "minIdleFailOpen",
+						group: "curator",
+						doc: "Let the idle gate open when the activity probe is unavailable.",
+						label: "检测不到活动也运行",
+						hint: "无法判断你是否空闲时，仍然运行自动整理。",
+						control: "switch",
+						unit: "",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "llmReview",
+						group: "curator",
+						doc: "Enable the LLM nomination pass on top of the deterministic lifecycle.",
+						label: "用模型挑选",
+						hint: "在固定规则之外，再用模型挑一遍候选项。",
+						control: "switch",
+						unit: "",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "curatorReviewMaxTokens",
+						group: "curator",
+						doc: "Token budget of the curator LLM review.",
+						label: "模型处理上限",
+						hint: "每次用模型挑选时最多消耗多少 token。",
+						control: "number",
+						unit: "token",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "curatorReviewTimeoutMs",
+						group: "curator",
+						doc: "Wall-clock bound of the curator LLM review.",
+						label: "模型处理超时",
+						hint: "一次模型挑选最长允许运行多久。",
+						control: "number",
+						unit: "毫秒",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "healthSoftBodyChars",
+						group: "curator",
+						doc: "Body character line the health view judges against.",
+						label: "正文长度参考值",
+						hint: "技能正文超过多少字符算偏长（只用于健康提示）。",
+						control: "number",
+						unit: "字符",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "healthStampDensityPerKb",
+						group: "curator",
+						doc: "Stamp density per KB that flags log-like content in a body.",
+						label: "日志化判定阈值",
+						hint: "每 KB 出现多少个时间标记，就判为「像日志」。",
+						control: "number",
+						unit: "处/KB",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "healthChurnMinPatches",
+						group: "curator",
+						doc: "Patches without a read that flag a write-ghost skill.",
+						label: "只写不读判定次数",
+						hint: "连续多少次改动都没有被读取，就判为「只写不读」。",
+						control: "number",
+						unit: "处",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					}
+				]
+			},
+			{
+				namespace: "evolution-merge",
+				seatKey: "evolution-merge",
+				fields: [
+					{
+						id: "mergeApproval",
+						group: "merge",
+						doc: "Pause after round 1 and put the pair in the pending queue instead of authoring round 2 automatically.",
+						label: "合并审批",
+						hint: "开启后，第一轮判定完先停下、进入待批准清单；关闭则直接进入第二轮合并。",
+						control: "switch",
+						unit: "",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "mergeSkippedTtlDays",
+						group: "merge",
+						doc: "Days a skipped pair stays out of screening; 0 means it never expires.",
+						label: "无需合并保留天数",
+						hint: "判定无需合并的对，多少天内不再参与筛选；0 表示一直保留。",
+						control: "number",
+						unit: "天",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "mergeRunTimeoutMinutes",
+						group: "merge",
+						doc: "Wall-clock budget of one merge run; 0 means no limit.",
+						label: "单次运行上限",
+						hint: "一次合并运行最多持续多少分钟；0 表示不设上限。",
+						control: "number",
+						unit: "分钟",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					}
+				]
+			},
+			{
+				namespace: "evolution-review",
+				seatKey: "evolution-review",
+				fields: [
+					{
+						id: "reviewSkillInterval",
+						group: "review",
+						doc: "Tool calls between skill-review injections: a turn advances by its tool-call count (a turn with none counts as one), or by 1 when the turn itself used a skill.",
+						label: "技能检查间隔",
+						hint: "每累计多少次工具调用检查一次技能：一轮按该轮工具调用数累加（一轮没有工具调用也算 1 次），本轮本身用到技能则只算 1 次。",
+						control: "number",
+						unit: "次",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "reviewMemoryInterval",
+						group: "review",
+						doc: "Tool calls between memory-review injections: a turn advances by its tool-call count (a turn with none counts as one), or by 1 when the turn itself touched memory.",
+						label: "记忆检查间隔",
+						hint: "每累计多少次工具调用检查一次记忆：一轮按该轮工具调用数累加（一轮没有工具调用也算 1 次），本轮本身用到记忆则只算 1 次。",
+						control: "number",
+						unit: "次",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "skillReviewTrigger",
+						group: "review",
+						doc: "Which channel may inject a skill review (cadence, completion, both).",
+						label: "技能检查时机",
+						hint: "什么时候检查技能：按间隔／按任务完成／两者。",
+						control: "select",
+						unit: "",
+						values: [
+							"cadence",
+							"completion",
+							"both"
+						],
+						valueLabels: [
+							"按间隔",
+							"按任务完成",
+							"两者"
+						],
+						atLeast: ""
+					},
+					{
+						id: "skillReviewCompletionMinToolCalls",
+						group: "review",
+						doc: "Tool calls a task needs before the completion channel injects.",
+						label: "完成时的最少工具调用",
+						hint: "选「按任务完成」时，任务至少用了几次工具才检查。",
+						control: "number",
+						unit: "次",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "reviewEnabled",
+						group: "review",
+						doc: "Master switch for the review plugin.",
+						label: "启用自动检查",
+						hint: "关闭后不再自动回顾会话。",
+						control: "switch",
+						unit: "",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "reviewMode",
+						group: "review",
+						doc: "Run the review in the parent session (inject), on a subagent, or in a background branch.",
+						label: "运行位置",
+						hint: "在哪里运行检查：在当前会话里／交给子代理／后台分支。",
+						control: "select",
+						unit: "",
+						values: ["inject", "branch"],
+						valueLabels: ["在当前会话里", "后台分支"],
+						atLeast: ""
+					},
+					{
+						id: "reviewWakeInject",
+						group: "review",
+						doc: "Deliver the deferred review as a waking follow-up message.",
+						label: "延后结果发提醒",
+						hint: "会话空闲时，把延后的检查结果作为一条提醒发给你。",
+						control: "switch",
+						unit: "",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "reviewNotice",
+						group: "review",
+						doc: "Deliver result notices into the parent conversation.",
+						label: "结果通知",
+						hint: "关闭后检查结果不再写进对话；检查本身照常运行，结果留在审计记录里。",
+						control: "switch",
+						unit: "",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					}
+				]
+			},
+			{
+				namespace: "memory-files",
+				seatKey: "memory-files",
+				fields: [
+					{
+						id: "memoryChars",
+						group: "memory",
+						doc: "Character budget the memory store enforces for MEMORY.md.",
+						label: "记忆库上限",
+						hint: "长期记忆文件（MEMORY.md）最多多少字符。",
+						control: "number",
+						unit: "字符",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "userChars",
+						group: "memory",
+						doc: "Character budget the memory store enforces for USER.md.",
+						label: "用户画像上限",
+						hint: "用户画像文件（USER.md）最多多少字符。",
+						control: "number",
+						unit: "字符",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "addDatePrefix",
+						group: "memory",
+						doc: "Prefix stored memory entries with their date heading.",
+						label: "记忆条目加日期",
+						hint: "写入时在条目开头加上日期。",
+						control: "switch",
+						unit: "",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "maxConsolidationFailures",
+						group: "memory",
+						doc: "Consolidation failures one turn tolerates before the tool gives up.",
+						label: "合并失败重试",
+						hint: "合并记忆连续失败多少次后停止。",
+						control: "number",
+						unit: "次",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					}
+				]
+			},
+			{
+				namespace: "tool-memory",
+				seatKey: "tool-memory",
+				fields: [{
+					id: "entryPreviewChars",
+					group: "memory",
+					doc: "Characters of one memory entry shown in a tool result preview.",
+					label: "记忆预览长度",
+					hint: "列表里每条记忆最多显示多少字符。",
+					control: "number",
+					unit: "字符",
+					values: [],
+					valueLabels: [],
+					atLeast: ""
+				}]
+			},
+			{
+				namespace: "tool-skill-manage",
+				seatKey: "tool-skill-manage",
+				fields: [
+					{
+						id: "skillContentChars",
+						group: "write-caps",
+						doc: "Character cap on a SKILL.md body (tighten-only).",
+						label: "技能文件正文上限",
+						hint: "技能 Markdown 正文最多多少字符（只能调小）。",
+						control: "number",
+						unit: "字符",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "maxSkillFileBytes",
+						group: "write-caps",
+						doc: "Byte cap on one support file (tighten-only).",
+						label: "附带文件大小上限",
+						hint: "技能附带文件单个最大多少字节（只能调小）。",
+						control: "number",
+						unit: "字节",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "maxSkillNameLength",
+						group: "write-caps",
+						doc: "Character cap on a skill name (tighten-only).",
+						label: "技能名长度上限",
+						hint: "技能名最多多少字符（只能调小）。",
+						control: "number",
+						unit: "字符",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "maxDescriptionLength",
+						group: "write-caps",
+						doc: "Character cap on a skill description (tighten-only).",
+						label: "技能描述长度上限",
+						hint: "技能描述最多多少字符（只能调小）。",
+						control: "number",
+						unit: "字符",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "descriptionStrict",
+						group: "write-caps",
+						doc: "Refuse a description over the authoring bar instead of advising.",
+						label: "描述不合规即拒绝",
+						hint: "描述不符合要求时直接拒绝写入（默认只提醒）。",
+						control: "switch",
+						unit: "",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "strictCrossSource",
+						group: "write-caps",
+						doc: "Refuse writes whose catalog entry resolves outside the family.",
+						label: "引用外部内容即拒绝",
+						hint: "技能引用了本插件之外的文件时拒绝写入。",
+						control: "switch",
+						unit: "",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					},
+					{
+						id: "citationPolicy",
+						group: "write-caps",
+						doc: "Refuse a move that would leave a dangling reference, or verify it.",
+						label: "引用检查方式",
+						hint: "移动或合并技能时怎么处理引用：先检查／直接拒绝。",
+						control: "select",
+						unit: "",
+						values: ["verify", "refuse"],
+						valueLabels: ["先检查", "直接拒绝"],
+						atLeast: ""
+					},
+					{
+						id: "supportFileCharPolicy",
+						group: "write-caps",
+						doc: "Warn about an oversize support file, or refuse the write.",
+						label: "附带文件超限时",
+						hint: "附带文件超出上限时：只提醒／拒绝写入。",
+						control: "select",
+						unit: "",
+						values: ["report", "enforce"],
+						valueLabels: ["只提醒", "拒绝写入"],
+						atLeast: ""
+					},
+					{
+						id: "skillWriteConfirm",
+						group: "write-caps",
+						doc: "What the one confirmation before a create or a bare delete does: write straight through, wait for an answer, or cancel the write when nobody answers within the timeout.",
+						label: "写入前是否确认",
+						hint: "新建或删除技能前要不要问你：直接写入／一直等你回答／超时未答就取消这次写入。",
+						control: "select",
+						unit: "",
+						values: [
+							"auto",
+							"ask",
+							"timeout"
+						],
+						valueLabels: [
+							"不弹窗直接写入",
+							"一直等待回答",
+							"超时自动取消"
+						],
+						atLeast: ""
+					},
+					{
+						id: "skillWriteConfirmTimeoutSeconds",
+						group: "write-caps",
+						doc: "Seconds the confirmation waits for an answer in timeout mode before the write is cancelled.",
+						label: "确认等待秒数",
+						hint: "选「超时自动取消」时，等多少秒没人回答就取消这次写入。",
+						control: "number",
+						unit: "秒",
+						values: [],
+						valueLabels: [],
+						atLeast: ""
+					}
+				]
+			}
+		];
+		/** Every (bundle, row) pair the Plugins page can open a configuration page for. */
+		const CLIENT_ROW_SEATS = [
+			{
+				bundle: "@lmzhen/dsh-evolution-all",
+				rows: [
+					"evolution-approval",
+					"evolution-commands",
+					"evolution-curator",
+					"evolution-merge",
+					"evolution-review",
+					"memory-files",
+					"tool-memory",
+					"tool-skill-manage"
+				]
+			},
+			{
+				bundle: "@lmzhen/dsh-evolution-host",
+				rows: [
+					"evolution-approval",
+					"evolution-commands",
+					"evolution-curator",
+					"evolution-merge",
+					"evolution-review",
+					"memory-files"
+				]
+			},
+			{
+				bundle: "@lmzhen/dsh-evolution-preset",
+				rows: [
+					"evolution-approval",
+					"evolution-commands",
+					"evolution-curator",
+					"evolution-merge",
+					"evolution-review",
+					"memory-files",
+					"tool-memory",
+					"tool-skill-manage"
+				]
+			}
+		];
+		//#endregion
+		//#region ../evolution-client-kit/src/generated/states.generated.ts
+		/** A neutral/ warn/ fail block; a fail block is role=alert so assistive tech announces it. */
+		function Block(props) {
+			const tone = props.tone ?? "neutral";
+			return (0, react.createElement)("div", {
+				"data-tone": tone,
+				...tone === "fail" ? { role: "alert" } : {}
+			}, props.title === void 0 ? null : (0, react.createElement)("div", { "data-tone-title": tone }, props.title), props.children);
+		}
+		/** One classified failure as a reader-facing sentence. */
+		function failureText(failure, t) {
+			switch (failure.kind) {
+				case "unauthenticated": return t("failureUnauthorized");
+				case "forbidden": return t("failureForbidden");
+				case "unmounted": return t("failureUnmounted");
+				case "server": return failure.status === 0 ? t("failureServer") : t("failureServer") + " (HTTP " + String(failure.status) + ")";
+				case "refused": return failure.message;
+			}
+		}
+		/** The failed-state block: sentence + (when the surface exists but is unreachable) the command fallback. */
+		function FailureBlock(props) {
+			const hint = props.fallback === void 0 ? null : (0, react.createElement)("div", { "data-tone-hint": "true" }, props.t("fallbackHint", { command: props.fallback.command }));
+			return Block({
+				tone: "fail",
+				title: failureText(props.failure, props.t),
+				children: hint
+			});
+		}
+		//#endregion
+		//#region src/panels/settings/pending-state.ts
+		/** The state a card mounts in: still loading, nothing in flight, nothing said yet. */
+		const INITIAL_PENDING_STATE = {
+			view: { kind: "loading" },
+			busy: [],
+			notice: null,
+			open: null,
+			preview: null
+		};
+		/** Open one row's preview: the row is now the open one and its answer is on the way. */
+		function expanded(state, id) {
+			return {
+				...state,
+				open: id,
+				preview: { kind: "loading" }
+			};
+		}
+		/** Close whatever preview is open. */
+		function collapsed(state) {
+			return {
+				...state,
+				open: null,
+				preview: null
+			};
+		}
+		/**
+		* A preview answer arrived. An answer for a row the reader has already left is DROPPED: it would
+		* otherwise paint one row's diff under another row's heading.
+		*/
+		function previewArrived(state, id, view) {
+			return state.open === id ? {
+				...state,
+				preview: view
+			} : state;
+		}
+		/** The first load, or a refresh after a decision: back to loading, keeping no stale rows. */
+		function loading(state) {
+			return {
+				...state,
+				view: { kind: "loading" }
+			};
+		}
+		/**
+		* A list arrived. An empty list is its OWN state — the reader is told the window is clear rather than
+		* being shown the same line a slow answer shows.
+		*/
+		function loaded(state, rows) {
+			return {
+				...state,
+				view: rows.length === 0 ? { kind: "empty" } : {
+					kind: "ready",
+					rows
+				}
+			};
+		}
+		/** The list could not be read: the classified failure stays on screen next to a retry control. */
+		function failed(state, failure) {
+			return {
+				...state,
+				view: {
+					kind: "failed",
+					failure
+				}
+			};
+		}
+		/** Mark one record as having an action in flight (its buttons are disabled until it ends). */
+		function beginAction(state, id) {
+			return state.busy.includes(id) ? state : {
+				...state,
+				busy: [...state.busy, id]
+			};
+		}
+		/** The action ended, whatever it answered. */
+		function endAction(state, id) {
+			return {
+				...state,
+				busy: state.busy.filter((candidate) => candidate !== id)
+			};
+		}
+		/** One refusal or failure line under the list; `null` clears it (a later success does). */
+		function noticed(state, message) {
+			return {
+				...state,
+				notice: message
+			};
+		}
+		//#endregion
+		//#region src/panels/settings/PendingCard.ts
+		/**
+		* The "writes awaiting approval" card: the staged write window, with the two decisions on each row.
+		*
+		* It is a card in the SAME section and wears the SAME shell as the parameter cards (header with title,
+		* count and chevron; body of field blocks; a button row per block), so nothing here invents a second
+		* visual language. Two things differ on purpose: the data comes from the host's approval routes rather
+		* than the settings transport, and its three states are distinct — "reading", "nothing staged" and "the
+		* read failed" each say so in their own words (E7: merging the first two is what made an empty panel
+		* look like lost data).
+		*
+		* Every decision re-reads the window instead of predicting the outcome: the host owns the state, and a
+		* refusal is shown with the host's own sentence.
+		* @module @lmzhen/dsh-evolution-ui/panels/settings/client/PendingCard
+		*/
+		/**
+		* U-6: the registry's gate word, read out of a section's user layer. ONE definition, exported so the
+		* mapping itself is judgeable: the entry does the wiring, this does the reading. Anything that is not
+		* one of the two explicit words falls back to the shipped default (`auto`) — a document written by a
+		* future version must not silently turn the confirmation ON, and a typo must not turn it off. The
+		* independent review flagged that this reader had no case at all (P2-11).
+		*/
+		function confirmModeFrom(user) {
+			const value = typeof user === "object" && user !== null ? user.approvalConfirm : void 0;
+			return value === "ask" || value === "timeout" ? value : "auto";
+		}
+		/** Which word one age bucket gets; an unknown bucket falls back to the count form. */
+		const AGE_KEYS = Object.freeze({
+			now: "approvalAgeNow",
+			minutes: "approvalAgeMinutes",
+			hours: "approvalAgeHours",
+			days: "approvalAgeDays",
+			months: "approvalAgeMonths"
+		});
+		/** Which word one staged kind gets. */
+		const KIND_KEYS = Object.freeze({
+			memory: "approvalKindMemory",
+			skill: "approvalKindSkill",
+			capability: "approvalKindCapability"
+		});
+		/**
+		* Render the pending window.
+		* @param props - the copy seat and the host calls.
+		* @returns the card.
+		*/
+		function PendingCard(props) {
+			const { t, api } = props;
+			const translate = (key, values) => t(key, values);
+			const confirmMode = props.confirmMode?.() ?? "auto";
+			const [armed, setArmed] = (0, react.useState)(null);
+			const [state, setState] = (0, react.useState)(INITIAL_PENDING_STATE);
+			const [open, setOpen] = (0, react.useState)(true);
+			const latest = (0, react.useRef)(state);
+			const apply = (next) => {
+				const value = next(latest.current);
+				latest.current = value;
+				setState(value);
+			};
+			/**
+			* Read the window the card is about: the writes WAITING and the writes RUNNING.
+			*
+			* T4-05/A47: the route has always taken `?status=` — the CLI asks for both lists — but this card
+			* asked for neither, so a record whose approve died between the claim and the decision showed as
+			* "nothing is waiting for a decision" while `/evolution pending` and doctor listed it. The two
+			* answers are ordered the way the CLI orders them (waiting first); either one failing fails the
+			* read, because a half-list would read as a complete window.
+			*/
+			const readTicket = (0, react.useRef)(0);
+			const load = async () => {
+				apply(loading);
+				const ticket = readTicket.current + 1;
+				readTicket.current = ticket;
+				const [waiting, running] = await Promise.all([api.pending(), api.pending("executing")]);
+				if (readTicket.current !== ticket) return;
+				if (!waiting.ok) {
+					apply((current) => failed(current, waiting.failure));
+					return;
+				}
+				if (!running.ok) {
+					apply((current) => failed(current, running.failure));
+					return;
+				}
+				apply((current) => loaded(current, [...waiting.data, ...running.data]));
+			};
+			(0, react.useEffect)(() => {
+				load();
+				const onFocus = () => {
+					load();
+				};
+				window.addEventListener("focus", onFocus);
+				return () => {
+					window.removeEventListener("focus", onFocus);
+				};
+			}, []);
+			const decide = (id, action) => {
+				apply((current) => beginAction(current, id));
+				(async () => {
+					const answer = action === "approve" ? await api.approve(id) : await api.reject(id);
+					if (!answer.ok) {
+						apply((current) => noticed(endAction(current, id), failureText(answer.failure, translate)));
+						return;
+					}
+					apply((current) => noticed(endAction(current, id), null));
+					await load();
+				})();
+			};
+			const age = (row) => {
+				const key = AGE_KEYS[row.age.unit];
+				if (key === void 0) return String(row.age.n);
+				return t(key, { n: row.age.n });
+			};
+			/** Ask the host what this record would store; the answer lands only if the row is still open. */
+			const loadPreview = async (id) => {
+				const answer = await api.preview(id);
+				const view = answer.ok ? answer.data.available ? {
+					kind: "ready",
+					answer: answer.data
+				} : {
+					kind: "unavailable",
+					reason: answer.data.reason
+				} : {
+					kind: "failed",
+					failure: answer.failure
+				};
+				apply((current) => previewArrived(current, id, view));
+			};
+			const togglePreview = (id) => {
+				if (state.open === id) {
+					apply(collapsed);
+					return;
+				}
+				apply((current) => expanded(current, id));
+				loadPreview(id);
+			};
+			/** The facts line, then the source view: the same shape the history panel's diff uses. */
+			const preview = (view) => {
+				if (view.kind === "loading") return (0, react.createElement)("p", {
+					className: "evolution-param-note",
+					role: "status"
+				}, t("approvalPreviewReading"));
+				if (view.kind === "failed") return (0, react.createElement)("p", {
+					className: "evolution-param-error",
+					role: "status"
+				}, failureText(view.failure, translate));
+				if (view.kind === "unavailable") return (0, react.createElement)("p", {
+					className: "evolution-param-error",
+					role: "status"
+				}, t("approvalPreviewNone") + view.reason);
+				const facts = [
+					(0, react.createElement)("span", {
+						className: "evolution-param-fact",
+						key: "added"
+					}, t("approvalDiffAdded", { n: view.answer.linesAdded })),
+					(0, react.createElement)("span", {
+						className: "evolution-param-fact",
+						key: "removed"
+					}, t("approvalDiffRemoved", { n: view.answer.linesRemoved })),
+					...view.answer.truncated ? [(0, react.createElement)("span", {
+						className: "evolution-param-fact",
+						key: "cut"
+					}, t("approvalDiffCut"))] : []
+				];
+				const lines = [];
+				for (const [hunkIndex, hunk] of view.answer.hunks.entries()) {
+					for (const [index, line] of hunk.oldText.split("\n").entries()) {
+						if (hunk.oldText === "" && line === "") continue;
+						lines.push((0, react.createElement)("div", {
+							key: "old-" + String(hunkIndex) + "-" + String(index),
+							className: "evolution-param-line-del"
+						}, "- " + line));
+					}
+					for (const [index, line] of hunk.newText.split("\n").entries()) {
+						if (hunk.newText === "" && line === "") continue;
+						lines.push((0, react.createElement)("div", {
+							key: "new-" + String(hunkIndex) + "-" + String(index),
+							className: "evolution-param-line-add"
+						}, "+ " + line));
+					}
+				}
+				return (0, react.createElement)("div", null, (0, react.createElement)("p", { className: "evolution-param-facts" }, ...facts), (0, react.createElement)("pre", { className: "evolution-param-diff" }, ...lines.length === 0 ? ["±"] : lines));
+			};
+			const row = (entry) => {
+				if (entry.status === "executing") return (0, react.createElement)("div", {
+					className: "evolution-param-field",
+					key: entry.id
+				}, (0, react.createElement)("div", { className: "evolution-param-label" }, (0, react.createElement)("span", { className: "evolution-param-source" }, t(KIND_KEYS[entry.kind])), (0, react.createElement)("span", { className: "evolution-param-value" }, entry.summary)), (0, react.createElement)("p", { className: "evolution-param-hint" }, age(entry)), (0, react.createElement)("p", {
+					className: "evolution-param-note",
+					role: "status"
+				}, t("approvalExecuting")), entry.claimedBy === void 0 ? null : (0, react.createElement)("p", { className: "evolution-param-hint" }, entry.claimedBy));
+				const busy = state.busy.includes(entry.id);
+				const button = (label, action, tone) => (0, react.createElement)("button", {
+					className: "evolution-param-button",
+					type: "button",
+					disabled: busy,
+					...tone === "primary" ? { "data-primary": "true" } : { "data-tone": tone },
+					onClick: () => {
+						if (action === "approve" && confirmMode === "ask" && armed !== entry.id) {
+							setArmed(entry.id);
+							return;
+						}
+						setArmed(null);
+						decide(entry.id, action);
+					}
+				}, busy ? t("approvalLoading") : t(label));
+				return (0, react.createElement)("div", {
+					className: "evolution-param-field",
+					key: entry.id
+				}, (0, react.createElement)("div", { className: "evolution-param-label" }, (0, react.createElement)("span", { className: "evolution-param-source" }, t(KIND_KEYS[entry.kind])), (0, react.createElement)("span", { className: "evolution-param-value" }, entry.summary)), (0, react.createElement)("p", { className: "evolution-param-hint" }, age(entry)), armed === entry.id ? (0, react.createElement)("p", {
+					className: "evolution-param-note",
+					role: "status"
+				}, (0, react.createElement)("span", { className: "evolution-param-value" }, t("approvalConfirmNamed", { n: entry.summary })), (0, react.createElement)("button", {
+					className: "evolution-param-button",
+					type: "button",
+					"data-confirm": "yes",
+					"data-primary": "true",
+					onClick: () => {
+						setArmed(null);
+						decide(entry.id, "approve");
+					}
+				}, t("approvalConfirmYes")), (0, react.createElement)("button", {
+					className: "evolution-param-button",
+					type: "button",
+					"data-tone": "ghost",
+					onClick: () => {
+						setArmed(null);
+					}
+				}, t("approvalConfirmNo"))) : null, (0, react.createElement)("div", { className: "evolution-param-actions" }, button("approvalApprove", "approve", "primary"), button("approvalReject", "reject", "outline"), (0, react.createElement)("button", {
+					className: "evolution-param-button",
+					type: "button",
+					"data-tone": "ghost",
+					onClick: () => {
+						togglePreview(entry.id);
+					}
+				}, state.open === entry.id ? t("approvalPreviewClose") : t("approvalPreview"))), state.open === entry.id && state.preview !== null ? preview(state.preview) : null);
+			};
+			const body = () => {
+				if (state.view.kind === "loading") return (0, react.createElement)("p", {
+					className: "evolution-param-note",
+					role: "status"
+				}, t("approvalLoading"));
+				if (state.view.kind === "empty") return (0, react.createElement)("p", {
+					className: "evolution-param-note",
+					role: "status"
+				}, t("approvalEmpty"));
+				if (state.view.kind === "failed") return (0, react.createElement)("div", { className: "evolution-param-actions" }, FailureBlock({
+					failure: state.view.failure,
+					t: translate,
+					fallback: props.fallback
+				}), (0, react.createElement)("button", {
+					className: "evolution-param-button",
+					type: "button",
+					onClick: () => {
+						load();
+					}
+				}, t("approvalRetry")));
+				return (0, react.createElement)("div", null, ...state.view.rows.map(row), state.notice === null ? null : (0, react.createElement)("p", {
+					className: "evolution-param-error",
+					role: "status"
+				}, state.notice));
+			};
+			const rows = state.view.kind === "ready" ? state.view.rows : [];
+			const waiting = rows.filter((entry) => entry.status !== "executing").length;
+			const running = rows.length - waiting;
+			return (0, react.createElement)("section", { className: "evolution-param-card" }, (0, react.createElement)("button", {
+				className: "evolution-param-head",
+				type: "button",
+				onClick: () => {
+					setOpen(!open);
+				},
+				"aria-expanded": open
+			}, (0, react.createElement)("span", { className: "evolution-param-card-title" }, t("approvalTitle")), waiting === 0 ? null : (0, react.createElement)("span", { className: "evolution-param-count" }, t("approvalCount", { n: waiting })), running === 0 ? null : (0, react.createElement)("span", { className: "evolution-param-count" }, t("approvalRunningCount", { n: running })), (0, react.createElement)("span", { className: "evolution-param-chevron" }, open ? "▲" : "▼")), open ? (0, react.createElement)("div", { className: "evolution-param-body" }, (0, react.createElement)("div", { className: "evolution-param-actions" }, (0, react.createElement)("button", {
+				className: "evolution-param-button",
+				type: "button",
+				onClick: () => {
+					load();
+				}
+			}, t("approvalRefresh"))), body()) : null);
+		}
+		//#endregion
+		//#region src/panels/settings/DiagnosticsCard.ts
+		/**
+		* The diagnostics card (W7 S7): the settings face of the SAME DiagnosticsView the CLI and the
+		* `/api/dsh-evolution/diagnostics` route answer.
+		*
+		* Read-only by construction: it fetches once on mount and only refetches on an explicit Refresh; a
+		* failed read renders the shared FailureBlock with the command-face fallback. The client owns no
+		* key list and no status vocabulary: it renders the host view's frozen runtime rows and leads with
+		* a plain-language summary. The view's documentation facts are a CLI/JSON concern and are
+		* deliberately NOT rendered here (0.27.2 real-machine feedback: a settings page is not a spec
+		* sheet; the runtime window is the whole reading).
+		* @module @lmzhen/dsh-evolution-ui/panels/settings/client/DiagnosticsCard
+		*/
+		/** Which word one status gets (the frozen W1 status set). */
+		const STATUS_KEYS = Object.freeze({
+			ok: "diagStatusOk",
+			warn: "diagStatusWarn",
+			fail: "diagStatusFail",
+			unknown: "diagStatusUnknown"
+		});
+		/** The summary word for a badge status (the same frozen set; ok has no count). */
+		const SUMMARY_KEYS = Object.freeze({
+			ok: "diagSummaryOk",
+			warn: "diagSummaryWarn",
+			fail: "diagSummaryFail",
+			unknown: "diagSummaryUnknown"
+		});
+		/** The one status the card leads with: fail > warn > unknown > ok. */
+		function summaryOf(rows) {
+			const count = (status) => rows.filter((row) => row.status === status).length;
+			for (const status of [
+				"fail",
+				"warn",
+				"unknown"
+			]) {
+				const n = count(status);
+				if (n > 0) return {
+					status,
+					count: n
+				};
+			}
+			return {
+				status: "ok",
+				count: 0
+			};
+		}
+		/**
+		* Render the card.
+		* @param props - the copy seat, the host call and the command fallback.
+		* @returns the card.
+		*/
+		function DiagnosticsCard(props) {
+			const { t, api } = props;
+			const translate = (key, values) => t(key, values);
+			const [state, setState] = (0, react.useState)({ phase: "loading" });
+			const [open, setOpen] = (0, react.useState)(true);
+			const ticket = (0, react.useRef)(0);
+			const read = (keepView) => {
+				const current = ticket.current + 1;
+				ticket.current = current;
+				if (!keepView) setState({ phase: "loading" });
+				api.view().then((answer) => {
+					if (ticket.current !== current) return;
+					setState(answer.ok ? {
+						phase: "ready",
+						view: answer.data
+					} : {
+						phase: "failed",
+						failure: answer.failure
+					});
+				});
+			};
+			(0, react.useEffect)(() => {
+				read(false);
+			}, []);
+			const refresh = () => {
+				read(true);
+			};
+			const summary = state.phase === "ready" ? summaryOf(state.view.runtime) : void 0;
+			const header = (0, react.createElement)("button", {
+				type: "button",
+				className: "evolution-param-head",
+				"aria-expanded": open ? "true" : "false",
+				onClick: () => {
+					setOpen(!open);
+				}
+			}, (0, react.createElement)("span", { className: "evolution-param-card-title" }, t("diagTitle")), summary === void 0 ? null : (0, react.createElement)("span", {
+				className: "evo-diag-badge",
+				"data-status": summary.status
+			}, t(SUMMARY_KEYS[summary.status], summary.count === 0 ? void 0 : { n: summary.count })), (0, react.createElement)("span", { className: "evolution-param-chevron" }, open ? "▲" : "▼"));
+			const runtime = (view) => view.runtime.length === 0 ? null : (0, react.createElement)("div", {}, (0, react.createElement)("h3", { className: "evolution-param-group" }, t("diagRuntimeTitle")), (0, react.createElement)("div", { className: "evo-diag-list" }, ...view.runtime.map((row) => (0, react.createElement)("div", {
+				key: "runtime-" + row.key,
+				className: "evo-diag-item",
+				"data-kind": "runtime",
+				"data-status": row.status
+			}, (0, react.createElement)("div", { className: "evo-diag-row-head" }, (0, react.createElement)("span", { className: "evo-diag-dot" }), (0, react.createElement)("span", { className: "evo-diag-label" }, row.label), (0, react.createElement)("span", { className: "evo-diag-status" }, t(STATUS_KEYS[row.status]))), row.detail === void 0 ? null : (0, react.createElement)("span", { className: "evo-diag-detail" }, row.detail), row.remedy === void 0 ? null : (0, react.createElement)("span", { className: "evo-diag-remedy" }, t("diagRemedy") + row.remedy)))));
+			const body = () => {
+				if (state.phase === "loading") return (0, react.createElement)("p", { className: "evolution-param-loading" }, t("stateLoading"));
+				if (state.phase === "failed") return FailureBlock({
+					failure: state.failure,
+					t: translate,
+					fallback: props.fallback
+				});
+				const view = state.view;
+				return (0, react.createElement)("div", {}, (0, react.createElement)("p", { className: "evolution-param-note" }, t("diagSubtitle")), (0, react.createElement)("div", { className: "evolution-param-actions" }, (0, react.createElement)("button", {
+					type: "button",
+					className: "evolution-param-button",
+					onClick: refresh,
+					"data-action": "diag-refresh"
+				}, t("diagRefresh"))), runtime(view), view.runtime.length === 0 ? (0, react.createElement)("p", { className: "evolution-param-note" }, t("diagNoRows")) : null);
+			};
+			return (0, react.createElement)("section", {
+				className: "evolution-param-card",
+				"data-card": "diagnostics"
+			}, header, open ? (0, react.createElement)("div", { className: "evolution-param-body" }, body()) : null);
+		}
+		//#endregion
+		//#region src/panels/settings/diagnostics-state.ts
+		/**
+		* The diagnostics card's data face (W7 S7): ONE request to `HOST_ROUTES.diagnostics.view` through the
+		* GENERATED route client, and the four-state answer the card renders.
+		*
+		* The Host route is the SAME `buildDoctorView` the CLI prints (W6/W8), so this client owns no facts
+		* and no computation — it only renders.
+		* @module @lmzhen/dsh-evolution-ui/panels/settings/client/diagnostics-state
+		*/
+		/**
+		* Build the diagnostics face over one fetch implementation.
+		* @param doFetch - the browser fetch, or a spec stub.
+		*/
+		function createDiagnosticsApi(doFetch = fetch) {
+			return { view: async () => await requestJson(doFetch, ROUTES.diagnostics.view, { headers: { accept: "application/json" } }) };
+		}
+		//#endregion
+		//#region ../evolution-client-kit/src/generated/fallbacks.generated.ts
+		/**
+		* The command-face fallback for every Host surface, generated from evolution-commands'
+		* COMMAND_FALLBACKS (the ONE home). When the platform's connection carrier is absent (E-325) the
+		* panels render this hint instead of a bare HTTP failure — same use case, command face.
+		*/
+		const FALLBACKS = {
+			approval: { command: "/evolution pending … /evolution approve <id> … /evolution reject <id> … /evolution release <id>" },
+			"skill-history": { command: "/evolution restore <name> [v]（查看：/evolution skills history <name>）" },
+			"skill-health": { command: "/evolution skills refresh（健康行：/evolution doctor）" },
+			merge: { command: "/evolution merge status / pending / approve <id> / report" },
+			diagnostics: {
+				command: "/evolution doctor",
+				platformCli: "dsh --json /evolution doctor"
+			}
+		};
+		//#endregion
+		//#region src/panels/settings/messages.ts
+		/**
+		* Copy for the evolution settings section and its parameter cards.
+		*
+		* The section is registered through the platform's locale seat (`ctx.locale`),
+		* which is the same route the other out-of-repo client plugins take. The earlier
+		* note in this package's README — that an outside package cannot bind the locale
+		* seat — is wrong: `locale.register(namespace, { zh, en })` is the documented
+		* call, and it is what makes the section title and its copy follow the UI
+		* language instead of shipping one hard-coded dictionary.
+		*/
+		/** Locale namespace this bundle registers. */
+		const NS$1 = "evolution-settings";
+		/** Chinese copy (the family's primary language). */
+		const zh$1 = {
+			title: "自进化",
+			subtitle: "待你决定的写入在最上面；下面按功能列出你能改的参数，没有列出的由安装时的配置决定。",
+			overridden: "已覆盖",
+			deployment: "默认",
+			loading: "正在读取设置…",
+			unavailable: "这个功能没有启动（对应的插件没有安装）",
+			seatMissing: "这个界面没有提供设置服务，参数只能看不能改",
+			projectionFailed: "这一块读设置时出错，已记入日志；其它参数不受影响",
+			readonly: "本次会话不允许写入设置（临时运行模式）",
+			apply: "保存",
+			reset: "恢复默认值",
+			empty: "这里没有可改项",
+			changed: "{n} 项已覆盖",
+			discard: "放弃修改",
+			saving: "保存中…",
+			resetting: "恢复中…",
+			writeTargetHost: "保存去向：宿主配置（对所有会话生效）",
+			invalidNumber: "需要一个数字",
+			invalidSelect: "不在允许的取值里",
+			invalidAtLeast: "不能小于同组的 {n}",
+			approvalConfirmNamed: "即将批准：{n}",
+			approvalConfirmYes: "确认批准",
+			approvalConfirmNo: "取消",
+			resetTo: "复位为 {value}",
+			refused: "这个值没有被接受（界面上保持原样）。想看原因：在对话里让它说明。",
+			resetRefused: "恢复默认值没有生效（这一行还是你的值）。想看原因：在对话里让它说明。",
+			cardReview: "会话回顾",
+			cardMemory: "长期记忆",
+			cardToolMemory: "记忆写入",
+			cardCurator: "技能整理",
+			cardSkills: "技能写入规则",
+			cardApproval: "写入审批",
+			cardCommands: "维护扫描",
+			cardMerge: "技能自动合并",
+			approvalCardHint: "写入审批=使用中生成/修改；合并审批=两轮工作流。",
+			mergeCardHint: "写入审批=使用中生成/修改；合并审批=两轮工作流。",
+			approvalTitle: "待批写入",
+			approvalLoading: "正在读取待批项…",
+			approvalEmpty: "没有待批的写入",
+			approvalFailed: "待批项读取失败",
+			approvalRetry: "重试",
+			approvalApprove: "批准",
+			approvalReject: "拒绝",
+			approvalCount: "{n} 项待批",
+			approvalRunningCount: "{n} 项执行中",
+			approvalRefresh: "刷新",
+			approvalExecuting: "执行中：这条的写效果可能已经落地，不要重复批准；要清掉它请用拒绝。",
+			approvalKindMemory: "记忆",
+			approvalKindSkill: "技能",
+			approvalKindCapability: "能力",
+			approvalAgeNow: "刚刚",
+			approvalAgeMinutes: "{n} 分钟前",
+			approvalAgeHours: "{n} 小时前",
+			approvalAgeDays: "{n} 天前",
+			approvalAgeMonths: "{n} 个月前",
+			approvalPreview: "预览",
+			approvalPreviewClose: "收起",
+			approvalPreviewReading: "正在读取预览…",
+			approvalPreviewNone: "看不了预览：",
+			approvalDiffAdded: "{n} 行新增",
+			approvalDiffRemoved: "{n} 行删除",
+			approvalDiffCut: "改动区域已截断",
+			diagTitle: "诊断",
+			diagSubtitle: "运行状态的只读自查；不会改动任何东西。",
+			diagRuntimeTitle: "运行状态",
+			diagSummaryOk: "运行正常",
+			diagSummaryWarn: "{n} 项需要注意",
+			diagSummaryFail: "{n} 项异常",
+			diagSummaryUnknown: "{n} 项待确认",
+			diagRefresh: "刷新",
+			diagRefreshing: "刷新中…",
+			diagStatusOk: "正常",
+			diagStatusWarn: "注意",
+			diagStatusFail: "异常",
+			diagStatusUnknown: "未知",
+			diagRemedy: "建议：",
+			diagNoRows: "没有可显示的运行状态",
+			stateLoading: "正在读取…",
+			failureUnauthorized: "需要登录：重新打开这个页面完成登录后再试。",
+			failureForbidden: "平台拒绝了这个请求（身份不是 owner）。",
+			failureUnmounted: "该功能没有挂载。",
+			failureServer: "读取失败，可以手动重试。",
+			fallbackHint: "可以改用命令：{command}"
+		};
+		/** English copy, key for key with {@link zh}. */
+		const en$1 = {
+			title: "Self-evolution",
+			subtitle: "Writes waiting for your decision come first; the changeable parameters are listed by feature below, and anything not listed comes from the deployment configuration.",
+			overridden: "Overridden",
+			deployment: "default",
+			loading: "reading settings…",
+			unavailable: "this feature is not running (its plugin is not installed)",
+			seatMissing: "this shell serves no settings surface, so the parameters cannot be edited here",
+			projectionFailed: "reading this row failed and the error is in the log; the other parameters are unaffected",
+			readonly: "settings cannot be written in this session (temporary mode)",
+			apply: "Save",
+			reset: "Reset to default",
+			empty: "nothing to change here",
+			changed: "{n} overridden",
+			discard: "Discard",
+			saving: "Saving…",
+			resetting: "Resetting…",
+			writeTargetHost: "Saved to: host configuration (applies to every session)",
+			invalidNumber: "Needs a number",
+			invalidSelect: "Not one of the allowed values",
+			invalidAtLeast: "must not be below {n}",
+			approvalConfirmNamed: "About to approve: {n}",
+			approvalConfirmYes: "Approve",
+			approvalConfirmNo: "Cancel",
+			resetTo: "Restores {value}",
+			refused: "The value was not accepted (the page keeps what you see). For the reason, ask in the conversation.",
+			resetRefused: "The reset did not take (this row still holds your value). For the reason, ask in the conversation.",
+			cardReview: "Session review",
+			cardMemory: "Long-term memory",
+			cardToolMemory: "Writing memory",
+			cardCurator: "Skill tidy-up",
+			cardSkills: "Skill write rules",
+			cardApproval: "Write approval",
+			cardCommands: "Maintenance scans",
+			cardMerge: "Skill auto-merge",
+			approvalCardHint: "Write approval = generate/modify while in use; merge approval = the two-round workflow.",
+			mergeCardHint: "Write approval = generate/modify while in use; merge approval = the two-round workflow.",
+			approvalTitle: "Writes awaiting approval",
+			approvalLoading: "reading the pending window…",
+			approvalEmpty: "nothing is waiting for a decision",
+			approvalFailed: "the pending window could not be read",
+			approvalRetry: "Retry",
+			approvalApprove: "Approve",
+			approvalReject: "Reject",
+			approvalCount: "{n} waiting",
+			approvalRunningCount: "{n} running",
+			approvalRefresh: "Refresh",
+			approvalExecuting: "Running: this write may already have landed — do not approve it twice; reject it to clear it.",
+			approvalKindMemory: "memory",
+			approvalKindSkill: "skill",
+			approvalKindCapability: "capability",
+			approvalAgeNow: "just now",
+			approvalAgeMinutes: "{n} min ago",
+			approvalAgeHours: "{n} h ago",
+			approvalAgeDays: "{n} d ago",
+			approvalAgeMonths: "{n} mo ago",
+			approvalPreview: "Preview",
+			approvalPreviewClose: "Hide",
+			approvalPreviewReading: "reading the preview…",
+			approvalPreviewNone: "no preview: ",
+			approvalDiffAdded: "{n} lines added",
+			approvalDiffRemoved: "{n} lines removed",
+			approvalDiffCut: "the changed region is truncated",
+			diagTitle: "Diagnostics",
+			diagSubtitle: "A read-only check of the runtime state; nothing here changes anything.",
+			diagRuntimeTitle: "Runtime status",
+			diagSummaryOk: "All healthy",
+			diagSummaryWarn: "{n} need attention",
+			diagSummaryFail: "{n} failing",
+			diagSummaryUnknown: "{n} unconfirmed",
+			diagRefresh: "Refresh",
+			diagRefreshing: "refreshing…",
+			diagStatusOk: "healthy",
+			diagStatusWarn: "needs attention",
+			diagStatusFail: "failing",
+			diagStatusUnknown: "unknown",
+			diagRemedy: "Suggested: ",
+			diagNoRows: "no runtime status to show",
+			stateLoading: "reading…",
+			failureUnauthorized: "Sign-in is required: reopen this page and sign in, then retry.",
+			failureForbidden: "The platform refused this request (not the owner principal).",
+			failureUnmounted: "This feature is not mounted.",
+			failureServer: "The read failed; you can retry manually.",
+			fallbackHint: "Command fallback: {command}"
+		};
+		/**
+		* Card titles per settings namespace. A namespace without an entry falls back to
+		* its raw name, so a Host that registers a new namespace still renders — the
+		* title is presentation, the namespace is the join key.
+		*/
+		const NAMESPACE_TITLES = Object.freeze({
+			"evolution-review": "cardReview",
+			"memory-files": "cardMemory",
+			"tool-memory": "cardToolMemory",
+			"evolution-curator": "cardCurator",
+			"tool-skill-manage": "cardSkills",
+			"evolution-approval": "cardApproval",
+			"evolution-commands": "cardCommands",
+			"evolution-merge": "cardMerge"
+		});
+		/**
+		* Resolve one message without the locale seat (tests and the fallback path).
+		* @param key - the message key.
+		* @param language - which dictionary to read; defaults to English (the platform FALLBACK_LOCALE).
+		* @returns the copy this bundle carries.
+		*/
+		function message(key, language = "en") {
+			return language === "zh" ? zh$1[key] : en$1[key];
+		}
+		/**
+		* Fill one TEMPLATE's `{slot}` placeholders (G5 C4). The seat's translator takes the values, so the
+		* rule lives here instead of at every call site — `t('changed').replace('{n}', …)` used to be
+		* written seven times across three components. An UNKNOWN slot is left standing: a missing value
+		* must not print "undefined" into the operator's UI.
+		* @param template - the resolved copy, with `{slot}` placeholders.
+		* @param values - substitutions keyed by the slot name inside the braces.
+		* @returns the filled copy.
+		*/
+		function fill$1(template, values) {
+			return template.replace(/\{(\w+)\}/g, (match, slot) => {
+				const value = values[slot];
+				return value === void 0 ? match : String(value);
+			});
+		}
+		//#endregion
+		//#region src/panels/settings/guards.ts
+		/**
+		* Is this a non-null, non-array object (what JSON calls an object)?
+		* @param value - the value to test.
+		* @returns whether it is a plain object.
+		*/
+		function isRecord(value) {
+			return typeof value === "object" && value !== null && !Array.isArray(value);
+		}
+		//#endregion
+		//#region src/panels/settings/ParamCard.ts
+		/**
+		* One namespace's parameter card.
+		*
+		* Structural local types on purpose: this package is distributed outside the
+		* platform repository and a value import of another plugin is forbidden, so the
+		* settings scope and its snapshot are declared by the shape the renderer hands
+		* over (\`getSnapshot\`/\`subscribe\`, status/value/user/writable).
+		*
+		* header (namespace title, change count, chevron), then one block per field —
+		* header (namespace title, change count, chevron), then one block per field —
+		* label with its unit and source chip, a control HOLDING THE CURRENT VALUE, the
+		* Chinese hint — and one 放弃修改/保存 pair at the card's foot. The control is
+		* typed from the registry (\`control\`), so booleans are switches, enums are
+		* selects and numbers are numeric inputs with the unit shown beside the label.
+		*/
+		/**
+		* The NAMESPACE-RELATIVE key of one registry field.
+		*
+		* The E3 registry writes family ids in canonical form (`evolution-approval.pendingTtlMs`),
+		* while the platform settings seat speaks a namespace's own field keys (`pendingTtlMs`) —
+		* its snapshot user layer, its base and its op paths are all relative to the namespace. Sending
+		* the canonical id as an op path makes the Host refuse the write
+		* ("Config field evolution-approval.pendingTtlMs is not volatile", measured 2026-10-19), so the
+		* card translates once, here, and every read/write goes through it.
+		* @param namespace - the settings namespace (Loader row id) the card writes.
+		* @param field - one generated field.
+		* @returns the field's key inside that namespace.
+		*/
+		function fieldKeyOf(namespace, field) {
+			const prefix = namespace + ".";
+			return field.id.startsWith(prefix) ? field.id.slice(prefix.length) : field.id;
+		}
+		/** One cell's text: absent reads as an empty control, containers as JSON. */
+		function format(value) {
+			if (value === void 0) return "";
+			if (typeof value === "string") return value;
+			return JSON.stringify(value);
+		}
+		/**
+		* Parse one edited value into what the scope should receive.
+		* @param control - the registry's control kind for the field.
+		* @param text - the text the operator left in the control.
+		* @returns the value handed to \`set\`; a string stays raw so the Host's own
+		*   validation produces the error message the operator reads.
+		*/
+		function parseFor(control, text) {
+			const trimmed = text.trim();
+			if (control === "switch") return trimmed === "true";
+			if (control === "number") {
+				const parsed = Number(trimmed);
+				return trimmed !== "" && Number.isFinite(parsed) ? parsed : trimmed;
+			}
+			try {
+				return JSON.parse(trimmed);
+			} catch {
+				return trimmed;
+			}
+		}
+		/**
+		* U-4: whether one field's CURRENT text is a value the Host can take. The controls constrain their own
+		* domains (a number input sanitizes, a select only offers listed values), so the reachable case is a
+		* value the registry no longer lists — carried in the user layer and re-staged by any other edit.
+		* @param field - the generated field.
+		* @param text - the text the control holds right now.
+		* @param peer - U-4: the text the row this field declares `atLeast` against currently holds (absent
+		* when the field declares no relation, or when that row is not on this card).
+		* @returns the message key explaining the refusal, or null when the value is acceptable.
+		*/
+		function invalidReason(field, text, peer) {
+			const trimmed = text.trim();
+			if (trimmed === "") return null;
+			if (field.control === "number") {
+				if (!Number.isFinite(Number(trimmed))) return "invalidNumber";
+				if (field.atLeast !== "" && peer !== void 0 && peer.trim() !== "" && Number.isFinite(Number(peer))) {
+					if (Number(trimmed) < Number(peer)) return "invalidAtLeast";
+				}
+				return null;
+			}
+			if (field.control === "select") return field.values.includes(trimmed) ? null : "invalidSelect";
+			return null;
+		}
+		/**
+		* U-5: the value a reset would restore, spelled for a reader. Only primitives are shown: the seat's
+		* `base` may be a nested object, and `[object Object]` is worse than saying nothing.
+		* @param value - the seat's base value for one field.
+		* @returns its display string, or null when it is not a primitive.
+		*/
+		function resetToOf(value) {
+			if (value === null || value === void 0) return null;
+			if (typeof value === "string") return value;
+			if (typeof value === "number" || typeof value === "boolean") return String(value);
+			return null;
+		}
+		/**
+		* The DOM id a field's control, its label and its explanation node all share. ONE definition: the
+		* three call sites used to spell the string out, and the third one (the explanation node) referred to
+		* a local that only existed inside the control — a ReferenceError on every invalid value, which the
+		* unit-level fixture could not see because it never rendered one (independent review, P1-1).
+		*/
+		function controlId(field) {
+			return "evolution-param-" + field.id;
+		}
+		/** One field's control, typed from the registry. */
+		function FieldControl(props) {
+			const { field, text } = props;
+			const id = controlId(field);
+			const common = {
+				id,
+				disabled: props.disabled,
+				className: "evolution-param-input",
+				...props.invalid === null ? {} : {
+					"aria-invalid": "true",
+					"aria-describedby": id + "-invalid"
+				}
+			};
+			if (field.control === "switch") return (0, react.createElement)("input", {
+				...common,
+				className: "evolution-param-check",
+				type: "checkbox",
+				checked: text === "true",
+				onChange: (event) => {
+					props.onChange(field.id, String(event.target.checked));
+				}
+			});
+			if (field.control === "select") return (0, react.createElement)("select", {
+				...common,
+				className: "evolution-param-select",
+				value: text,
+				onChange: (event) => {
+					props.onChange(field.id, event.target.value);
+				}
+			}, [field.values.includes(text) || text === "" ? null : (0, react.createElement)("option", {
+				key: text,
+				value: text
+			}, text), ...field.values.map((value, index) => (0, react.createElement)("option", {
+				key: value,
+				value
+			}, field.valueLabels[index] ?? value))]);
+			return (0, react.createElement)("input", {
+				...common,
+				type: field.control === "number" ? "number" : "text",
+				value: text,
+				onChange: (event) => {
+					props.onChange(field.id, event.target.value);
+				}
+			});
+		}
+		/** One parameter field: label, control, hint, and its reset-to-deployment action. */
+		function FieldBlock(props) {
+			const { field, t } = props;
+			const unit = field.unit === "" ? null : (0, react.createElement)("span", { className: "evolution-param-unit" }, "（" + field.unit + "）");
+			return (0, react.createElement)("div", { className: "evolution-param-field" }, (0, react.createElement)("div", { className: "evolution-param-label" }, (0, react.createElement)("label", { htmlFor: controlId(field) }, field.label === "" ? field.id : field.label), unit, props.overridden ? (0, react.createElement)("span", {
+				className: "evolution-param-source",
+				"data-user": "true"
+			}, t("overridden")) : null), FieldControl(props), (0, react.createElement)("p", { className: "evolution-param-hint" }, field.hint === "" ? field.doc : field.hint), props.invalid === null ? null : (0, react.createElement)("p", {
+				id: controlId(field) + "-invalid",
+				className: "evolution-param-error",
+				role: "status"
+			}, t(props.invalid)), props.overridden ? (0, react.createElement)("div", { className: "evolution-param-actions" }, (0, react.createElement)("button", {
+				type: "button",
+				className: "evolution-param-button",
+				disabled: props.disabled || props.clearing,
+				onClick: () => {
+					props.onClear(field.id);
+				}
+			}, props.clearing ? t("resetting") : t("reset")), props.resetTo === null ? null : (0, react.createElement)("span", { className: "evolution-param-hint" }, t("resetTo", { value: props.resetTo }))) : null);
+		}
+		/**
+		* Render one row's card body from a supplied snapshot.
+		* @param props - the card data, its callbacks, and the row state to render.
+		* @returns the card.
+		*/
+		function ParamCardView(props) {
+			const { t, fields, mutateOnce, clear, namespace, snapshot } = props;
+			const [open, setOpen] = (0, react.useState)(false);
+			const [draft, setDraft] = (0, react.useState)({});
+			const [busy, setBusy] = (0, react.useState)(false);
+			const [error, setError] = (0, react.useState)("");
+			const [pending, setPending] = (0, react.useState)(null);
+			const [clearing, setClearing] = (0, react.useState)(null);
+			/**
+			* Settle a staged write against the Host's answer.
+			*
+			* A resolved write promise is not the verdict: both settings scopes this bundle runs
+			* on (the shell's own controller and the bridge variant) finish their recovery read
+			* BEFORE it resolves, so a value the Host refused is simply still the previous one.
+			* Presence in the user layer therefore cannot answer the question — on a field the
+			* operator had already overridden, a refused value's key is present as well. The
+			* verdict asks whether each staged id now holds the value this card requested.
+			* The check lives in an effect, not in the save callback, because the raw snapshot is
+			* reachable only through the render-time seat — the face's `hooks` compartment never
+			* reaches the component.
+			*/
+			(0, react.useEffect)(() => {
+				if (pending === null) return;
+				setPending(null);
+				setBusy(false);
+				setClearing(null);
+				if (!pending.accepted) {
+					setError(t(pending.resets ? "resetRefused" : "refused"));
+					return;
+				}
+				if (!pending.resets) setDraft({});
+			}, [
+				pending,
+				snapshot.user,
+				t
+			]);
+			if (snapshot.status === "loading") return (0, react.createElement)("p", {
+				className: "evolution-param-note",
+				role: "status"
+			}, t("loading"));
+			if (snapshot.status === "unavailable") return (0, react.createElement)("p", {
+				className: "evolution-param-note",
+				role: "status"
+			}, t(snapshot.reason === "seat-missing" ? "seatMissing" : snapshot.reason === "projection-failed" ? "projectionFailed" : "unavailable"));
+			const user = isRecord(snapshot.user) ? snapshot.user : {};
+			const value = isRecord(snapshot.value) ? snapshot.value : {};
+			const disabled = !snapshot.writable;
+			const locked = disabled || busy || clearing !== null;
+			const titleKey = NAMESPACE_TITLES[namespace];
+			const title = titleKey === void 0 ? namespace : t(titleKey);
+			const hintKey = namespace === "evolution-merge" ? "mergeCardHint" : namespace === "evolution-approval" ? "approvalCardHint" : void 0;
+			const keyOf = (field) => fieldKeyOf(namespace, field);
+			const changed = fields.filter((field) => Object.hasOwn(user, keyOf(field))).length;
+			const textOf = (field) => draft[field.id] ?? format(value[keyOf(field)]);
+			const dirty = fields.filter((field) => draft[field.id] !== void 0 && draft[field.id] !== format(value[keyOf(field)]));
+			const peerTextOf = (field) => {
+				if (field.atLeast === "") return void 0;
+				const related = fields.find((candidate) => candidate.id === field.atLeast);
+				return related === void 0 ? void 0 : textOf(related);
+			};
+			const blocked = fields.some((field) => invalidReason(field, textOf(field), peerTextOf(field)) !== null);
+			const change = (id, next) => {
+				setDraft({
+					...draft,
+					[id]: next
+				});
+			};
+			/**
+			* Restore one field's deployment default (T5-05/A60).
+			*
+			* The scope's own boolean is NOT the verdict — same reason the save path judges the settled
+			* snapshot instead: a host refusal leaves the user layer untouched, which is precisely what a
+			* structural check sees and a dropped return value does not. A throw (the settings service
+			* rejecting a non-volatile path) used to escape as an unhandled rejection.
+			*/
+			const reset = (field) => {
+				setClearing(field);
+				setError("");
+				(async () => {
+					let accepted;
+					try {
+						accepted = await clear(fieldKeyOf(namespace, { id: field }));
+					} catch (caught) {
+						setClearing(null);
+						setError(caught instanceof Error && caught.message !== "" ? caught.message : t("resetRefused"));
+						return;
+					}
+					setPending({
+						accepted,
+						resets: true
+					});
+				})();
+			};
+			const save = () => {
+				setBusy(true);
+				setError("");
+				(async () => {
+					try {
+						setPending({
+							accepted: await mutateOnce(dirty.map((field) => ({
+								op: "set",
+								path: [keyOf(field)],
+								value: parseFor(field.control, textOf(field))
+							}))),
+							resets: false
+						});
+					} catch (caught) {
+						setBusy(false);
+						setError(caught instanceof Error && caught.message !== "" ? caught.message : t("refused"));
+					}
+				})();
+			};
+			return (0, react.createElement)("section", { className: "evolution-param-card" }, (0, react.createElement)("button", {
+				type: "button",
+				className: "evolution-param-head",
+				"aria-expanded": open ? "true" : "false",
+				onClick: () => {
+					setOpen(!open);
+				}
+			}, (0, react.createElement)("span", { className: "evolution-param-card-title" }, title), changed === 0 ? null : (0, react.createElement)("span", { className: "evolution-param-count" }, t("changed", { n: changed })), (0, react.createElement)("span", { className: "evolution-param-dest" }, t("writeTargetHost")), (0, react.createElement)("span", { className: "evolution-param-chevron" }, open ? "▲" : "▼")), open ? (0, react.createElement)("div", { className: "evolution-param-body" }, hintKey === void 0 ? null : (0, react.createElement)("p", { className: "evolution-param-note" }, t(hintKey)), disabled ? (0, react.createElement)("p", {
+				className: "evolution-param-note",
+				role: "status"
+			}, t("readonly")) : null, fields.length === 0 ? (0, react.createElement)("p", {
+				className: "evolution-param-note",
+				role: "status"
+			}, t("empty")) : fields.flatMap((field, index) => [index === 0 || fields[index - 1]?.group !== field.group ? (0, react.createElement)("h3", {
+				key: "group-" + field.group,
+				className: "evolution-param-group"
+			}, field.group) : null, (0, react.createElement)(FieldBlock, {
+				key: field.id,
+				field,
+				text: textOf(field),
+				overridden: Object.hasOwn(user, keyOf(field)),
+				disabled: locked,
+				clearing: clearing === field.id,
+				resetTo: resetToOf(snapshot.base?.[keyOf(field)]),
+				invalid: invalidReason(field, textOf(field), peerTextOf(field)),
+				t,
+				onChange: change,
+				onClear: reset
+			})]), error === "" ? null : (0, react.createElement)("p", {
+				className: "evolution-param-error",
+				role: "status"
+			}, error), fields.length === 0 ? null : (0, react.createElement)("div", { className: "evolution-param-footer" }, (0, react.createElement)("button", {
+				type: "button",
+				className: "evolution-param-button",
+				disabled: busy || dirty.length === 0 || blocked,
+				onClick: () => {
+					setDraft({});
+					setError("");
+				}
+			}, t("discard")), (0, react.createElement)("button", {
+				type: "button",
+				className: "evolution-param-button",
+				"data-primary": "true",
+				disabled: locked || blocked || dirty.length === 0,
+				onClick: save
+			}, busy ? t("saving") : t("apply")))) : null);
+		}
+		/**
+		* The card as our own section renders it: the row state comes from the hook seat the
+		* renderer binds out of the inject face's `hooks` compartment (components never hold a
+		* subscription of their own).
+		* @param props - the card data, its callbacks, and the bound row hook.
+		* @returns the card.
+		*/
+		function ParamCard(props) {
+			return ParamCardView({
+				namespace: props.namespace,
+				fields: props.fields,
+				t: props.t,
+				mutateOnce: props.mutateOnce,
+				clear: props.clear,
+				snapshot: props.useParamSection((state) => state)
+			});
+		}
+		//#endregion
+		//#region src/panels/settings/source.ts
+		/** What a card shows when this UI found no settings seat at all. */
+		const SEAT_MISSING = Object.freeze({
+			status: "unavailable",
+			value: void 0,
+			user: void 0,
+			writable: false,
+			base: void 0,
+			reason: "seat-missing"
+		});
+		/** What a card shows when the seat served the row but projecting it failed. A frozen constant
+		* so a failing row keeps ONE reference: a fresh object per call would reintroduce the
+		* render loop this module exists to prevent. */
+		const PROJECTION_FAILED = Object.freeze({
+			status: "unavailable",
+			value: void 0,
+			user: void 0,
+			writable: false,
+			base: void 0,
+			reason: "projection-failed"
+		});
+		/**
+		* Project one platform snapshot into the card's own shape.
+		* @param snapshot - the seat's snapshot.
+		* @returns the card's snapshot, with the reason an unavailable one is unavailable.
+		*/
+		function sectionSnapshotOf(snapshot) {
+			return {
+				status: snapshot.status,
+				value: isRecord(snapshot.value) ? snapshot.value : void 0,
+				user: snapshot.user,
+				writable: snapshot.writable,
+				base: isRecord(snapshot.base) ? snapshot.base : void 0,
+				...snapshot.status === "unavailable" ? { reason: "not-served" } : {}
+			};
+		}
+		/**
+		* Bind one row's form to a projection that is stable per raw snapshot and never throws.
+		* @param form - the row's client form, as the settings seat hands it over.
+		* @returns the projection the card's hook reads.
+		*/
+		function stableProjection(form) {
+			let lastRaw;
+			let lastOut;
+			let reported = false;
+			const failed = (error) => {
+				if (!reported) {
+					reported = true;
+					console.error("[evolution-settings] projecting one row failed:", error);
+				}
+				return PROJECTION_FAILED;
+			};
+			return () => {
+				let raw;
+				try {
+					raw = form.getSnapshot();
+				} catch (error) {
+					return failed(error);
+				}
+				if (lastOut !== void 0 && raw === lastRaw) return lastOut;
+				try {
+					const next = sectionSnapshotOf(raw);
+					lastRaw = raw;
+					lastOut = next;
+					return next;
+				} catch (error) {
+					return failed(error);
+				}
+			};
+		}
+		/**
+		* The live source one row's card binds.
+		* @param probe - the lazily probed settings seat.
+		* @param namespace - the row's entry id.
+		* @returns the source; without a seat it reports the stated empty state, and it re-probes on
+		*   every read so a seat that appears later is picked up without a timer.
+		*/
+		function sourceFor(probe, namespace) {
+			const listeners = /* @__PURE__ */ new Set();
+			let form;
+			let projected;
+			let offForm;
+			/**
+			* Bind the seat's form for this row.
+			* @param force - re-read the seat even when one is already bound, so a REPLACED seat (the shell
+			*   re-composed, a different form object for the same row) is picked up instead of kept stale.
+			*/
+			const bind = (force = false) => {
+				if (form !== void 0 && !force) return;
+				const seat = probe();
+				if (seat === void 0) return;
+				const next = seat.get(namespace);
+				if (next === form) return;
+				offForm?.();
+				offForm = void 0;
+				form = next;
+				projected = stableProjection(form);
+			};
+			const attach = () => {
+				if (form === void 0 || offForm !== void 0) return;
+				offForm = form.subscribe(() => {
+					for (const listener of listeners) listener();
+				});
+			};
+			return {
+				getSnapshot: () => {
+					bind();
+					return projected === void 0 ? SEAT_MISSING : projected();
+				},
+				revive: () => {
+					bind(true);
+					attach();
+					for (const listener of listeners) listener();
+				},
+				subscribe: (listener) => {
+					listeners.add(listener);
+					bind();
+					attach();
+					return () => {
+						listeners.delete(listener);
+						if (listeners.size === 0) {
+							offForm?.();
+							offForm = void 0;
+						}
+					};
+				}
+			};
+		}
+		/**
+		* The write pair for one row.
+		* @param probe - the lazily probed settings seat.
+		* @param namespace - the row's entry id.
+		* @returns the two calls a card's save/reset path uses; without a seat they resolve without writing.
+		*/
+		function writeFaceFor(probe, namespace) {
+			const form = () => probe()?.get(namespace);
+			return {
+				mutateOnce: async (ops) => {
+					const seat = form();
+					if (seat === void 0) return false;
+					return await seat.mutate(ops);
+				},
+				clear: async (field) => {
+					const seat = form();
+					if (seat === void 0) return false;
+					return await seat.unset(field);
+				}
+			};
+		}
+		/**
+		* One source object per namespace, for the life of the plugin fiber.
+		*
+		* The renderer caches a hook binding per SOURCE OBJECT, so building a source per render
+		* would re-bind the hook and remount the card. The cache is owned by the caller's fiber and
+		* cleared on dispose.
+		* @param probe - the lazily probed settings seat.
+		* @returns the per-namespace source cache and its disposer.
+		*/
+		function createSourceCache(probe) {
+			const sources = /* @__PURE__ */ new Map();
+			return {
+				sourceFor: (namespace) => {
+					const existing = sources.get(namespace);
+					if (existing !== void 0) return existing;
+					const source = sourceFor(probe, namespace);
+					sources.set(namespace, source);
+					return source;
+				},
+				revive: () => {
+					for (const source of sources.values()) source.revive();
+				},
+				dispose: () => {
+					sources.clear();
+				}
+			};
+		}
+		//#endregion
+		//#region src/panels/settings/RowConfigCard.ts
+		/**
+		* The Plugins page's per-row configuration entry for a family row.
+		*
+		* The page owns the settings subscription — it re-renders the entry — and passes the row's
+		* form in, so this component renders the SAME card body as our own section, fed by the
+		* page's state instead of the bound hook and therefore holding no subscription of its own.
+		* `summary` answers the page's one-line slot: a row's description fallback, which stays
+		* empty until the row actually overrides something, exactly as the page expects.
+		* @module @lmzhen/dsh-evolution-ui/panels/settings/client
+		*/
+		/**
+		* Count the keys this row's user layer holds.
+		* @param user - the raw user section, as the page reports it.
+		* @param fields - the row's fields.
+		* @returns how many of them the user overrode.
+		*/
+		function overridden(user, fields, namespace) {
+			const layer = isRecord(user) ? user : {};
+			return fields.filter((field) => Object.hasOwn(layer, fieldKeyOf(namespace, field))).length;
+		}
+		/**
+		* Render one row's configuration entry.
+		* @param props - the page's view/form seat plus this row's face.
+		* @returns the entry; `summary` renders nothing for an untouched row (the page then keeps the row's own description).
+		*/
+		function RowConfigCard(props) {
+			const { t, fields, namespace, view, form } = props;
+			if (form === void 0) return view === "summary" ? null : (0, react.createElement)("p", {
+				className: "evolution-param-note",
+				role: "status"
+			}, t("seatMissing"));
+			const changed = overridden(form.state.user, fields, namespace);
+			if (view === "summary") return changed === 0 ? null : (0, react.createElement)("span", null, t("changed", { n: changed }));
+			return ParamCardView({
+				namespace,
+				fields,
+				t,
+				snapshot: sectionSnapshotOf(form.state),
+				mutateOnce: async (ops) => form.mutate(ops, form.state.revision),
+				clear: async (field) => form.mutate([{
+					op: "unset",
+					path: [field]
+				}], form.state.revision)
+			});
+		}
+		//#endregion
+		//#region src/panels/settings/seam.ts
+		/** Our card slot, hosted by the section this bundle registers. */
+		const CARD_SLOT = "evolution.namespace.card";
+		/** The Plugins page's per-row configuration seat (declared by `ui-plugin-manager`). */
+		const ROW_CONFIG_SLOT = "plugins.row.config";
+		/**
+		* The key the Plugins page files a row's configuration under.
+		*
+		* Spelled here because the page's own helper cannot be imported (a value import from
+		* another plugin's client half is forbidden):
+		* `ui-plugin-manager`'s config-ledger module is the definition this mirrors.
+		* @param bundle - the bundle package name that declares the row.
+		* @param rowId - the row id that bundle's patch declares.
+		* @returns the `plugins.row.config` key.
+		*/
+		function rowConfigKey(bundle, rowId) {
+			return bundle + "#" + rowId;
+		}
+		/**
+		* The pending-window card's slot key.
+		*
+		* The section pairs cards by key and the parameter cards use their settings namespace; this card has no
+		* namespace (its data comes from the host's approval routes), so it carries a key of its own. The constant
+		* lives HERE and not in `index.ts` because the SECTION has to name it too, and `index.ts` already imports
+		* the section — one definition in the module both sides already share is what keeps that pair acyclic.
+		*/
+		const PENDING_CARD_KEY = "approval-pending";
+		/** The diagnostics card's slot key: read-only, no settings namespace (its data comes from HOST_ROUTES.diagnostics). */
+		const DIAGNOSTICS_CARD_KEY = "diagnostics";
+		//#endregion
+		//#region src/panels/settings/SettingsSection.ts
+		/**
+		* The section shell: title, one-line explanation, then one card per namespace — with the staged-write
+		* window's card ahead of them all, because it is the only card here that waits on a decision.
+		*
+		* This is the shape the platform's own settings sections use — a heading plus the
+		* child slots it declared in its registration. The cards themselves are separate
+		* registrations keyed by namespace, so a namespace the Host does not serve simply
+		* renders nothing and a deployment that drops this row loses the whole section.
+		* @module @lmzhen/dsh-evolution-ui/panels/settings/client
+		*/
+		/**
+		* Render the section.
+		* @param face - the shell's inject face: translator and child-slot renderer.
+		* @returns the section element.
+		*/
+		function SettingsSection(face) {
+			return (0, react.createElement)("div", { className: "evolution-params" }, (0, react.createElement)("h2", { className: "evolution-params-title" }, face.t("title")), (0, react.createElement)("p", { className: "evolution-params-subtitle" }, face.t("subtitle")), (0, react.createElement)("p", { className: "evolution-params-about" }, "0.32.1 · Web UI umbrella for the evolution family: settings, merge, skill history and skill health panels"), (0, react.createElement)("div", {
+				key: PENDING_CARD_KEY,
+				className: "evolution-params-group"
+			}, face.renderSlot(CARD_SLOT, {}, { entryKey: PENDING_CARD_KEY })), (0, react.createElement)("div", {
+				key: DIAGNOSTICS_CARD_KEY,
+				className: "evolution-params-group"
+			}, face.renderSlot(CARD_SLOT, {}, { entryKey: DIAGNOSTICS_CARD_KEY })), ...CLIENT_PARAM_SECTIONS.map((section_) => (0, react.createElement)("div", {
+				key: section_.namespace,
+				className: "evolution-params-group"
+			}, face.renderSlot(CARD_SLOT, {}, { entryKey: section_.namespace }))));
+		}
+		//#endregion
+		//#region ../evolution-client-kit/src/tokens.ts
+		/**
+		* The scale, declared on one element so it never leaks into the host shell.
+		* @param scope - the selector the custom properties are declared on.
+		* @returns the declaration block to put in the stylesheet.
+		*/
+		function tokenVars(scope) {
+			return scope + "{--evo-type-lg:calc(1em + 2px);--evo-type-body:1em;--evo-type-sm:calc(1em - 1px);--evo-type-xs:calc(1em - 2px);--evo-space-2:2px;--evo-space-4:4px;--evo-space-6:6px;--evo-space-8:8px;--evo-space-10:10px;--evo-space-12:12px;--evo-space-14:14px;--evo-space-16:16px;--evo-space-20:20px;--evo-radius-chip:4px;--evo-radius-control:8px;--evo-radius-surface:12px;--evo-radius-pill:999px;--evo-hairline-width:.5px;--evo-hairline-marker:2px;--evo-measure-read:80ch;--evo-leading-base:1.5;--evo-tone-quiet:var(--dsw-alias-label-secondary);--evo-tone-primary:var(--dsw-alias-brand-primary);--evo-tone-danger:var(--dsw-alias-state-error-primary);--evo-tone-success:var(--dsw-alias-state-success-primary);--evo-focus-ring:2px solid var(--dsw-alias-label-primary);--evo-focus-offset:-2px;--evo-cap-aside:280px;--evo-cap-block:260px}";
+		}
+		//#endregion
+		//#region src/panels/settings/styles.ts
+		/**
+		* The section's stylesheet.
+		*
+		* The platform's own client bundles compile CSS Modules into a string and inject
+		* it once behind a `<style data-plugin-css="<pkg>/<file>">` tag; this bundle is
+		* built outside that pipeline, so it carries its own string and injects it the
+		* same way. Every colour reads the platform's design tokens (`--dsw-alias-*`), so
+		* the section follows the light and dark themes without owning a colour; every
+		* type step and geometry value reads the family scale (`./tokens.ts`, generated
+		* from `packages/scripts/client-tokens.json`), the same one the history panel
+		* draws from — before it existed this card rooted its type in
+		* `--dsh-content-font-size*` (the CONVERSATION content size, which the platform's
+		* own surfaces never read) and wrote its own paddings, so the family's two client
+		* faces drifted apart (W2/W5/W6).
+		*
+		* The field metrics (8px/10px input padding, 8px radius, 12px/6px paddings and
+		* gaps) follow the platform's own settings fields: `ui-primitives/Input.module.css`
+		* and `ui-settings-plugins/.../fields.module.css` both use an 8px field radius.
+		* @module @lmzhen/dsh-evolution-ui/panels/settings/client
+		*/
+		/** Tag id that makes the injection idempotent. */
+		const CSS_TAG_ID$1 = "@lmzhen/dsh-evolution-ui/settings.css";
+		/** The stylesheet the section injects once. */
+		const CSS$1 = [
+			tokenVars(".evolution-params,.evolution-param-card"),
+			".evolution-params{display:flex;flex-direction:column}",
+			".evolution-params-title{margin:0 0 var(--evo-space-4);color:var(--dsw-alias-label-primary);font-size:var(--evo-type-lg);font-weight:600;line-height:var(--evo-leading-base)}",
+			".evolution-params-subtitle{margin:0 0 var(--evo-space-16);color:var(--dsw-alias-label-tertiary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}",
+			".evolution-params-about{margin:0 0 var(--evo-space-16);color:var(--dsw-alias-label-tertiary);font-size:var(--evo-type-xs)}",
+			".evolution-param-card{border:var(--evo-hairline-width) solid var(--dsw-alias-border-l2);border-radius:var(--evo-radius-control);background:var(--dsw-alias-bg-layer-1);margin-bottom:var(--evo-space-12)}",
+			".evolution-param-head{display:flex;align-items:center;gap:var(--evo-space-8);width:100%;padding:var(--evo-space-12) var(--evo-space-14);background:none;border:0;text-align:left;cursor:pointer;color:inherit;font:inherit}",
+			".evolution-param-head:hover{background:var(--dsw-alias-interactive-bg-hover)}",
+			".evolution-param-card-title{flex:1;min-width:0;color:var(--dsw-alias-label-primary);font-size:var(--evo-type-sm);font-weight:500;line-height:var(--evo-leading-base)}",
+			".evolution-param-count{color:var(--dsw-alias-brand-primary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}",
+			".evolution-param-chevron{color:var(--dsw-alias-label-tertiary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}",
+			".evolution-param-body{padding:0 var(--evo-space-14) var(--evo-space-12);border-top:var(--evo-hairline-width) solid var(--dsw-alias-border-l2)}",
+			".evolution-param-dest{color:var(--dsw-alias-label-tertiary);font-size:var(--evo-type-xs)}",
+			".evolution-param-group{margin:var(--evo-space-12) 0 0;font-size:var(--evo-type-sm);font-weight:600;color:var(--dsw-alias-label-secondary);text-transform:none}",
+			".evolution-param-field{display:flex;flex-direction:column;gap:var(--evo-space-6);padding:var(--evo-space-12) 0}",
+			".evolution-param-field+.evolution-param-field{border-top:var(--evo-hairline-width) solid var(--dsw-alias-border-l2)}",
+			".evolution-param-label{display:flex;align-items:center;gap:var(--evo-space-6);color:var(--dsw-alias-label-primary);font-size:var(--evo-type-body);font-weight:500;line-height:var(--evo-leading-base)}",
+			".evolution-param-unit{color:var(--dsw-alias-label-tertiary);font-weight:400}",
+			".evolution-param-hint{margin:0;color:var(--dsw-alias-label-tertiary);font-size:var(--evo-type-sm);line-height:var(--evo-leading-base)}",
+			".evolution-param-value{color:var(--dsw-alias-label-secondary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}",
+			".evolution-param-input{width:100%;box-sizing:border-box;padding:var(--evo-space-8) var(--evo-space-10);border:var(--evo-hairline-width) solid var(--dsw-alias-border-l2);border-radius:var(--evo-radius-control);background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-primary);font-size:var(--evo-type-body);line-height:var(--evo-leading-base)}",
+			".evolution-param-input:focus-visible{outline:var(--evo-focus-ring);outline-offset:var(--evo-focus-offset)}",
+			".evolution-param-input:disabled{color:var(--dsw-alias-label-dimmed);cursor:default}",
+			".evolution-param-source{display:inline-flex;align-items:center;height:var(--evo-space-20);padding:0 var(--evo-space-6);border-radius:var(--evo-radius-chip);background:var(--dsw-alias-bg-layer-3);color:var(--dsw-alias-label-secondary);font-size:var(--evo-type-xs);line-height:var(--evo-space-20)}",
+			".evolution-param-source[data-user=\"true\"]{background:var(--dsw-alias-brand-primary);color:var(--dsw-alias-label-primary-foreground)}",
+			".evolution-param-actions{display:flex;justify-content:flex-end;gap:var(--evo-space-8);padding-top:var(--evo-space-12)}",
+			".evolution-param-button{padding:var(--evo-space-6) var(--evo-space-12);border:var(--evo-hairline-width) solid var(--dsw-alias-border-l2);border-radius:var(--evo-radius-control);background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);font-size:var(--evo-type-sm);line-height:var(--evo-leading-base);cursor:pointer}",
+			".evolution-param-button:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover)}",
+			".evolution-param-button[data-tone=\"outline\"]{border-color:var(--dsw-alias-border-l2)}",
+			".evolution-param-button[data-tone=\"ghost\"]{border-color:transparent;background:transparent}",
+			".evolution-param-button[data-primary=\"true\"]{background:var(--dsw-alias-button-primary-fill);color:var(--dsw-alias-label-primary-foreground);border-color:transparent}",
+			".evolution-param-button[data-primary=\"true\"]:hover:not(:disabled){background:var(--dsw-alias-button-primary-hover)}",
+			".evolution-param-button:disabled{color:var(--dsw-alias-label-dimmed);cursor:default}",
+			".evolution-param-select{width:100%;box-sizing:border-box;padding:var(--evo-space-8) var(--evo-space-10);border:var(--evo-hairline-width) solid var(--dsw-alias-border-l2);border-radius:var(--evo-radius-control);background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-primary);font-size:var(--evo-type-sm);line-height:var(--evo-leading-base)}",
+			".evolution-param-select:focus-visible{outline:var(--evo-focus-ring);outline-offset:var(--evo-focus-offset)}",
+			".evolution-param-select:disabled{color:var(--dsw-alias-label-dimmed);cursor:default}",
+			".evolution-param-check{width:var(--evo-space-16);height:var(--evo-space-16);margin:0;accent-color:var(--dsw-alias-brand-primary);cursor:pointer}",
+			".evolution-param-check:disabled{cursor:default;opacity:.5}",
+			".evolution-param-footer{display:flex;justify-content:flex-end;gap:var(--evo-space-8);padding:var(--evo-space-12) 0 0;border-top:var(--evo-hairline-width) solid var(--dsw-alias-border-l2)}",
+			".evolution-param-note{margin:0;color:var(--dsw-alias-label-tertiary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}",
+			".evolution-param-error{margin:0;color:var(--dsw-alias-state-error-primary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}",
+			".evolution-param-facts{display:flex;flex-wrap:wrap;align-items:baseline;margin:0;color:var(--dsw-alias-label-tertiary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}",
+			".evolution-param-fact+.evolution-param-fact::before{content:\"·\";margin:0 var(--evo-space-6);color:var(--dsw-alias-label-tertiary)}",
+			".evolution-param-diff{margin:0;padding:var(--evo-space-12) var(--evo-space-16);max-height:var(--evo-cap-block);overflow:auto;border:var(--evo-hairline-width) solid var(--dsw-alias-border-l1);border-radius:var(--evo-radius-surface);background:var(--dsw-alias-markdown-code-block);color:var(--dsw-alias-label-primary);font:var(--dsw-font-markdown-code-block-small);white-space:pre-wrap}",
+			".evolution-param-line-add{color:var(--evo-tone-success)}",
+			".evolution-param-line-del{color:var(--evo-tone-danger)}",
+			".evolution-param-loading{margin:var(--evo-space-12) 0 0;color:var(--dsw-alias-label-tertiary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}",
+			".evo-diag-badge{display:inline-flex;align-items:center;height:var(--evo-space-20);padding:0 var(--evo-space-8);border-radius:var(--evo-radius-chip);background:var(--dsw-alias-bg-layer-3);color:var(--dsw-alias-label-secondary);font-size:var(--evo-type-xs);line-height:var(--evo-space-20);flex:none}",
+			".evo-diag-badge[data-status=\"ok\"]{color:var(--dsw-alias-state-success-primary)}",
+			".evo-diag-badge[data-status=\"warn\"]{color:var(--dsw-alias-state-warn-primary)}",
+			".evo-diag-badge[data-status=\"fail\"]{color:var(--dsw-alias-state-error-primary)}",
+			".evo-diag-badge[data-status=\"unknown\"]{color:var(--dsw-alias-state-idle-primary)}",
+			".evo-diag-list{display:flex;flex-direction:column}",
+			".evo-diag-item{padding:var(--evo-space-12) 0}",
+			".evo-diag-item+.evo-diag-item{border-top:var(--evo-hairline-width) solid var(--dsw-alias-border-l2)}",
+			".evo-diag-label{display:block;color:var(--dsw-alias-label-tertiary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}",
+			".evo-diag-row-head{display:flex;align-items:baseline;gap:var(--evo-space-6);flex-wrap:wrap}",
+			".evo-diag-dot{width:var(--evo-space-6);height:var(--evo-space-6);border-radius:var(--evo-radius-pill);background:var(--evo-diag-tone,var(--dsw-alias-state-idle-primary));flex:none}",
+			".evo-diag-status{color:var(--evo-diag-tone,var(--dsw-alias-state-idle-primary));font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}",
+			".evo-diag-item[data-status=\"ok\"]{--evo-diag-tone:var(--dsw-alias-state-success-primary)}",
+			".evo-diag-item[data-status=\"warn\"]{--evo-diag-tone:var(--dsw-alias-state-warn-primary)}",
+			".evo-diag-item[data-status=\"fail\"]{--evo-diag-tone:var(--dsw-alias-state-error-primary)}",
+			".evo-diag-item[data-status=\"unknown\"]{--evo-diag-tone:var(--dsw-alias-state-idle-primary)}",
+			".evo-diag-detail{display:block;margin:var(--evo-space-2) 0 0;color:var(--dsw-alias-label-secondary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base);overflow-wrap:anywhere}",
+			".evo-diag-remedy{display:block;margin:var(--evo-space-4) 0 0;color:var(--dsw-alias-label-tertiary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}"
+		].join("\n");
+		/**
+		* Inject the stylesheet once per document.
+		*
+		* S5-08: it RETURNS the disposer. The tag check alone answered only half the question - "is it
+		* there" - and left "who takes it away" to nobody, so a hot reload (unmount, remount) found the old
+		* tag, skipped the injection, and kept serving the PREVIOUS bundle CSS. skill-history hands its
+		* disposer back to the fiber; this is the same shape for the same concern.
+		* @param host - the document to inject into; defaults to the global one.
+		* @returns the disposal; a no-op when there is no document or the tag was already present.
+		*/
+		function injectStyles$1(host) {
+			const doc = host ?? globalThis.document;
+			if (doc === void 0) return () => {};
+			if (doc.querySelector("style[data-plugin-css=\"@lmzhen/dsh-evolution-ui/settings.css\"]") !== null) return () => {};
+			const tag = doc.createElement("style");
+			tag.dataset.plugin = "@lmzhen/dsh-evolution-ui";
+			tag.dataset.pluginCss = CSS_TAG_ID$1;
+			tag.textContent = CSS$1;
+			doc.head.appendChild(tag);
+			return () => {
+				tag.remove();
+			};
+		}
+		//#endregion
+		//#region src/panels/settings/index.ts
+		/** Section id and nav order (the platform's own sections sit at 0/10/15/20). */
+		const SECTION_ID = "evolution";
+		/**
+		* Register the locale namespace, the section, its cards, and the per-row configuration entries.
+		* @param ctx - client cordis context.
+		*/
+		function apply$2(ctx) {
+			ctx.effect(() => injectStyles$1(), "evolution-settings-ui: styles");
+			const seam = ctx;
+			let registered = false;
+			ctx.effect(() => {
+				try {
+					const dispose = seam.locale.register(NS$1, {
+						zh: zh$1,
+						en: en$1
+					});
+					registered = true;
+					return dispose;
+				} catch (error) {
+					ctx.logger.warn(`evolution-settings-ui: the locale seat refused the "${NS$1}" dictionary registration (${error instanceof Error ? error.message : String(error)}) — the cards fall back to the bundle's own copy`);
+					return () => {};
+				}
+			}, "evolution-settings: dictionaries");
+			let bound = null;
+			const translate = (key) => {
+				if (!registered) return message(key);
+				if (bound === null) try {
+					bound = seam.locale.bind(NS$1);
+				} catch {
+					return message(key);
+				}
+				return bound(key);
+			};
+			const t = (key, values) => values === void 0 ? translate(key) : fill$1(translate(key), values);
+			const probe = () => ctx.get("configForms");
+			const sources = createSourceCache(probe);
+			ctx.effect(() => () => {
+				sources.dispose();
+			}, "evolution-settings: sources");
+			const approvalSource = sources.sourceFor("evolution-approval");
+			const confirmMode = () => confirmModeFrom(approvalSource.getSnapshot().user);
+			ctx.inject?.(["configForms"], () => {
+				sources.revive();
+			});
+			seam.slots.inject("settings.section", function* () {
+				yield seam.slots.register({
+					name: "settings.section",
+					id: SECTION_ID,
+					order: 25,
+					label: () => t("title"),
+					locale: NS$1,
+					children: { [CARD_SLOT]: {
+						kind: "keyed",
+						scope: "root"
+					} }
+				}, SettingsSection);
+			});
+			seam.slots.inject(CARD_SLOT, function* () {
+				for (const section of CLIENT_PARAM_SECTIONS) {
+					const source = sources.sourceFor(section.seatKey);
+					const { mutateOnce, clear } = writeFaceFor(probe, section.namespace);
+					const face = () => ({
+						namespace: section.namespace,
+						fields: section.fields,
+						t,
+						mutateOnce,
+						clear,
+						hooks: { paramSection: source }
+					});
+					yield seam.slots.register({
+						name: CARD_SLOT,
+						key: section.namespace,
+						inject: face
+					}, ParamCard);
+				}
+				const api = createApprovalApi((input, init) => fetch(input, init));
+				yield seam.slots.register({
+					name: CARD_SLOT,
+					key: PENDING_CARD_KEY,
+					inject: () => ({
+						t,
+						api,
+						confirmMode,
+						fallback: FALLBACKS.approval
+					})
+				}, PendingCard);
+				const diagApi = createDiagnosticsApi((input, init) => fetch(input, init));
+				yield seam.slots.register({
+					name: CARD_SLOT,
+					key: DIAGNOSTICS_CARD_KEY,
+					inject: () => ({
+						t,
+						api: diagApi,
+						fallback: FALLBACKS.diagnostics
+					})
+				}, DiagnosticsCard);
+			});
+			seam.slots.inject(ROW_CONFIG_SLOT, function* () {
+				for (const seat of CLIENT_ROW_SEATS) for (const rowId of seat.rows) {
+					const section = CLIENT_PARAM_SECTIONS.find((candidate) => candidate.namespace === rowId);
+					if (section === void 0) continue;
+					const face = () => ({
+						namespace: rowId,
+						fields: section.fields,
+						t
+					});
+					yield seam.slots.register({
+						name: ROW_CONFIG_SLOT,
+						key: rowConfigKey(seat.bundle, rowId),
+						inject: face
+					}, RowConfigCard);
+				}
+			});
+		}
+		//#endregion
+		//#region ../evolution-client-kit/src/panel.ts
+		function interpolate(text, values) {
+			if (values === void 0) return text;
+			return text.replace(/\{(\w+)\}/g, (_match, key) => String(values[key] ?? ""));
+		}
+		function injectStyles(doc, css, tagId) {
+			if (doc === void 0) return () => {};
+			if (doc.querySelector("style[data-plugin-css=\"" + tagId + "\"]") !== null) return () => {};
+			const tag = doc.createElement("style");
+			tag.setAttribute("data-plugin-css", tagId);
+			tag.textContent = css;
+			doc.head.append(tag);
+			return () => {
+				tag.remove();
+			};
+		}
+		/**
+		* Register one sidebar row and its main body under one lifecycle.
+		* @param ctx - the client context carrying the slots and locale seats.
+		* @param spec - the feature-specific row/body descriptor.
+		*/
+		function registerSidebarPanel(ctx, spec) {
+			const seam = ctx;
+			let registered = false;
+			ctx.effect(() => {
+				try {
+					const dispose = seam.locale.register(spec.namespace, spec.dictionaries);
+					registered = true;
+					return dispose;
+				} catch (error) {
+					ctx.logger.warn(spec.namespace + ": the locale seat refused the dictionary (" + String(error) + "); the panel falls back to the bundle copy");
+					return () => {};
+				}
+			}, spec.namespace + ": locale");
+			ctx.effect(() => injectStyles(typeof document === "undefined" ? void 0 : document, spec.styles.css, spec.styles.tagId), spec.namespace + ": styles");
+			const fallback = spec.dictionaries[spec.fallback ?? "zh"];
+			const lookup = (key) => {
+				const own = fallback[key] ?? key;
+				if (!registered) return own;
+				try {
+					return seam.locale.bind(spec.namespace)(key);
+				} catch {
+					return own;
+				}
+			};
+			const t = (key, values) => interpolate(lookup(key), values);
+			const label = () => lookup("entry.label");
+			seam.slots.inject("sidebar.panellist", function* () {
+				yield seam.slots.register({
+					name: "sidebar.panellist",
+					id: spec.id,
+					order: spec.order,
+					label
+				}, spec.icon);
+				yield seam.slots.register({
+					name: "main",
+					key: spec.id,
+					inject: () => spec.body(t)
+				}, spec.component);
+			});
+		}
+		//#endregion
+		//#region src/panels/history/client/api.ts
+		/**
+		* The host routes this bundle calls, and the ONE place a request is made.
+		*
+		* G5/W7: the paths come from the generated client route table (rendered from evolution-core
+		* HOST_ROUTES), and the transport classifier is the shared generated route-client — the browser half
+		* can no longer drift from the host table or grow a second HTTP vocabulary.
+		* @module @lmzhen/dsh-evolution-ui/panels/history/client
+		*/
+		/** Route paths: the generated mirror of the host's HOST_ROUTES (one declaration in core). */
+		const HOST_ROUTES = ROUTES["skill-history"];
+		/**
+		* A refusal the host reported, carrying its own sentence (the curator's, not ours) and the classified
+		* four-state failure so the panel can render the shared failure block (G5/W7 S6b).
+		*/
+		var SkillHistoryRefusal = class extends Error {
+			failure;
+			constructor(failure) {
+				super(failureMessage(failure));
+				this.name = "SkillHistoryRefusal";
+				this.failure = failure;
+			}
+		};
+		/**
+		* Build the panel's face over one fetch implementation.
+		* @param fetchImpl - the fetch to use; a spec passes a stub.
+		* @returns the three callbacks the component receives through its inject face.
+		*/
+		function createSkillHistoryApi(fetchImpl = fetch) {
+			const request = async (path, init) => {
+				const answer = await requestJson(fetchImpl, path, init);
+				if (!answer.ok) throw new SkillHistoryRefusal(answer.failure);
+				return answer.data;
+			};
+			return {
+				skills: async () => await request(HOST_ROUTES.skills),
+				versions: async (name) => await request(HOST_ROUTES.versions + "?name=" + encodeURIComponent(name)),
+				diff: async (name, v) => await request(HOST_ROUTES.diff + "?name=" + encodeURIComponent(name) + "&v=" + String(v)),
+				body: async (name, v) => await request(HOST_ROUTES.body + "?name=" + encodeURIComponent(name) + "&v=" + String(v)),
+				undo: async (name, v, unitId) => {
+					return (await request(HOST_ROUTES.undo, {
+						method: "POST",
+						headers: { "content-type": "application/json" },
+						body: JSON.stringify(unitId !== void 0 && unitId !== "" ? {
+							name,
+							unitId
+						} : v === void 0 ? { name } : {
+							name,
+							v
+						})
+					})).message;
+				}
+			};
+		}
+		//#endregion
+		//#region src/panels/history/client/messages.ts
+		/**
+		* Panel copy, in a zh/en dictionary registered through the platform’s locale seat.
+		*
+		* Client copy is locale-owned: the entry label, the group headings, the actions, the version facts
+		* (action words, relative time, deltas) and the status lines all resolve here, and the panel carries
+		* no literal string of its own. Facts come from the host; only the WORDS live here.
+		* @module @lmzhen/dsh-evolution-ui/panels/history/client
+		*/
+		/** The locale namespace this bundle registers. */
+		const NS = "evolution-skill-history";
+		/** Chinese dictionary. */
+		const zh = {
+			"entry.label": "技能历史",
+			title: "技能历史",
+			hint: "每次技能写入留下的内容版本。回退只改 SKILL.md 正文，标记、使用计数与策展状态不变。内容相同的版本会同时标「当前」。",
+			search: "按名字或描述筛选",
+			"search.none": "没有匹配的技能。",
+			"group.content": "正文版本",
+			"group.support": "文件版本（不可回退）",
+			"group.support.note": "附带文件的字节与正文共用一份索引；回退不恢复它们。",
+			"empty.skills": "还没有技能留下过内容版本。",
+			"empty.versions": "这个技能还没有记录版本。",
+			"empty.versions.failed": "版本读取失败——这个技能有没有版本，现在判断不了；点「刷新」重试。",
+			"empty.pick": "从左栏选一个技能，看它记录过的版本。",
+			loading: "读取中…",
+			refresh: "刷新",
+			undo: "回退到此版",
+			"failure.unauthorized": "需要登录：重新打开这个页面完成登录后再试。",
+			"failure.forbidden": "平台拒绝了这个请求（身份不是 owner）。",
+			"failure.unmounted": "该功能没有挂载。",
+			"failure.server": "读取失败，可以重试。",
+			"fallback.hint": "可以改用命令：{command}",
+			"undo.confirm": "确认回退",
+			"undo.no": "取消",
+			current: "当前",
+			"versions.count": "{n} 个版本",
+			"row.version": "v{n}",
+			"row.first": "初始版本",
+			"row.summary.missing": "（未生成摘要）",
+			"row.delta.up": "（+{n} 字符）",
+			"row.delta.down": "（-{n} 字符）",
+			"diff.show": "差异",
+			"diff.source": "源码",
+			"preview.show": "预览",
+			"preview.hide": "收起预览",
+			"preview.truncated": "正文过长：只显示前 {shown} 个字符（共 {total} 个）",
+			"path.unrecorded": "（路径未记录）",
+			"diff.rendered": "渲染",
+			"markdown.copy": "复制",
+			"markdown.copied": "已复制",
+			"markdown.footnotes": "脚注",
+			"diff.hide": "收起差异",
+			"diff.loading": "读取差异…",
+			"diff.against": "与 v{n} 比较",
+			"diff.first": "这是第一版，整篇都是新增",
+			"diff.truncated": "差异过长，只显示前一部分",
+			"diff.added": "新增 {n} 行",
+			"diff.removed": "删除 {n} 行",
+			"state.managed": "家族管理",
+			"state.foreign": "非家族管理",
+			"state.protected": "受保护",
+			"state.unknown": "标记不可读",
+			"action.baseline": "初始快照",
+			"action.create": "新建",
+			"action.patch": "定点修改",
+			"action.update": "整篇更新",
+			"action.restore": "回退",
+			"action.delete": "删除",
+			"action.delete.note": "这一版存的是被删掉的正文",
+			"action.archive": "归档",
+			"action.archive.note": "这一版存的是被归档的正文",
+			"action.consolidate": "合并",
+			"action.restructure": "结构调整",
+			"action.extract": "跨技能提取",
+			"action.support-write": "写入附带文件",
+			"action.support-remove": "删除附带文件",
+			"action.other": "其他写入",
+			"time.now": "刚刚",
+			"time.minutes": "{n} 分钟前",
+			"time.minutes.one": "1 分钟前",
+			"time.hours": "{n} 小时前",
+			"time.hours.one": "1 小时前",
+			"time.days": "{n} 天前",
+			"time.days.one": "1 天前",
+			"time.months": "{n} 个月前",
+			"time.months.one": "1 个月前",
+			"time.years": "{n} 年前",
+			"time.years.one": "1 年前",
+			error: "读取失败",
+			"error.hint": "面板读不到宿主路由：通常是插件版本与宿主不匹配。请重启 DeepSeek Harness 后重试；仍不行就在对话里说明。"
+		};
+		/** English dictionary: the same keys, or the panel falls back to the key itself. */
+		const en = {
+			"entry.label": "Skill history",
+			title: "Skill history",
+			hint: "The content versions every skill write leaves behind. Restoring changes the SKILL.md body only: markers, usage counts and curation state stay as they are. Versions holding the same content are all marked “current”.",
+			search: "Filter by name or description",
+			"search.none": "No skill matches.",
+			"group.content": "Body versions",
+			"group.support": "File versions (not restorable)",
+			"group.support.note": "Support-file bytes share this index with the body; restoring the body does not bring them back.",
+			"empty.skills": "No skill has recorded a content version yet.",
+			"empty.versions": "This skill has no recorded versions.",
+			"empty.versions.failed": "The version read FAILED - whether this skill has versions is unknown right now; use Refresh to retry.",
+			"empty.pick": "Pick a skill on the left to see the versions it recorded.",
+			loading: "Loading…",
+			refresh: "Refresh",
+			undo: "Restore this version",
+			"failure.unauthorized": "Sign-in is required: reopen this page and sign in, then retry.",
+			"failure.forbidden": "The platform refused this request (not the owner principal).",
+			"failure.unmounted": "This feature is not mounted.",
+			"failure.server": "The read failed; you can retry.",
+			"fallback.hint": "Command fallback: {command}",
+			"undo.confirm": "Confirm restore",
+			"undo.no": "Cancel",
+			current: "Current",
+			"versions.count": "{n} versions",
+			"row.version": "v{n}",
+			"row.first": "First version",
+			"row.summary.missing": "(no summary generated)",
+			"row.delta.up": "(+{n} chars)",
+			"row.delta.down": "(-{n} chars)",
+			"diff.show": "Diff",
+			"diff.source": "Source",
+			"preview.show": "Preview",
+			"preview.hide": "Hide preview",
+			"preview.truncated": "the body is long: showing the first {shown} of {total} characters",
+			"path.unrecorded": "(path not recorded)",
+			"diff.rendered": "Rendered",
+			"markdown.copy": "Copy",
+			"markdown.copied": "Copied",
+			"markdown.footnotes": "Footnotes",
+			"diff.hide": "Hide diff",
+			"diff.loading": "Loading the diff…",
+			"diff.against": "compared with v{n}",
+			"diff.first": "first version: everything is new",
+			"diff.truncated": "the change is long; only its beginning is shown",
+			"diff.added": "{n} lines added",
+			"diff.removed": "{n} lines removed",
+			"state.managed": "family-managed",
+			"state.foreign": "not family-managed",
+			"state.protected": "protected",
+			"state.unknown": "marker unreadable",
+			"action.baseline": "initial snapshot",
+			"action.create": "created",
+			"action.patch": "targeted edit",
+			"action.update": "whole-body update",
+			"action.restore": "restored",
+			"action.delete": "deleted",
+			"action.delete.note": "this version holds the removed body",
+			"action.archive": "archived",
+			"action.archive.note": "this version holds the archived body",
+			"action.consolidate": "merged",
+			"action.restructure": "restructured",
+			"action.extract": "extracted across skills",
+			"action.support-write": "support file written",
+			"action.support-remove": "support file removed",
+			"action.other": "other write",
+			"time.now": "just now",
+			"time.minutes": "{n} minutes ago",
+			"time.minutes.one": "1 minute ago",
+			"time.hours": "{n} hours ago",
+			"time.hours.one": "1 hour ago",
+			"time.days": "{n} days ago",
+			"time.days.one": "1 day ago",
+			"time.months": "{n} months ago",
+			"time.months.one": "1 month ago",
+			"time.years": "{n} years ago",
+			"time.years.one": "1 year ago",
+			error: "Could not load",
+			"error.hint": "The panel could not reach the host routes — usually a plugin/host version mismatch. Restart DeepSeek Harness and retry; if it persists, ask in the conversation."
+		};
+		/**
+		* Fill one TEMPLATE’s `{n}` slots. The seat resolves the key, this fills it, so the panel needs
+		* only the seat plus this rule and never learns which language it is rendering.
+		* @param template - the copy, with `{slot}` placeholders.
+		* @param values - the substitutions, keyed by the slot name inside the braces.
+		* @returns the filled copy.
+		*/
+		function fill(template, values) {
+			return template.replace(/\{(\w+)\}/g, (match, slot) => {
+				const value = values[slot];
+				return value === void 0 ? match : String(value);
+			});
+		}
+		//#endregion
+		//#region src/panels/history/client/styles.ts
+		/**
+		* The panel’s stylesheet, injected once behind a `<style data-plugin-css=…>` tag.
+		*
+		* TWO FACES, ONE SCALE. The TOOL face (`.evo-hist-*`) is the compact list and its controls; the
+		* READING face (`.evo-doc-*`, at the end) is a version rendered as a document. Each face owns its
+		* rules and they never overlap: the list may be dense and full of controls, a document may not. That
+		* is the whole reason for two prefixes — a rule that serves one face can no longer fight the other’s
+		* comfort, and a third face would be another block rather than an edit here (§15.2 L2b, W22).
+		*
+		* Every colour is a platform design token; every type step and every geometry value is a family scale
+		* token (`./tokens.ts`, generated from `packages/scripts/client-tokens.json`), so the two client
+		* halves of this family cannot drift apart.
+		*
+		* The metrics themselves are COPIED from the platform’s own components rather than invented:
+		*
+		* - the code block (`--dsw-font-markdown-code-block-small`, `0.5px` border, `12px` padding, radius
+		*   `12px`, `max-height: 260px`) is the platform command card’s `<pre>` (client/ui-chat/…/GenericCommandCard.module.css);
+		* - hover / focus (`--dsw-alias-interactive-bg-hover`, a 2px inset focus ring) follow the platform
+		*   sidebar row (client/ui-sidebar/…/SidebarRoot.module.css);
+		* - the field radius (`8px`) is the platform’s own Input primitive (client/ui-primitives/Input.module.css);
+		* - the panel’s type steps come from the family scale, which is relative to the shell’s chrome size —
+		*   NOT the setting behind `--dsh-content-font-size*` (that one says it affects conversation content
+		*   only, and the platform’s own surfaces never read it). The step is relative, so the panel scales
+		*   with the shell, not with the conversation: the dense list needs it — at the raw chrome size
+		*   `dsh-evolution-maintenance` truncates in 264px.
+		* @module @lmzhen/dsh-evolution-ui/panels/history/client
+		*/
+		/** Tag id that makes the injection idempotent. */
+		const CSS_TAG_ID = "@lmzhen/dsh-evolution-ui/panel.css";
+		/** The stylesheet the panel injects once. */
+		const CSS = [
+			tokenVars(".evo-hist-root"),
+			".evo-hist-root{display:flex;height:100%;min-height:0;min-width:0;font-size:var(--evo-type-sm);color:var(--dsw-alias-label-primary)}",
+			".evo-hist-aside{display:flex;flex-direction:column;flex:0 0 var(--evo-cap-aside);width:var(--evo-cap-aside);min-height:0;border-right:var(--evo-hairline-width) solid var(--dsw-alias-border-l2)}",
+			".evo-hist-search{padding:var(--evo-space-12) var(--evo-space-12) var(--evo-space-4)}",
+			".evo-hist-search input{width:100%;box-sizing:border-box;padding:var(--evo-space-6) var(--evo-space-10);border:var(--evo-hairline-width) solid var(--dsw-alias-border-l2);border-radius:var(--evo-radius-control);background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-primary);font:inherit}",
+			".evo-hist-search input:focus-visible{outline:var(--evo-focus-ring);outline-offset:var(--evo-focus-offset)}",
+			".evo-hist-list{flex:1 1 auto;min-height:0;overflow-y:auto;padding:var(--evo-space-4) var(--evo-space-12) var(--evo-space-10)}",
+			".evo-hist-empty{padding:var(--evo-space-6) var(--evo-space-8);margin:0;color:var(--dsw-alias-label-tertiary)}",
+			".evo-hist-skill{display:block;width:100%;box-sizing:border-box;padding:var(--evo-space-6) var(--evo-space-8);border:0;border-radius:var(--evo-radius-control);background:transparent;color:var(--dsw-alias-label-secondary);font:inherit;text-align:left;cursor:pointer}",
+			".evo-hist-skill:hover{background:var(--dsw-alias-interactive-bg-hover)}",
+			".evo-hist-skill:focus-visible{outline:var(--evo-focus-ring);outline-offset:var(--evo-focus-offset)}",
+			".evo-hist-skill[aria-current=\"true\"]{background:var(--dsw-alias-interactive-bg-active);color:var(--dsw-alias-label-primary);font-weight:500}",
+			".evo-hist-cell-line{display:flex;align-items:baseline;gap:var(--evo-space-6);min-width:0}",
+			".evo-hist-cell-meta{margin-top:var(--evo-space-2)}",
+			".evo-hist-cell{min-width:0;font-variant-numeric:tabular-nums}",
+			".evo-hist-slot-lead{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
+			".evo-hist-slot-meta{flex:none;white-space:nowrap}",
+			".evo-hist-slot-aside{flex:none;margin-left:auto;white-space:nowrap}",
+			".evo-hist-tone-primary{color:inherit}",
+			".evo-hist-tone-secondary{color:var(--dsw-alias-label-secondary)}",
+			".evo-hist-tone-tertiary{color:var(--dsw-alias-label-tertiary)}",
+			".evo-hist-main{flex:1 1 auto;min-width:0;min-height:0;overflow-y:auto;padding:var(--evo-space-12) var(--evo-space-12)}",
+			".evo-hist-head{display:flex;align-items:center;gap:var(--evo-space-10);margin:0 0 var(--evo-space-4)}",
+			".evo-hist-title{flex:1 1 auto;margin:0;font-size:var(--evo-type-lg);font-weight:600}",
+			".evo-hist-hint{margin:0 0 var(--evo-space-10);color:var(--dsw-alias-label-secondary);line-height:var(--evo-leading-base)}",
+			".evo-hist-note{display:flex;align-items:flex-start;gap:var(--evo-space-6);margin:0 0 var(--evo-space-10);color:var(--dsw-alias-label-secondary);line-height:var(--evo-leading-base)}",
+			".evo-hist-note-text{min-width:0;white-space:pre-wrap}",
+			".evo-hist-note[data-error=\"true\"]{color:var(--evo-tone-danger);background:var(--dsw-alias-bg-layer-2);border:var(--evo-hairline-width) solid var(--evo-tone-danger);border-radius:var(--evo-radius-control);padding:var(--evo-space-8) var(--evo-space-10)}",
+			".evo-hist-icon{flex:none;margin-top:.15em}",
+			".evo-hist-group{margin:var(--evo-space-16) 0 var(--evo-space-4);font-size:var(--evo-type-sm);font-weight:600;color:var(--dsw-alias-label-secondary)}",
+			".evo-hist-row{display:flex;align-items:flex-start;gap:var(--evo-space-8);padding:var(--evo-space-8) 0;border-top:var(--evo-hairline-width) solid var(--dsw-alias-border-l2);max-width:calc(var(--evo-measure-read) * 1.5);color:var(--dsw-alias-label-primary)}",
+			".evo-hist-row:first-of-type{border-top:0}",
+			".evo-hist-row-body{flex:1 1 auto;min-width:0}",
+			".evo-hist-row-title{display:flex;align-items:baseline;gap:var(--evo-space-8);min-width:0}",
+			".evo-hist-row-summary{margin-top:var(--evo-space-2);line-height:var(--evo-leading-base)}",
+			".evo-hist-actions{display:flex;flex:none;align-items:center;gap:var(--evo-space-6)}",
+			".evo-hist-chip{flex:none;padding:var(--evo-space-2) var(--evo-space-8);border-radius:var(--evo-radius-pill);background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-secondary)}",
+			".evo-hist-button{display:inline-flex;flex:none;align-items:center;gap:var(--evo-space-2);font:inherit;padding:var(--evo-space-4) var(--evo-space-10);border:var(--evo-hairline-width) solid var(--dsw-alias-border-l2);border-radius:var(--evo-radius-control);background:transparent;color:var(--evo-tone-quiet);cursor:pointer}",
+			".evo-hist-button[data-kind=\"toggle\"],.evo-hist-button[data-kind=\"switch\"]{padding:var(--evo-space-2) var(--evo-space-4);border-color:transparent;color:var(--evo-tone-quiet)}",
+			".evo-hist-button[data-kind=\"switch\"][aria-pressed=\"true\"]{color:var(--dsw-alias-label-primary)}",
+			".evo-hist-button:hover{background:var(--dsw-alias-interactive-bg-hover)}",
+			".evo-hist-button:focus-visible{outline:var(--evo-focus-ring);outline-offset:var(--evo-focus-offset)}",
+			".evo-hist-button[data-tone=\"primary\"]{border-color:var(--evo-tone-primary);color:var(--evo-tone-primary)}",
+			".evo-doc-preview{margin:var(--evo-space-6) 0 var(--evo-space-2);max-width:var(--evo-measure-read);line-height:var(--evo-leading-base)}",
+			".evo-doc-diff{display:flex;flex-direction:column;gap:var(--evo-space-8)}",
+			".evo-doc-head{display:flex;align-items:center;gap:var(--evo-space-8);max-width:var(--evo-measure-read)}",
+			".evo-doc-head .evo-hist-note{flex:1 1 auto;margin:0}",
+			".evo-doc-toggle{display:flex;flex:none;align-items:center;gap:var(--evo-space-6)}",
+			".evo-doc-fact+.evo-doc-fact::before{content:\"·\";margin:0 var(--evo-space-6);color:var(--dsw-alias-label-tertiary)}",
+			".evo-doc-source{margin:var(--evo-space-6) 0 var(--evo-space-2);padding:var(--evo-space-12) var(--evo-space-16);max-height:var(--evo-cap-block);overflow:auto;border:var(--evo-hairline-width) solid var(--dsw-alias-border-l1);border-radius:var(--evo-radius-surface);background:var(--dsw-alias-markdown-code-block);color:var(--dsw-alias-label-primary);font:var(--dsw-font-markdown-code-block-small);white-space:pre-wrap}",
+			".evo-doc-render{display:flex;flex-direction:column;gap:var(--evo-space-8);margin:var(--evo-space-6) 0 var(--evo-space-2);max-width:var(--evo-measure-read)}",
+			".evo-doc-block{position:relative;padding:var(--evo-space-8) var(--evo-space-12) var(--evo-space-8) var(--evo-space-20);border:var(--evo-hairline-width) solid var(--dsw-alias-border-l2);border-left-width:var(--evo-hairline-marker);border-radius:var(--evo-radius-surface);background:var(--dsw-alias-markdown-code-block);overflow-x:auto}",
+			".evo-doc-del{border-left-color:var(--evo-tone-danger)}",
+			".evo-doc-add{border-left-color:var(--evo-tone-success)}",
+			".evo-doc-tag{position:absolute;left:var(--evo-space-8);top:var(--evo-space-8);color:var(--dsw-alias-label-tertiary)}",
+			".evo-doc-line-add{color:var(--evo-tone-success)}",
+			".evo-doc-line-del{color:var(--evo-tone-danger)}"
+		].join("\n");
+		//#endregion
+		//#region src/panels/history/client/atoms.ts
+		/**
+		* The four atoms the panel's tool face is built from (G3, §15.2 L2a atoms).
+		*
+		* Why atoms at all: the row used to be assembled from five different elements that each wrote their
+		* own classes, so "what a control looks like" was spread over the stylesheet and a click target, a
+		* state chip, a refusal and a glyph had no vocabulary at all (W7/W9/W13/W14). Every interactive
+		* element now says what it IS — a control that acts, a control that only reveals more, a state, a
+		* notice — and the stylesheet answers once per kind.
+		*
+		* No words live here: an atom takes the copy its caller already resolved.
+		* @module @lmzhen/dsh-evolution-ui/panels/history/client
+		*/
+		/** The stroked path of one glyph, in a 16x16 box. */
+		const PATHS = {
+			"chevron-right": ["M6.5 3.5L11 8l-4.5 4.5"],
+			"chevron-down": ["M3.5 6.5L8 11l4.5-4.5"],
+			alert: [
+				"M8 2.5l5.5 10.5h-11z",
+				"M8 6.6v3.1",
+				"M8 11.4h.01"
+			]
+		};
+		/**
+		* One drawn glyph.
+		* @param name - which glyph.
+		* @returns an inline SVG that takes the surrounding colour and type size.
+		*/
+		function icon(name) {
+			return (0, react.createElement)("svg", {
+				className: "evo-hist-icon",
+				viewBox: "0 0 16 16",
+				width: "1em",
+				height: "1em",
+				fill: "none",
+				stroke: "currentColor",
+				strokeWidth: 1.5,
+				strokeLinecap: "round",
+				strokeLinejoin: "round",
+				"aria-hidden": "true",
+				focusable: "false"
+			}, PATHS[name].map((d, index) => (0, react.createElement)("path", {
+				key: index,
+				d
+			})));
+		}
+		/**
+		* One control.
+		* @param props - what it is, how it speaks, and what it does.
+		* @returns the button element.
+		*/
+		function button(props) {
+			const { children, kind = "action", tone = "quiet", title, expanded, pressed, onClick } = props;
+			return (0, react.createElement)("button", {
+				key: props.key,
+				type: "button",
+				className: "evo-hist-button",
+				"data-kind": kind,
+				"data-tone": tone,
+				title,
+				"aria-expanded": expanded,
+				"aria-pressed": pressed,
+				onClick
+			}, kind === "toggle" ? icon(expanded === true ? "chevron-down" : "chevron-right") : null, children);
+		}
+		/**
+		* One state, spelled as a chip: never clickable, never in the primary colour (W9).
+		* @param props - the copy.
+		* @returns the chip element.
+		*/
+		function chip(props) {
+			return (0, react.createElement)("span", {
+				key: props.key,
+				className: "evo-hist-chip"
+			}, props.children);
+		}
+		/**
+		* One notice.
+		* @param props - the copy, and whether it reports a failure.
+		* @returns the note element.
+		*/
+		function note(props) {
+			return (0, react.createElement)("p", {
+				key: props.key,
+				className: "evo-hist-note",
+				"data-error": props.error === true ? "true" : void 0
+			}, props.error === true ? icon("alert") : null, (0, react.createElement)("span", { className: "evo-hist-note-text" }, props.children));
+		}
+		//#endregion
+		//#region src/panels/history/client/chrome.ts
+		/**
+		* The TOOL face: the skill list, the version list, and the controls that act on a version.
+		*
+		* This file renders FACTS. What a row says, in which order and in which slot is decided in core
+		* (`skill-row-cells.ts`) and travels with the row, because a browser half cannot import core at
+		* runtime; the words come from the locale dictionary through the `Copy` seat. The renderer's only
+		* judgements are layout: a cell's slot decides its alignment, and the `aside` slot is the one the
+		* browser's ellipsis may never eat (W1).
+		*
+		* The reading face — a version rendered as a document, and the rendered diff — lives in
+		* `document.ts`; the two faces share the scale in `tokens.ts` and nothing else (§15.2 L2b).
+		* @module @lmzhen/dsh-evolution-ui/panels/history/client
+		*/
+		/** The local time an ISO timestamp names, as the operator's own clock shows it. */
+		function localTime(at) {
+			const parsed = Date.parse(at);
+			if (Number.isNaN(parsed)) return at;
+			const date = new Date(parsed);
+			const pad = (value) => String(value).padStart(2, "0");
+			return String(date.getFullYear()) + "-" + pad(date.getMonth() + 1) + "-" + pad(date.getDate()) + " " + pad(date.getHours()) + ":" + pad(date.getMinutes());
+		}
+		/** The text one cell shows, resolved through the seat. */
+		function cellText(copy, cell) {
+			if (!("copy" in cell)) return cell.literal;
+			return cell.values === void 0 ? copy.t(cell.copy) : copy.format(cell.copy, cell.values);
+		}
+		/**
+		* One line of cells. The slot decides placement; the tone only changes the register.
+		* @param cells - the cells of this line, in reading order.
+		* @param copy - the dictionary seat.
+		* @param className - the line's own class.
+		* @param hover - hover text the host cannot express (the local clock), by cell key.
+		* @returns the line element.
+		*/
+		function cellLine(cells, copy, className, hover = {}) {
+			return (0, react.createElement)("div", { className }, cells.map((cell) => (0, react.createElement)("span", {
+				key: cell.key,
+				className: "evo-hist-cell evo-hist-slot-" + cell.slot + " evo-hist-tone-" + cell.tone,
+				title: hover[cell.key] ?? cell.note
+			}, cellText(copy, cell))));
+		}
+		/** The search field above the list. */
+		function searchField(copy, query, onQuery) {
+			return (0, react.createElement)("div", { className: "evo-hist-search" }, (0, react.createElement)("input", {
+				type: "search",
+				value: query,
+				placeholder: copy.t("search"),
+				"aria-label": copy.t("search"),
+				onChange: (event) => {
+					onQuery(event.target.value);
+				}
+			}));
+		}
+		/**
+		* One skill in the left column: its name and size, then what it is and when it last changed.
+		* @param copy - the dictionary seat.
+		* @param row - the skill's facts and cells.
+		* @param selected - whether this is the open skill.
+		* @param onOpen - what a click does.
+		* @returns the row.
+		*/
+		function skillLine(copy, row, selected, onOpen) {
+			return (0, react.createElement)("button", {
+				key: row.name,
+				type: "button",
+				className: "evo-hist-skill",
+				"aria-current": selected ? "true" : void 0,
+				onClick: onOpen
+			}, cellLine(row.cells.title, copy, "evo-hist-cell-line"), cellLine(row.cells.meta, copy, "evo-hist-cell-line evo-hist-cell-meta"));
+		}
+		/**
+		* One version row: what happened, when, how big — then the controls, then whatever is expanded.
+		*
+		* The write is the only control that can change anything, and it is the only one that ever takes the
+		* primary tone; a toggle that merely reveals more is borderless and carries a drawn chevron, so the
+		* two kinds cannot be mistaken for each other (W7/W14).
+		* @param props - the row, the copy, and the panel's callbacks.
+		* @returns the row.
+		*/
+		function versionRow(props) {
+			const { copy, row, confirming, open, expanded, onRestore, onCancel, onToggle } = props;
+			const actions = [];
+			if (row.undoable === false) actions.push(chip({
+				key: "current",
+				children: copy.t("current")
+			}));
+			if (row.undoable === true) {
+				if (confirming) actions.push(button({
+					key: "cancel",
+					onClick: onCancel,
+					children: copy.t("undo.no")
+				}));
+				actions.push(button({
+					key: "undo",
+					tone: confirming ? "primary" : "quiet",
+					onClick: onRestore,
+					children: confirming ? copy.t("undo.confirm") : copy.t("undo")
+				}));
+			}
+			if (row.undoable === true || row.charsDelta !== void 0) actions.push(button({
+				key: "diff",
+				kind: "toggle",
+				expanded: open === "diff",
+				onClick: () => {
+					onToggle("diff");
+				},
+				children: open === "diff" ? copy.t("diff.hide") : copy.t("diff.show")
+			}));
+			actions.push(button({
+				key: "preview",
+				kind: "toggle",
+				expanded: open === "preview",
+				onClick: () => {
+					onToggle("preview");
+				},
+				children: open === "preview" ? copy.t("preview.hide") : copy.t("preview.show")
+			}));
+			return (0, react.createElement)("div", {
+				key: String(row.v),
+				className: "evo-hist-row"
+			}, (0, react.createElement)("div", { className: "evo-hist-row-body" }, cellLine(row.cells.title, copy, "evo-hist-row-title", { time: localTime(row.at) }), row.cells.meta.length === 0 ? null : cellLine(row.cells.meta, copy, "evo-hist-row-summary"), expanded), (0, react.createElement)("div", { className: "evo-hist-actions" }, actions));
+		}
+		/**
+		* One group's heading, and the note that explains the group.
+		* @param title - the group's name, already resolved.
+		* @param noteText - the group's note, when it has one.
+		* @returns the heading and the note, for the caller to place in its own section.
+		*/
+		function groupHeading(title, noteText) {
+			return [(0, react.createElement)("h3", {
+				key: "title",
+				className: "evo-hist-group"
+			}, title), noteText === void 0 ? null : (0, react.createElement)("p", {
+				key: "note",
+				className: "evo-hist-hint"
+			}, noteText)];
+		}
+		/** What the list shows when it has nothing to show.
+		* S5-07: the sites that render it as a SIBLING in an array must pass a key - a keyless sibling made
+		* React warn on every render of the default view (measured: one warning per render, captured by spy).
+		*/
+		function emptyState(text, key) {
+			return (0, react.createElement)("p", {
+				key,
+				className: "evo-hist-empty"
+			}, text);
+		}
+		/** One notice about what just happened. */
+		function notice(text, error) {
+			if (text === void 0) return null;
+			return note({
+				error,
+				children: text
+			});
+		}
+		/** The pane's heading and its one control. */
+		function panelHead(copy, onRefresh) {
+			return (0, react.createElement)("div", { className: "evo-hist-head" }, (0, react.createElement)("h2", { className: "evo-hist-title" }, copy.t("title")), button({
+				key: "refresh",
+				title: copy.t("refresh"),
+				onClick: onRefresh,
+				children: copy.t("refresh")
+			}));
+		}
+		//#endregion
+		//#region src/panels/history/client/markdown.ts
+		/**
+		* The one seam onto the platform's Markdown renderer.
+		*
+		* Everything that renders Markdown in this panel goes through here, so the implementation can be
+		* swapped in one file: today it is the platform's own `MarkdownText` (reached through the client
+		* module table — zero bytes shipped, styles already in the shell, the same mdast pipeline the chat
+		* uses); if that ever stops being reachable, a self-drawn renderer replaces this module and nothing
+		* else changes.
+		*
+		* The words are NOT this module's: the face passes its locale dictionary in, because the platform
+		* component takes its chrome as props.
+		* @module @lmzhen/dsh-evolution-ui/panels/history/client
+		*/
+		/** The module-table specifier; kept in one place so the seam is the only reader. */
+		const PLATFORM_UI_MODULE = "@deepseek-ai/dsh-client-ui-primitives";
+		/**
+		* The renderer a module row carries, when it carries one.
+		*
+		* A React component type is NOT always a function: the platform's own `MarkdownText` is
+		* `memo(function MarkdownText …)`, and `memo` returns an OBJECT. A `typeof === 'function'` test
+		* therefore rejected the real renderer and silently degraded every view to its source — exactly
+		* what 0.14.0 shipped (measured on the installed panel 2026-09-28: `[预览]` and the rendered diff
+		* both fell back). The accepted domain is React's element-type domain: a function, or a non-null
+		* object it can mount. `tests/markdown.client.spec.ts` pins all four cases.
+		* @param row - what the client module table handed over.
+		* @returns the component, or undefined when the row carries none.
+		*/
+		function rendererOf(row) {
+			const candidate = row.MarkdownText;
+			if (typeof candidate === "function") return candidate;
+			if (typeof candidate === "object" && candidate !== null && candidate.$$typeof !== void 0) return candidate;
+		}
+		/**
+		* The platform component, when this deployment's module table carries one.
+		*
+		* A row that IS reachable without a renderer is not a render: reporting one would move the failure
+		* into the render itself, where only the slot's error boundary would catch it.
+		* @returns the component, or undefined when it cannot be reached.
+		*/
+		function markdownText() {
+			try {
+				return rendererOf(require(PLATFORM_UI_MODULE));
+			} catch {
+				return;
+			}
+		}
+		/**
+		* One document, rendered by the platform component under a labels object that survives re-renders.
+		*
+		* The component is memoized and the platform's own call sites memoize their labels for that reason:
+		* this panel re-renders on every keystroke in its search field, and a fresh labels object per render
+		* would take the whole document through the render again.
+		* @param props - the resolved component, the Markdown source, and the localized words.
+		* @returns the rendered document.
+		*/
+		function MarkdownBlock(props) {
+			const { component: MarkdownText, text, words } = props;
+			const { copy, copied, footnotes } = words;
+			return (0, react.createElement)(MarkdownText, {
+				text,
+				labels: (0, react.useMemo)(() => ({
+					code: {
+						copyLabel: copy,
+						copiedLabel: copied
+					},
+					footnotes
+				}), [
+					copy,
+					copied,
+					footnotes
+				])
+			});
+		}
+		/**
+		* Render one Markdown document to an element tree.
+		* @param text - the Markdown source (already bounded by the caller).
+		* @param words - the localized Markdown chrome.
+		* @returns the element, or `{ ok: false }` when the platform renderer is not reachable (the caller
+		*   then keeps its own source view: a missing renderer degrades the view, never the panel).
+		*/
+		function renderMarkdown(text, words) {
+			const component = markdownText();
+			if (component === void 0) return { ok: false };
+			return {
+				ok: true,
+				node: (0, react.createElement)(MarkdownBlock, {
+					component,
+					text,
+					words
+				})
+			};
+		}
+		//#endregion
+		//#region src/panels/history/client/document.ts
+		/**
+		* The READING face: one version rendered as a document, and the rendered diff.
+		*
+		* This file is the only place that decides how a document reads (G4). The tool face (`chrome.ts`)
+		* picks versions and acts on them; here the rules are the reader's, and they follow the positioning
+		* ruling of §14.0: a document is read, not scanned — one measure, page-like spacing, no inner scroll
+		* (W18/W20/W21/W22). Nothing here is a control except the source/rendered choice, which belongs to
+		* the reader rather than to the panel's actions.
+		*
+		* The text arrives already prepared: the host strips the frontmatter block through core's
+		* `displayBodyOf`, because a browser half cannot import core. The RENDERED DIFF keeps the whole text
+		* on purpose — a diff is about what CHANGED, and a metadata change is a change.
+		*
+		* It degrades rather than blanking: when the platform's renderer cannot be reached, the exact text is
+		* shown instead, and the reader can still read the version.
+		* @module @lmzhen/dsh-evolution-ui/panels/history/client
+		*/
+		/** One `<pre>` rendering of a diff: added lines marked `+`, removed ones `-`. */
+		function sourceBlock(diff) {
+			const rows = [];
+			for (const [hunkIndex, hunk] of diff.hunks.entries()) {
+				for (const [index, line] of hunk.oldText.split("\n").entries()) {
+					if (hunk.oldText === "" && line === "") continue;
+					rows.push((0, react.createElement)("div", {
+						key: "old-" + String(hunkIndex) + "-" + String(index),
+						className: "evo-doc-line-del"
+					}, "- " + line));
+				}
+				for (const [index, line] of hunk.newText.split("\n").entries()) {
+					if (hunk.newText === "" && line === "") continue;
+					rows.push((0, react.createElement)("div", {
+						key: "new-" + String(hunkIndex) + "-" + String(index),
+						className: "evo-doc-line-add"
+					}, "+ " + line));
+				}
+			}
+			return (0, react.createElement)("pre", { className: "evo-doc-source" }, rows.length === 0 ? "±" : rows);
+		}
+		/** One rendered side of a diff: an \u201cold\u201d or \u201cnew\u201d block under a tinted edge. */
+		function renderedSide(face, mark, side, text) {
+			const rendered = renderMarkdown(text, face.markdownWords);
+			if (!rendered.ok) return null;
+			return (0, react.createElement)("div", { className: "evo-doc-block evo-doc-" + side }, (0, react.createElement)("span", { className: "evo-doc-tag" }, mark), rendered.node);
+		}
+		/**
+		* The same diff, both sides rendered as Markdown and stacked: the removed text first, then the added
+		* one. Block level on purpose — line-level interleaving of two rendered documents is a different (and
+		* much larger) problem, and the source view stays one click away for exact bytes.
+		* @param face - the dictionary seat and the renderer's words.
+		* @param diff - the windowed change the host reported.
+		* @returns the stacked blocks, or null when the renderer is out.
+		*/
+		function renderedBlocks(face, diff) {
+			const blocks = [];
+			for (const [index, hunk] of diff.hunks.entries()) {
+				if (hunk.oldText !== "") {
+					const side = renderedSide(face, "−", "del", hunk.oldText);
+					if (side === null) return null;
+					blocks.push((0, react.createElement)("div", { key: "del-" + String(index) }, side));
+				}
+				if (hunk.newText !== "") {
+					const side = renderedSide(face, "+", "add", hunk.newText);
+					if (side === null) return null;
+					blocks.push((0, react.createElement)("div", { key: "add-" + String(index) }, side));
+				}
+			}
+			return blocks.length === 0 ? null : blocks;
+		}
+		/**
+		* One diff in the mode the reader asked for, degrading to the source view when the renderer is out.
+		* @param face - the dictionary seat and the renderer's words.
+		* @param diff - the windowed change the host reported.
+		* @param mode - source or rendered.
+		* @returns the element to draw.
+		*/
+		function diffView(face, diff, mode) {
+			if (mode === "rendered") {
+				const blocks = renderedBlocks(face, diff);
+				if (blocks !== null) return (0, react.createElement)("div", { className: "evo-doc-render" }, blocks);
+			}
+			return sourceBlock(diff);
+		}
+		/**
+		* One version read as a document: the platform renderer when it is there, plain text when it is not.
+		*
+		* The document is the page, not a card inside it: no border, no surface of its own and no inner
+		* scroll, so the pane's own scrollbar is the only one a reader meets (W20/W21). A body the host
+		* bounded says how much it is not showing, with both numbers (W23).
+		* @param props - the face and the body state to draw.
+		* @returns the element.
+		*/
+		function PreviewBody(props) {
+			const { face, body } = props;
+			if (body.kind === "loading") return note({ children: face.t("diff.loading") });
+			if (body.kind === "failed") return note({
+				error: true,
+				children: body.message
+			});
+			const rendered = renderMarkdown(body.body.display, face.markdownWords);
+			return (0, react.createElement)("div", { className: "evo-doc-preview" }, body.body.truncated ? note({ children: face.format("preview.truncated", {
+				shown: body.body.display.length,
+				total: body.body.chars
+			}) }) : null, rendered.ok ? rendered.node : (0, react.createElement)("pre", { className: "evo-doc-source" }, body.body.display));
+		}
+		/**
+		* The expanded body of one row: the diff, a loading line, or the refusal.
+		*
+		* The source/rendered choice is LOCAL to this view: which row is open is the panel's business, but
+		* how one open diff is displayed is not, so the state does not climb into the parent.
+		* @param props - the face and the diff state to draw.
+		* @returns the element.
+		*/
+		function DiffBody(props) {
+			const { face, diff } = props;
+			const [mode, setMode] = (0, react.useState)("source");
+			if (diff.kind === "loading") return note({ children: face.t("diff.loading") });
+			if (diff.kind === "failed") return note({
+				error: true,
+				children: diff.message
+			});
+			const against = diff.diff.against === null ? face.t("diff.first") : face.format("diff.against", { n: diff.diff.against });
+			const toggle = (0, react.createElement)("div", { className: "evo-doc-toggle" }, button({
+				key: "source",
+				kind: "switch",
+				pressed: mode === "source",
+				onClick: () => {
+					setMode("source");
+				},
+				children: face.t("diff.source")
+			}), button({
+				key: "rendered",
+				kind: "switch",
+				pressed: mode === "rendered",
+				onClick: () => {
+					setMode("rendered");
+				},
+				children: face.t("diff.rendered")
+			}));
+			return (0, react.createElement)("div", { className: "evo-doc-diff" }, (0, react.createElement)("div", { className: "evo-doc-head" }, note({ children: [
+				(0, react.createElement)("span", {
+					key: "against",
+					className: "evo-doc-fact"
+				}, against),
+				(0, react.createElement)("span", {
+					key: "added",
+					className: "evo-doc-fact"
+				}, face.format("diff.added", { n: diff.diff.linesAdded })),
+				(0, react.createElement)("span", {
+					key: "removed",
+					className: "evo-doc-fact"
+				}, face.format("diff.removed", { n: diff.diff.linesRemoved })),
+				diff.diff.truncated ? (0, react.createElement)("span", {
+					key: "truncated",
+					className: "evo-doc-fact"
+				}, face.t("diff.truncated")) : null
+			] }), toggle), diffView(face, diff.diff, mode));
+		}
+		//#endregion
+		//#region src/panels/history/client/Panel.ts
+		/**
+		* The panel: one read, one open skill, one open row — and the faces that draw them.
+		*
+		* Everything a PERSON reads is decided elsewhere: what a row says is core's (`skill-row-cells.ts`,
+		* shipped with the row), the words are the dictionary's, the tool face is `chrome.ts` and the reading
+		* face is `document.ts`. What is left here is the STATE — which skill is open, which row is expanded,
+		* which reads are in flight — and the two rules that only a state machine can hold: a read takes a
+		* ticket so a slow reply cannot land on another skill, and a write reports its own result instead of
+		* being erased by the read that follows it.
+		* @module @lmzhen/dsh-evolution-ui/panels/history/client
+		*/
+		/**
+		* The panel body.
+		* @param face - copy plus the data callbacks.
+		* @returns the panel element.
+		*/
+		/** Fill the generated block's `{slot}` copies with this bundle's dictionary. */
+		function fillCopy(template, values) {
+			return template.replace(/\{(\w+)\}/g, (match, slot) => {
+				const value = values[slot];
+				return value === void 0 ? match : String(value);
+			});
+		}
+		/** The shared four-state failure block, spoken through this bundle's keys. */
+		function failureBlock(t, failure) {
+			const translate = (key, values) => {
+				const text = t(key);
+				return values === void 0 ? text : fillCopy(text, values);
+			};
+			return FailureBlock({
+				failure,
+				t: translate,
+				fallback: FALLBACKS["skill-history"]
+			});
+		}
+		function SkillHistoryPanel(face) {
+			const [skills, setSkills] = (0, react.useState)([]);
+			const [skillsLoaded, setSkillsLoaded] = (0, react.useState)(false);
+			const [failure, setFailure] = (0, react.useState)(void 0);
+			const [selected, setSelected] = (0, react.useState)(void 0);
+			const [payload, setPayload] = (0, react.useState)(void 0);
+			const [versionsFailed, setVersionsFailed] = (0, react.useState)(void 0);
+			const [noteText, setNoteText] = (0, react.useState)(void 0);
+			const [noteError, setNoteError] = (0, react.useState)(false);
+			const [pending, setPending] = (0, react.useState)(void 0);
+			const [query, setQuery] = (0, react.useState)("");
+			const [expanded, setExpanded] = (0, react.useState)(void 0);
+			const [diffs, setDiffs] = (0, react.useState)(/* @__PURE__ */ new Map());
+			const [bodies, setBodies] = (0, react.useState)(/* @__PURE__ */ new Map());
+			const readTicket = (0, react.useRef)(0);
+			const failed = (error) => {
+				setNoteError(true);
+				setNoteText(face.t("error.hint") + "\n" + face.t("error") + ": " + (error instanceof Error ? error.message : String(error)));
+				setFailure(error instanceof SkillHistoryRefusal ? error.failure : {
+					kind: "server",
+					status: 0
+				});
+			};
+			const succeeded = (message) => {
+				setNoteError(false);
+				setNoteText(message);
+			};
+			/** The sentence one failed read carries, in ONE place: every reader below reports the same way. */
+			const failedMessage = (error) => face.t("error") + ": " + (error instanceof Error ? error.message : String(error));
+			/** Read the skills again, keeping the sentence: a re-read is not an answer to anything. */
+			const reloadSkills = () => {
+				face.loadSkills().then(setSkills).catch(failed).finally(() => {
+					setSkillsLoaded(true);
+				});
+			};
+			/**
+			* Show one skill's chains, keeping the sentence. A re-read that FAILS reports through the caller's
+			* own handler, so the failure of a read can never erase the write it was reading after.
+			* @param name - the skill to open.
+			* @param onFailure - what to do with a failed read.
+			*/
+			const showVersions = (name, onFailure = failed) => {
+				const ticket = readTicket.current + 1;
+				readTicket.current = ticket;
+				setSelected(name);
+				setPayload(void 0);
+				setVersionsFailed(void 0);
+				setPending(void 0);
+				setExpanded(void 0);
+				setDiffs(/* @__PURE__ */ new Map());
+				setBodies(/* @__PURE__ */ new Map());
+				face.loadVersions(name).then((next) => {
+					if (readTicket.current === ticket) setPayload(next);
+				}).catch((error) => {
+					if (readTicket.current !== ticket) return;
+					setVersionsFailed(failedMessage(error));
+					onFailure(error);
+				});
+			};
+			/** Open a skill from the list: another skill's sentence described another skill, so it goes away. */
+			const open = (name) => {
+				if (name !== selected) {
+					setNoteText(void 0);
+					setNoteError(false);
+				}
+				showVersions(name);
+			};
+			/** What the refresh control does: both reads again, and the sentence stays. */
+			const refresh = () => {
+				reloadSkills();
+				if (selected !== void 0) showVersions(selected);
+			};
+			const restore = (v, unitId) => {
+				if (selected === void 0) return;
+				if (pending !== v) {
+					setPending(v);
+					return;
+				}
+				setPending(void 0);
+				const name = selected;
+				face.undo(name, unitId === void 0 ? v : void 0, unitId).then((message) => {
+					showVersions(name, (error) => {
+						setNoteError(true);
+						setNoteText(message + "\n" + face.t("error") + ": " + (error instanceof Error ? error.message : String(error)));
+					});
+					succeeded(message);
+				}).catch(failed);
+			};
+			/**
+			* Expand one row, or collapse it: one row is open at a time, and each kind keeps its own lazy read.
+			* @param v - the version whose row was clicked.
+			* @param kind - which expansion the row should show.
+			*/
+			const toggle = (v, kind) => {
+				if (selected === void 0) return;
+				if (expanded !== void 0 && expanded.v === v && expanded.kind === kind) {
+					setExpanded(void 0);
+					return;
+				}
+				setExpanded({
+					v,
+					kind
+				});
+				if (kind === "diff" ? diffs.has(v) : bodies.has(v)) return;
+				const name = selected;
+				const ticket = readTicket.current + 1;
+				readTicket.current = ticket;
+				if (kind === "diff") {
+					setDiffs((current) => new Map(current).set(v, { kind: "loading" }));
+					face.loadDiff(name, v).then((diff) => {
+						if (readTicket.current !== ticket) {
+							setDiffs((current) => without(current, v));
+							return;
+						}
+						setDiffs((current) => new Map(current).set(v, {
+							kind: "ready",
+							diff
+						}));
+					}).catch((error) => {
+						if (readTicket.current !== ticket) {
+							setDiffs((current) => without(current, v));
+							return;
+						}
+						setDiffs((current) => new Map(current).set(v, {
+							kind: "failed",
+							message: failedMessage(error)
+						}));
+					});
+					return;
+				}
+				setBodies((current) => new Map(current).set(v, { kind: "loading" }));
+				face.loadBody(name, v).then((body) => {
+					if (readTicket.current !== ticket) {
+						setBodies((current) => without(current, v));
+						return;
+					}
+					setBodies((current) => new Map(current).set(v, {
+						kind: "ready",
+						body
+					}));
+				}).catch((error) => {
+					if (readTicket.current !== ticket) {
+						setBodies((current) => without(current, v));
+						return;
+					}
+					setBodies((current) => new Map(current).set(v, {
+						kind: "failed",
+						message: failedMessage(error)
+					}));
+				});
+			};
+			(0, react.useEffect)(reloadSkills, []);
+			const needle = query.trim().toLowerCase();
+			const visible = (0, react.useMemo)(() => needle === "" ? skills : skills.filter((skill) => skill.name.toLowerCase().includes(needle) || skill.description.toLowerCase().includes(needle)), [skills, needle]);
+			const loaded = payload !== void 0;
+			/** Drop the pending confirmation: the control that opened it must not be the only way out. */
+			const cancelRestore = () => {
+				setPending(void 0);
+			};
+			/** What one row shows when it is the open one. */
+			const expandedOf = (row) => {
+				if (expanded === void 0 || expanded.v !== row.v) return null;
+				if (expanded.kind === "diff") {
+					const state = diffs.get(row.v);
+					return state === void 0 ? null : (0, react.createElement)(DiffBody, {
+						face,
+						diff: state
+					});
+				}
+				const state = bodies.get(row.v);
+				return state === void 0 ? null : (0, react.createElement)(PreviewBody, {
+					face,
+					body: state
+				});
+			};
+			/** One group: a heading, an optional note, and its rows. */
+			const group = (title, entries, noteText2) => {
+				if (entries.length === 0) return null;
+				return (0, react.createElement)("section", { key: title }, ...groupHeading(title, noteText2), ...entries.map((row) => versionRow({
+					copy: face,
+					row,
+					confirming: pending === row.v,
+					open: expanded !== void 0 && expanded.v === row.v ? expanded.kind : void 0,
+					expanded: expandedOf(row),
+					onRestore: () => {
+						restore(row.v, row.unitId);
+					},
+					onCancel: cancelRestore,
+					onToggle: (kind) => {
+						toggle(row.v, kind);
+					}
+				})));
+			};
+			return (0, react.createElement)("div", { className: "evo-hist-root" }, (0, react.createElement)("aside", { className: "evo-hist-aside" }, searchField(face, query, setQuery), (0, react.createElement)("div", { className: "evo-hist-list" }, skills.length === 0 ? emptyState(face.t(skillsLoaded ? "empty.skills" : "loading")) : visible.length === 0 ? emptyState(face.t("search.none")) : visible.map((skill) => skillLine(face, skill, skill.name === selected, () => {
+				open(skill.name);
+			})))), (0, react.createElement)("div", { className: "evo-hist-main" }, panelHead(face, refresh), notice(noteText, noteError), failure === void 0 ? null : (0, react.createElement)("div", { className: "evo-hist-failure" }, failureBlock(face.t, failure)), selected === void 0 ? [emptyState(face.t(skills.length === 0 ? skillsLoaded ? "empty.skills" : "loading" : "empty.pick"), "empty"), (0, react.createElement)("p", {
+				key: "hint",
+				className: "evo-hist-hint"
+			}, face.t("hint"))] : loaded ? null : emptyState(versionsFailed === void 0 ? face.t("loading") : `${face.t("empty.versions.failed")} — ${versionsFailed}`), loaded ? (0, react.createElement)("div", null, group(face.t("group.content"), payload.content, void 0), group(face.t("group.support"), payload.support, face.t("group.support.note")), payload.content.length === 0 && payload.support.length === 0 ? (0, react.createElement)("p", { className: "evo-hist-hint" }, face.t("empty.versions")) : null) : null));
+		}
+		/**
+		* The lazy-read cache without one key.
+		*
+		* A read that a later toggle superseded must leave nothing behind: `loading` is not an answer, and
+		* the cache also serves as the \u201cdo not read twice\u201d guard, so an abandoned entry would refuse every
+		* later read of that row and leave it saying \u201cloading\u201d until the page is reloaded.
+		* @param current - the cache.
+		* @param key - the version whose entry is dropped.
+		* @returns a new cache without that key.
+		*/
+		function without(current, key) {
+			const next = new Map(current);
+			next.delete(key);
+			return next;
+		}
+		//#endregion
+		//#region src/panels/history/client/ids.ts
+		const PANEL_ID = "skill-history";
+		function PanelIcon(props = {}) {
+			const size = typeof props.size === "number" && props.size > 0 ? props.size : 18;
+			return (0, react.createElement)("svg", {
+				"aria-hidden": "true",
+				width: String(size),
+				height: String(size),
+				viewBox: "0 0 16 16",
+				fill: "none",
+				stroke: "currentColor",
+				strokeWidth: "1.5",
+				strokeLinecap: "round",
+				strokeLinejoin: "round"
+			}, (0, react.createElement)("circle", {
+				cx: "8",
+				cy: "8",
+				r: "5.75"
+			}), (0, react.createElement)("path", { d: "M8 4.75V8l2.25 1.5" }));
+		}
+		/**
+		* Register the locale namespace, the panel row and the panel body.
+		* @param ctx - the client cordis context.
+		*/
+		function apply$1(ctx) {
+			const api = createSkillHistoryApi();
+			registerSidebarPanel(ctx, {
+				id: PANEL_ID,
+				order: 35,
+				namespace: NS,
+				dictionaries: {
+					zh,
+					en
+				},
+				fallback: "en",
+				styles: {
+					css: CSS,
+					tagId: CSS_TAG_ID
+				},
+				icon: PanelIcon,
+				component: SkillHistoryPanel,
+				body: (t) => ({
+					t,
+					format: (key, values) => fill(t(key), values),
+					loadSkills: api.skills,
+					loadVersions: api.versions,
+					loadDiff: api.diff,
+					loadBody: api.body,
+					undo: api.undo,
+					markdownWords: {
+						copy: t("markdown.copy"),
+						copied: t("markdown.copied"),
+						footnotes: t("markdown.footnotes")
+					}
+				})
+			});
+		}
+		//#endregion
+		//#region src/client/index.ts
+		const inject = [
+			"slots",
+			"locale",
+			"layout"
+		];
+		/** Register every panel through the shared client-kit lifecycle. */
+		function apply(ctx) {
+			apply$2(ctx);
+			(0, _deepseek_ai_dsh_evolution_merge_ui_client.apply)(ctx);
+			apply$1(ctx);
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+
+		return module.exports;
+	}
+});