@cowwo/dsh-lookout 0.1.2 → 0.5.0

package/client/client.js

@@ -5039,13 +5039,22 @@ window.__ModuleLoader__.load({
 //
 // 这一页只回答两个问题：
 //   1. 配好了吗   → 分组状态点（已配置 / 未配置 / 不适用）
-//   2. 能发出去吗 → 顶部状态条 + 发送测试邮件 + 最近一次投递结果
+//   2. 能发出去吗 → 顶部状态条 + 发送测试邮件（点了当场回执成败与原始报错）
 // 其余一切让路：不额外套卡片、不加编号、不做中英同屏。
 //
-// 编辑模型：**没有保存/放弃按钮，改完即时生效**。按字段类型区别对待：
-//   - 开关 / 下拉 / 分段：立刻写
-//   - 数字 / 文本：防抖（停手再写）+ 失焦兜底
-//   - 密码：只在失焦或回车时写，且**每个凭据引用名各写各的**
+// 信息架构（本轮只重做视觉骨架，信息架构与功能不动）：
+//   内容列 max-width 760 居中；页标题 18/600 + 说明 12/18；右上只有动作组
+//   （脏读数 + 保存 + 放弃改动），它是动作区、不是第二层页头；
+//   判决条 = 状态色 hero（bg-module-platform + 左侧 3px 状态色 + 18/600 标题 + 主按钮在右下）；
+//   下面三张描边卡片：收件人 / 怎么发 / 什么时候发给我（14/22·500 卡片标题 + 12/18 状态读数）；
+//   7 个预设收成一行横向滚动 chips；端口 / 加密折进「更多」（收起时标题带当前值）；
+//   8 个事件开关排成宿主同款行（16px 上下内边距 + 行自身 .5px 线），说明由问号**点击**展开。
+//   字号阶梯全部落在宿主网格上（只用整像素档，不再有半档字号）；圆角只用 4/8/12/16/20/28。
+//
+// 编辑模型：**显式保存**。所有控件只改本地草稿，点「保存」才一次性写回：
+//   - 配置字段：与基线不同的项合成一次 mutate(found.ns, ops, revision)
+//   - 授权码：草稿只活在内存里，保存成功时才写凭据库（写入目标由那一行决定）
+//   - 「放弃改动」把草稿整体回滚到基线；「恢复全部默认」不受保存按钮约束，立即生效
 //
 // 六条硬约束（前三条踩过，后三条是本轮修掉的）：
 //   1. 注册页面只依赖 `slots`。远程命名空间 / locale 各开一个非阻塞的 ctx.inject 去填；
@@ -5077,24 +5086,25 @@ window.__ModuleLoader__.load({
     /** 只等必需服务：页面注册本身只需要 slots（硬约束 1）。 */
     const inject = ['slots'];
 
-    const NS = 'dsh-notify-p';
+    /**
+     * 文案字典的命名空间（宿主的 profile 入口 id）。
+     *
+     * **不是设置命名空间**：配置的 ns 每次都由 describe() 返回项里的 schema 签名认领
+     * （见 load()），客户端不允许写死——profile 入口 id 换了，这里的所有读写都得跟着换。
+     */
+    const LOCALE_NS = 'lookout';
 
     /** Host Remote 的命名空间（与 lib/typert.host.js 清单一致）。 */
     const REMOTE_NS = 'mailNotify';
 
-    /** 文本 / 数字字段的防抖时长（毫秒）。 */
-    const TEXT_DEBOUNCE_MS = 600;
-    const NUMBER_DEBOUNCE_MS = 500;
-
     // ---------------------------------------------------------------------------
     // 文案：zh 是内置兜底，en 走 locale 字典；界面永远只显示一种语言（不同屏并列）。
     // ---------------------------------------------------------------------------
     const ZH = {
       'group.status': '投递状态',
-      'evidence.label': '最近一次发送',
-      'evidence.never': '还没有试过',
-      'evidence.ok': '成功，用时 {ms} 毫秒，{ago}',
-      'evidence.fail': '失败',
+      'test.sent': '已发送',
+      'test.sentMs': '用时 {ms} 毫秒',
+      'test.failed': '这次没发出去',
       'cred.saved': '已保存',
       'cred.notSaved': '还没保存',
       'cred.replace': '更换',
@@ -5103,7 +5113,7 @@ window.__ModuleLoader__.load({
       'err.auth': '服务端拒绝了这组账号密码',
       'err.authHint': '多半是授权码不对或过期了：QQ 邮箱要的是「授权码」而不是登录密码，重新生成一个再填。',
       'err.rejected': '发件人被拒',
-      'err.rejectedHint': '收件服务器不接受这个发件人。换个发件地址（一般在「发件人与链接」里）再试。',
+      'err.rejectedHint': '收件服务器不接受这个发件人。发件地址由插件按服务端设置决定，确认这个邮箱被允许用来发信后再试。',
       'err.network': '连不上服务器',
       'err.networkHint': '检查主机名与端口；本机防火墙或公司网络也可能挡住 465 / 587。',
       'err.other': '发送失败',
@@ -5112,11 +5122,24 @@ window.__ModuleLoader__.load({
       nav: '邮件通知',
       lead: '会话干完活、出错或卡住时，给你发一封邮件。',
 
-      'save.auto': '改动即时生效',
-      'save.saving': '正在保存…',
-      'save.savedAgo': '已保存，{n} 秒前',
+      'save.clean': '没有未保存的改动',
+      'save.dirty': '有 {n} 项改动未保存',
+      'save.saving': '保存中…',
+      'save.savedJust': '已保存 · 刚刚',
+      'save.savedAgo': '已保存 · {n} 秒前',
       'save.error': '保存失败：{error}',
+      'save.retry': '重试',
       'save.reload': '重新读取',
+      // 读失败是**独立的一档**：它不是"保存失败"，重试也不该走保存那条路。
+      'save.loadFailed': '读不到本插件的配置：{error}',
+      // 冲突恢复：别人先改了 → 已自动重读，草稿没动，让用户再点一次。
+      'save.conflictReloaded': '配置已被别处改动，已读到最新值，请再点一次保存',
+      // 半成功：必须点出**哪一半**成功、哪一半没成，别用一句"保存失败"把成功的半吞掉。
+      'save.credFailed': '配置已保存，但授权码没写进去：{error}',
+      'save.configFailed': '授权码已保存，但配置没写进去：{error}',
+      'save.credAlsoFailed': '授权码也没写进去：{error}',
+      'save.retryCred': '重试授权码',
+      'save.retryConfig': '重试配置',
       'save.checkingCred': '正在确认授权码是否已写入…',
       'save.credCheckFailed': '凭据状态读取失败：{error}',
 
@@ -5126,7 +5149,6 @@ window.__ModuleLoader__.load({
       'status.needUser': '还差 SMTP 用户名',
       'status.needCredential': '还差{cred}',
       'status.ready': '可以发信了',
-      'status.lastFailed': '上次发信失败',
       'status.notServed': '这一页读不到本插件的配置',
 
       // 判决下面那句人话。只说用户的事，不说实现的事。
@@ -5136,7 +5158,8 @@ window.__ModuleLoader__.load({
       'status.why.needUser': '多数邮箱要求用户名和授权码成对出现。',
       'status.why.needCredential': '没填它，服务端会拒收这封信。',
       'status.why.ready': '配置齐了。发一封测试邮件，确认服务端真的收下。',
-      'status.why.lastFailed': '配置看着没问题，但上一次没发出去。',
+      // 判决条只按已保存的配置判定，这句把口径说透，免得"我明明填好了"变成困惑。
+      'status.unsavedDraft': '未保存的改动不参与判定。',
 
       'act.enable': '启用',
       'act.goFill': '去填写',
@@ -5144,15 +5167,15 @@ window.__ModuleLoader__.load({
       'act.testing': '正在发送…',
       'act.retest': '重新测试',
       'act.needsRestart': '需要重启 DSH 后才能测试',
-      'act.testHint': '按现在的配置真发一封到收件人，不用等某个会话干完。',
+      // 明说用**哪一份**配置：测试走的是已保存配置，草稿还没落盘，别让人以为测的是屏幕上这些字。
+      'act.testHint': '用已保存的配置真发一封到收件人，不用等某个会话干完。',
+      'act.save': '保存',
+      'act.discard': '放弃改动',
+      'act.saveHint': '把这一页的改动一次性写回配置。',
 
       'group.recipients': '收件人',
       'group.transport': '怎么发',
       'group.outcomes': '什么时候发给我',
-      'group.optional': '可选设置',
-      'group.sender': '发件人与链接',
-      'group.advanced': '高级',
-
 
       'recipients.label': '收件邮箱',
       'recipients.placeholder': 'you@qq.com',
@@ -5161,12 +5184,6 @@ window.__ModuleLoader__.load({
       'recipients.none': '还没填',
       'recipients.invalid': '格式不对，不会被发送：{list}',
 
-      'time.justNow': '刚刚',
-      'time.secondsAgo': '{n} 秒前',
-      'time.minutesAgo': '{n} 分钟前',
-      'time.hoursAgo': '{n} 小时前',
-      'time.daysAgo': '{n} 天前',
-
       'transportState.done': '已配好',
       'transportState.todo': '还没配好',
 
@@ -5175,6 +5192,12 @@ window.__ModuleLoader__.load({
       'preset.label': '邮箱服务商',
       'preset.other': '其他',
       'preset.detected': '已按「{name}」填好',
+      // 端口 / 加密收进「更多」：收起来不等于藏起来——偏离宿主默认就把现值摆到标题上。
+      'transport.more': '更多',
+      'transport.moreWith': '更多（{value}）',
+      // 事件开关的问号按钮：只做可访问名（说明正文仍走 outcomes.*Hint）。
+      'hint.show': '展开「{title}」的说明',
+      'hint.hide': '收起「{title}」的说明',
 
       'smtp.host': 'SMTP 主机',
       'smtp.port': '端口',
@@ -5183,7 +5206,7 @@ window.__ModuleLoader__.load({
       'smtp.accountMismatch': '{host} 是{name}的服务器，但账号是 {user}：对不上，认证会失败。把账号换成 {suffix} 结尾的邮箱，或把服务商改成账号所属的那一家。',
 
       'cred.smtp': 'SMTP 授权码',
-      'cred.smtpHint': '不是登录密码。只写进凭据库，永不回显；离开输入框时保存。',
+      'cred.smtpHint': '不是登录密码。只写进凭据库，永不回显；点「保存」时才写入。',
       'cred.smtpHelp': '怎么拿授权码？',
       'cred.smtpHelpTitle': '怎么拿 SMTP 授权码',
       'cred.smtpHelpBody': '授权码不是登录密码，是邮箱服务商单独发的口令（QQ 是 16 位）。\n\nQQ 邮箱：设置 → 账户 → 开启「POP3/SMTP 服务」→ 生成授权码。\n163 / 126：设置 → POP3/SMTP/IMAP → 开启服务 → 新增授权码。\nGmail：账号 → 安全性 → 两步验证 → 应用专用密码。\niCloud：Apple ID → 登录与安全 → App 专用密码。\nOutlook：账户 → 安全性 → 高级安全选项 → 应用密码。',
@@ -5207,52 +5230,12 @@ window.__ModuleLoader__.load({
       'outcomes.interruptedHint': 'DSH 重启 / 热更新 / 被父级取消。',
       'outcomes.maxTokens': '达到长度上限',
       'outcomes.maxTokensHint': '回复被长度上限截断。',
-      'outcomes.minDuration': '完成时长下限',
-      'outcomes.minDurationHint': '短于这个时长的完成不发信；只对「任务完成」生效，出错、卡住、审批不受此限。',
       'outcomes.subagents': '也通知子代理会话',
       'outcomes.subagentsHint': '一个 workflow 能扇出几十个子会话，默认不打扰。',
 
-      'sender.name': '发件人显示名',
-      'sender.nameHint': '收件人看到的发件人名字，留空就用默认名。',
-      'sender.address': '发件人地址',
-      'sender.addressHint': '必须是能用的邮箱地址；格式不对或与清单里已有的重复，会在弹层里就地报错。',
-      'sender.listLabel': '发件人',
-      'sender.listHint': '这里保存所有发件人，发信时用选中的那一条。点某一行选中它，✎ 改，× 删。',
-      'sender.empty': '还没有保存发件人 · 将回退到默认发件人',
-      'sender.add': '＋ 添加发件人',
-      'sender.addTitle': '添加发件人',
-      'sender.editTitle': '编辑发件人',
-      'sender.save': '保存',
-      'sender.cancel': '取消',
-      'sender.inUse': '发信时用它',
-      'sender.edit': '编辑',
-      'sender.remove': '删除',
-      'sender.nameUnset': '（用默认显示名）',
-      'sender.useThis': '用 {address} 发信',
-      'sender.issue.needAddress': '请填发件人地址',
-      'sender.issue.badAddress': '地址格式不对，不会被接受',
-      'sender.issue.duplicate': '这个地址已经在清单里了',
-
-      'link.enabled': '邮件里带直达会话链接',
-      'link.enabledHint': '需要另装深链插件才能被识别。',
-      'link.base': '链接对外地址',
-      'link.baseHint': '留空则读 DSH_WEB_URL；手机要能点开就填局域网地址或域名。',
-
-      'adv.settle': '合并窗口',
-      'adv.settleHint': '毫秒。期间同一会话又开新轮，就合并成一封。',
-      'adv.rate': '发送速率上限',
-      'adv.rateHint': '封/分钟，多会话并停时保护邮箱服务商。',
-      'adv.pwRef': 'SMTP 凭据引用名',
-      'adv.pwRefHint': '凭据库里的键名，改这里不会动已存的值。',
-      'adv.statePath': '投递账本路径',
-      'adv.statePathHint': '留空 = $DSH_HOME/dsh-notify-p/state.json。排错时 cat 它。',
-
-      'unit.ms': '毫秒',
-      'unit.perMin': '封/分钟',
-
       'danger.reset': '恢复全部默认',
       'danger.title': '恢复全部默认？',
-      'danger.body': '这会清掉本插件在 settings.yaml 里的全部覆盖（收件人、事件开关、节奏参数都会回到默认）。',
+      'danger.body': '这会清掉本插件在 profile 里的全部覆盖（收件人、事件开关、节奏参数都会回到默认），并立即生效——它不受「保存」按钮约束，这一页还没保存的草稿也会一起丢掉。',
       'danger.keep': '凭据库里已存的授权码不受影响。',
       'danger.ok': '恢复默认',
       'danger.cancel': '取消',
@@ -5260,10 +5243,9 @@ window.__ModuleLoader__.load({
 
     const EN = {
       'group.status': 'Delivery status',
-      'evidence.label': 'Last send',
-      'evidence.never': 'Not tried yet',
-      'evidence.ok': 'Sent in {ms} ms, {ago}',
-      'evidence.fail': 'Failed',
+      'test.sent': 'Sent',
+      'test.sentMs': 'in {ms} ms',
+      'test.failed': 'This send did not go out',
       'cred.saved': 'Saved',
       'cred.notSaved': 'Not saved yet',
       'cred.replace': 'Replace',
@@ -5272,7 +5254,7 @@ window.__ModuleLoader__.load({
       'err.auth': 'The server rejected these credentials',
       'err.authHint': 'Usually a wrong or expired authorization code: QQ Mail needs an app code, not your login password. Generate a new one and paste it here.',
       'err.rejected': 'Sender rejected',
-      'err.rejectedHint': 'The receiving server will not accept this sender. Change the From address under "Sender and links" and retry.',
+      'err.rejectedHint': 'The receiving server will not accept this sender. The From address comes from the plugin’s server-side settings; check that the mailbox is allowed to send.',
       'err.network': 'Cannot reach the server',
       'err.networkHint': 'Check the host and port; a local firewall or corporate network may block 465 / 587.',
       'err.other': 'Send failed',
@@ -5281,11 +5263,21 @@ window.__ModuleLoader__.load({
       nav: 'Mail notification',
       lead: 'Get one email when a session finishes, fails, or gets stuck.',
 
-      'save.auto': 'Changes apply immediately',
+      'save.clean': 'No unsaved changes',
+      'save.dirty': 'Unsaved changes: {n}',
       'save.saving': 'Saving…',
-      'save.savedAgo': 'Saved, {n}s ago',
+      'save.savedJust': 'Saved · just now',
+      'save.savedAgo': 'Saved · {n}s ago',
       'save.error': 'Save failed: {error}',
+      'save.retry': 'Retry',
       'save.reload': 'Reload',
+      'save.loadFailed': 'Cannot read this plugin’s settings: {error}',
+      'save.conflictReloaded': 'The settings were changed elsewhere. The latest values are loaded — press Save again.',
+      'save.credFailed': 'Settings saved, but the authorization code was not written: {error}',
+      'save.configFailed': 'Authorization code saved, but the settings were not written: {error}',
+      'save.credAlsoFailed': 'The authorization code was not written either: {error}',
+      'save.retryCred': 'Retry the code',
+      'save.retryConfig': 'Retry the settings',
       'save.checkingCred': 'Checking whether the code was written…',
       'save.credCheckFailed': 'Could not read the credential state: {error}',
 
@@ -5295,7 +5287,6 @@ window.__ModuleLoader__.load({
       'status.needUser': 'SMTP user name missing',
       'status.needCredential': '{cred} missing',
       'status.ready': 'Ready to send',
-      'status.lastFailed': 'The last send failed',
       'status.notServed': 'This page cannot read the plugin settings',
 
       'status.why.disabled': 'Turn on any case below and notifications start.',
@@ -5304,7 +5295,7 @@ window.__ModuleLoader__.load({
       'status.why.needUser': 'Most providers want the user name and the authorization code together.',
       'status.why.needCredential': 'Without it the server will refuse the message.',
       'status.why.ready': 'Configuration is complete. Send a test email to confirm the server accepts it.',
-      'status.why.lastFailed': 'The configuration looks fine, but the last attempt did not go out.',
+      'status.unsavedDraft': 'Unsaved changes are not part of this verdict.',
 
       'act.enable': 'Turn on',
       'act.goFill': 'Fill it in',
@@ -5312,15 +5303,14 @@ window.__ModuleLoader__.load({
       'act.testing': 'Sending…',
       'act.retest': 'Test again',
       'act.needsRestart': 'Restart DSH to test',
-      'act.testHint': 'Really sends one email to the recipients right now, without waiting for a session to finish.',
+      'act.testHint': 'Really sends one email to the recipients with the saved configuration, without waiting for a session to finish.',
+      'act.save': 'Save',
+      'act.discard': 'Discard changes',
+      'act.saveHint': 'Writes every change on this page back in one go.',
 
       'group.recipients': 'Recipients',
       'group.transport': 'How to send',
       'group.outcomes': 'When to notify me',
-      'group.optional': 'Optional',
-      'group.sender': 'Sender and links',
-      'group.advanced': 'Advanced',
-
 
       'recipients.label': 'Recipient addresses',
       'recipients.placeholder': 'you@qq.com, one per line',
@@ -5329,12 +5319,6 @@ window.__ModuleLoader__.load({
       'recipients.none': 'None yet',
       'recipients.invalid': 'Bad format, will not be sent: {list}',
 
-      'time.justNow': 'just now',
-      'time.secondsAgo': '{n}s ago',
-      'time.minutesAgo': '{n} min ago',
-      'time.hoursAgo': '{n} h ago',
-      'time.daysAgo': '{n} d ago',
-
       'transportState.done': 'Configured',
       'transportState.todo': 'Not configured yet',
 
@@ -5343,6 +5327,10 @@ window.__ModuleLoader__.load({
       'preset.label': 'Mail provider',
       'preset.other': 'Other',
       'preset.detected': 'Filled in for “{name}”',
+      'transport.more': 'More',
+      'transport.moreWith': 'More ({value})',
+      'hint.show': 'Show the note for “{title}”',
+      'hint.hide': 'Hide the note for “{title}”',
 
       'smtp.host': 'SMTP host',
       'smtp.port': 'Port',
@@ -5351,7 +5339,7 @@ window.__ModuleLoader__.load({
       'smtp.accountMismatch': '{host} is {name}’s server but the account is {user} — they do not match, so authentication will fail. Use a {suffix} address, or switch the provider to the account’s own.',
 
       'cred.smtp': 'SMTP authorization code',
-      'cred.smtpHint': 'Not your login password. Written to the credential store only, never echoed; saved when you leave the field.',
+      'cred.smtpHint': 'Not your login password. Written to the credential store only, never echoed; written when you press Save.',
       'cred.smtpHelp': 'How do I get one?',
       'cred.smtpHelpTitle': 'Getting an SMTP authorization code',
       'cred.smtpHelpBody': 'An authorization code is not your login password — the mail provider issues it separately.\n\nQQ Mail: Settings → Account → enable “POP3/SMTP service” → generate the code.\n163 / 126: Settings → POP3/SMTP/IMAP → enable the service → add an authorization code.\nGmail: Account → Security → 2-Step Verification → App passwords.\niCloud: Apple ID → Sign-In and Security → App-Specific Passwords.\nOutlook: Account → Security → Advanced security options → App password.',
@@ -5375,52 +5363,12 @@ window.__ModuleLoader__.load({
       'outcomes.interruptedHint': 'Harness restart / hot reload / cancelled by a parent.',
       'outcomes.maxTokens': 'Token limit reached',
       'outcomes.maxTokensHint': 'The reply was cut off by the length limit.',
-      'outcomes.minDuration': 'Minimum duration',
-      'outcomes.minDurationHint': 'Completions shorter than this are not sent; applies to “Task completed” only — failures, blocks and approvals always get through.',
       'outcomes.subagents': 'Also notify subagent sessions',
       'outcomes.subagentsHint': 'One workflow can fan out dozens of sub-sessions; off by default.',
 
-      'sender.name': 'Sender display name',
-      'sender.nameHint': 'The name your recipients see; leave empty to use the default.',
-      'sender.address': 'From address',
-      'sender.addressHint': 'Must be a usable email address; a bad one or a duplicate is reported in the dialog.',
-      'sender.listLabel': 'Senders',
-      'sender.listHint': 'All senders are kept here; the selected one is used to send. Click a row to select it, ✎ to edit, × to remove.',
-      'sender.empty': 'No sender saved yet · will fall back to the default sender',
-      'sender.add': '＋ Add sender',
-      'sender.addTitle': 'Add sender',
-      'sender.editTitle': 'Edit sender',
-      'sender.save': 'Save',
-      'sender.cancel': 'Cancel',
-      'sender.inUse': 'In use',
-      'sender.edit': 'Edit',
-      'sender.remove': 'Remove',
-      'sender.nameUnset': '(uses the default name)',
-      'sender.useThis': 'Send from {address}',
-      'sender.issue.needAddress': 'A from address is required',
-      'sender.issue.badAddress': 'Not a valid email address',
-      'sender.issue.duplicate': 'This address is already in the list',
-
-      'link.enabled': 'Include a link to the session',
-      'link.enabledHint': 'Needs a deep-link plugin installed to be recognized.',
-      'link.base': 'Public base URL',
-      'link.baseHint': 'Empty reads DSH_WEB_URL. To open links on your phone, put a LAN address or domain here.',
-
-      'adv.settle': 'Coalesce window',
-      'adv.settleHint': 'Milliseconds. A new turn in the same session during this window is folded into one email.',
-      'adv.rate': 'Send rate limit',
-      'adv.rateHint': 'Emails per minute; protects your mail provider when many sessions stop at once.',
-      'adv.pwRef': 'SMTP credential reference',
-      'adv.pwRefHint': 'The key name in the credential store. Renaming does not touch the stored value.',
-      'adv.statePath': 'Delivery ledger path',
-      'adv.statePathHint': 'Empty = $DSH_HOME/dsh-notify-p/state.json. cat it when debugging.',
-
-      'unit.ms': 'ms',
-      'unit.perMin': 'per min',
-
       'danger.reset': 'Reset everything to defaults',
       'danger.title': 'Reset everything to defaults?',
-      'danger.body': 'This clears every override this plugin stored in settings.yaml — recipients, event switches and pacing all return to defaults.',
+      'danger.body': 'This clears every override this plugin stored in the profile — recipients, event switches and pacing all return to defaults — and takes effect immediately, outside the Save button. Unsaved drafts on this page are dropped as well.',
       'danger.keep': 'Stored authorization codes are not affected.',
       'danger.ok': 'Reset',
       'danger.cancel': 'Cancel',
@@ -5464,6 +5412,12 @@ window.__ModuleLoader__.load({
       { id: 'icloud', name: 'iCloud', host: 'smtp.mail.me.com', port: 587, secure: 'starttls', suffix: '@icloud.com', domains: ['icloud.com', 'me.com', 'mac.com'] },
     ];
 
+    /**
+     * 端口 / 加密的宿主默认值（逐字对齐 lib/notify/config.js：端口 465、加密 auto）。
+     * 「更多」折叠标题靠它判断这一对值是不是偏离默认，偏离才在后面写当前值。
+     */
+    const DEFAULT_TRANSPORT = { port: 465, secure: 'auto' };
+
     /**
      * 解析收件人：一行一个（兼容逗号/分号），去空、去重、丢弃明显不含 @ 的项。
      * 规则必须与 Host 侧 lib/config.js 的 parseRecipients 保持一致。
@@ -5487,97 +5441,6 @@ window.__ModuleLoader__.load({
       return { valid, invalid };
     }
 
-    /**
-     * 归一化发件人清单，并把老配置迁移成清单。
-     * 规则必须与 Host 侧 lib/config.js 的 senderList 保持一致（迁移、去空、去重）。
-     * @param {object} config 当前草稿
-     * @returns {{ name: string, address: string }[]} 清单（可能为空）
-     */
-    function migrateSenders(config) {
-      const raw = Array.isArray(config?.senders) ? config.senders : [];
-      const list = [];
-      const seen = new Set();
-      for (const entry of raw) {
-        const address = String(entry?.address ?? '').trim();
-        if (address === '') continue;
-        const key = address.toLowerCase();
-        if (seen.has(key)) continue;
-        seen.add(key);
-        list.push({ name: String(entry?.name ?? '').trim(), address });
-      }
-      if (list.length > 0) return list;
-      const address = String(config?.fromAddress ?? '').trim();
-      if (address === '') return [];
-      return [{ name: String(config?.senderName ?? '').trim(), address }];
-    }
-
-    /**
-     * 哪一条是当前生效的。
-     * 与 Host 侧 resolveSender 同规则：按**地址**匹配，找不到就退回第一条。
-     * @param {object} config 当前草稿
-     * @param {{name: string, address: string}[]} list 已归一化的清单
-     * @returns {string} 生效的地址；清单为空时 ''
-     */
-    function activeSenderAddress(config, list) {
-      const wanted = String(config?.activeSender ?? '').trim().toLowerCase();
-      const hit = list.find((entry) => entry.address.toLowerCase() === wanted);
-      return (hit ?? list[0])?.address ?? '';
-    }
-
-    /**
-     * 校验一条发件人。
-     * @param {{name: string, address: string}[]} list 现有清单
-     * @param {number} editing 正在编辑的下标；等于 list.length 表示新增
-     * @param {{name: string, address: string}} value 待保存的值
-     * @returns {''|'needAddress'|'badAddress'|'duplicate'} '' 表示通过
-     */
-    function senderIssue(list, editing, value) {
-      const address = String(value?.address ?? '').trim();
-      if (address === '') return 'needAddress';
-      if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(address)) return 'badAddress';
-      const key = address.toLowerCase();
-      for (let i = 0; i < list.length; i += 1) {
-        if (i !== editing && list[i].address.toLowerCase() === key) return 'duplicate';
-      }
-      return '';
-    }
-
-    /**
-     * 保存一条（新增或就地修改）。
-     * 新增的**自动成为生效项**；改地址时若它正是生效项，生效项跟着新地址走。
-     * @param {{list: object[], active: string, editing: number}} state 当前状态
-     * @param {{name: string, address: string}} value 待保存的值
-     * @returns {{list: object[], active: string}} 新状态
-     */
-    function senderCommit(state, value) {
-      const list = state.list.map((entry) => ({ ...entry }));
-      const name = String(value?.name ?? '').trim();
-      const address = String(value?.address ?? '').trim();
-      if (state.editing >= list.length) {
-        list.push({ name, address });
-        return { list, active: address };
-      }
-      const before = list[state.editing].address;
-      list[state.editing] = { name, address };
-      return { list, active: state.active === before ? address : state.active };
-    }
-
-    /**
-     * 删一条，并决定谁来接替生效位。
-     * 删掉的正是生效项时，选它下面那条（没有下面则选最后一条）；删光则清空生效位。
-     * @param {{list: object[], active: string}} state 当前状态
-     * @param {number} index 要删的下标
-     * @returns {{list: object[], active: string}} 新状态
-     */
-    function senderRemove(state, index) {
-      const list = state.list.map((entry) => ({ ...entry }));
-      const wasActive = list[index].address === state.active;
-      list.splice(index, 1);
-      if (list.length === 0) return { list, active: '' };
-      if (!wasActive) return { list, active: state.active };
-      return { list, active: list[Math.min(index, list.length - 1)].address };
-    }
-
     /**
      * 把投递失败的原因翻译成「该动哪里」。
      *
@@ -5605,25 +5468,6 @@ window.__ModuleLoader__.load({
       };
     }
 
-    /**
-     * 「多久以前」的人话。只给投递结果用，所以粒度到分钟就够。
-     * @param {unknown} at 时间戳（毫秒）
-     * @param {number} now 当前时间戳
-     * @returns {string} 如「刚刚」「3 分钟前」
-     */
-    function relativeTime(at, now) {
-      const stamp = typeof at === 'number' && Number.isFinite(at) ? at : null;
-      if (stamp === null) return '';
-      const seconds = Math.max(0, Math.round((now - stamp) / 1000));
-      if (seconds < 10) return i18n.t('time.justNow');
-      if (seconds < 60) return i18n.t('time.secondsAgo', { n: seconds });
-      const minutes = Math.round(seconds / 60);
-      if (minutes < 60) return i18n.t('time.minutesAgo', { n: minutes });
-      const hours = Math.round(minutes / 60);
-      if (hours < 24) return i18n.t('time.hoursAgo', { n: hours });
-      return i18n.t('time.daysAgo', { n: Math.round(hours / 24) });
-    }
-
     /**
      * 按主机名匹配预设。
      * @param {unknown} host SMTP 主机
@@ -5679,14 +5523,13 @@ window.__ModuleLoader__.load({
       return hit === undefined ? '' : hit;
     }
 
-    /** 状态条的取值顺序：先看能不能发，再看有没有真的发出去过。 */
+    /** 状态条的取值只由「配置齐不齐」决定；投递历史已随账本一起删除。 */
     const STATUS_TONE = {
       disabled: 'idle',
       needRecipients: 'warning',
       needHost: 'warning',
       needUser: 'warning',
       needCredential: 'warning',
-      lastFailed: 'error',
       ready: 'done',
     };
 
@@ -5694,22 +5537,43 @@ window.__ModuleLoader__.load({
      * 推导状态条要显示哪个结论。纯函数，输入全部来自草稿与凭据状态。
      * SMTP 是唯一的发送方式，必填项是「主机 + 用户名 + 凭据」，缺哪个就报哪个——
      * 只报主机会让用户填完主机才发现还是发不出去。
+     * 投递历史不参与：账本已删，这里只回答「配置齐不齐」。
      * @param {object} input 判定输入
      * @returns {string} 状态键
      */
     function deriveStatus(input) {
-      const { enabled, recipientCount, host, user, credentialConfigured, lastDelivery } = input ?? {};
+      const { enabled, recipientCount, host, user, credentialConfigured } = input ?? {};
       if (enabled !== true) return 'disabled';
       if (!(recipientCount > 0)) return 'needRecipients';
       if (String(host ?? '').trim() === '') return 'needHost';
       if (String(user ?? '').trim() === '') return 'needUser';
       if (credentialConfigured !== true) return 'needCredential';
-      if (lastDelivery && lastDelivery.ok === false) return 'lastFailed';
       return 'ready';
     }
 
     /**
-     * 某一组的状态点。optional 组只区分「已自定义 / 走默认」。
+     * 草稿与基线的差异 → mutate 的 ops。
+     *
+     * 一次保存只发一条 mutate：ops 里只放与基线不同的字段，空值走 unset（清掉覆盖）。
+     * @param {object} draft 当前草稿
+     * @param {object} base 上一次落盘的基线
+     * @returns {Array<{op: string, path: string[], value?: unknown}>} ops
+     */
+    function diffOps(draft, base) {
+      const left = draft && typeof draft === 'object' ? draft : {};
+      const right = base && typeof base === 'object' ? base : {};
+      const ops = [];
+      for (const key of new Set([...Object.keys(left), ...Object.keys(right)])) {
+        const value = left[key];
+        if (value === right[key]) continue;
+        if (value === '' || value === null || value === undefined) ops.push({ op: 'unset', path: [key] });
+        else ops.push({ op: 'set', path: [key], value });
+      }
+      return ops;
+    }
+
+    /**
+     * 某一组的状态点。不适用时给 idle——这一组本来就不参与，别画成告警。
      * @param {boolean} done 是否已配置好
      * @param {boolean} [notApplicable] 是否不适用
      * @returns {'done'|'warning'|'idle'} 状态点状态
@@ -5736,65 +5600,127 @@ window.__ModuleLoader__.load({
     //   面板是它的后代，直接引用按继承链正常求值，暗色自动跟着走。
     //
     // 量度（全部照抄宿主自己的设置页，别自己发明）：
-    //   内容列 ≈ 564px · 段标题 14/22·500 · 行标题 14/22 · 字段标签 12/18·500
-    //   说明 12/18 tertiary · 行间 .5px border-l2 · 段头下 .5px border-l3
+    //   内容列 max-width 760 居中 · 页标题 18/26·600 · 卡片标题 14/22·500 · 行标题 14/22·400
+    //   字段标签 13/1.5·500（primary） · 说明 12/18 tertiary · 小读数 11/16
+    //   卡片 = .5px border-l4 + radius 20 + padding 14 16 + gap 12；卡片之间 gap 12
+    //   行 = padding 16px 0 + 行自身 .5px border-l2（最后一行没有）；段头 / 页脚一律不画线
     //   填充面 = bg-module-platform（宿主"编辑器/选中态"用的就是这个）
     //
     // 纪律：全页零硬编码颜色（单测里有审计）。**全页只有一个填充面 —— 判决条。**
     // ---------------------------------------------------------------------------
 
     /** 一眼看出浏览器加载的是哪一版。放在根节点的 data-build 上，检查 DOM 可见，不占视觉。 */
-    const BUILD = 'ui11';
-
-    const CSS = `
-/* dsh-notify-p · 设置页样式（量度对齐宿主 settings 页；全页零硬编码颜色） */
-.dshmn-page{display:flex;flex-direction:column;min-width:0;max-width:100%;color:var(--dsw-alias-label-primary);font-size:14px;line-height:22px}
-.dshmn-mono{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:12px;line-height:18px;font-variant-numeric:tabular-nums}
-
-/* 页头：一句用途 + 落盘读数（读数只报事实，不报"操作成功"） */
-.dshmn-head{display:flex;align-items:baseline;justify-content:space-between;gap:16px;margin:0 0 14px;min-width:0}
-.dshmn-lead{margin:0;min-width:0;color:var(--dsw-alias-label-secondary);font-size:14px;line-height:22px}
-.dshmn-stamp{flex:none;display:inline-flex;align-items:center;gap:6px;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}
+    const BUILD = 'ui17';
+
+    const CSS = `/* dsh-notify-p · 设置页样式（视觉骨架照抄宿主 settings 页；全页零硬编码颜色）
+   字号阶梯（每一档都落在宿主网格上，全页只用整像素档，不许半档）：
+     页标题 18/26·600 ＝ 判决标题 18/26·600 > 卡片标题 14/22·500
+     > 字段标签 13/1.5·500 > 行标题 14/22·400 > 说明 12/18 > 小读数 11/16
+   骨架：内容列 max-width 760 居中；页头只有标题 + 动作组；三张描边卡片；
+   判决条是唯一填充面（bg-module-platform）+ 左侧 3px 状态色；页脚无边框。
+   线只长在行自己身上（.5px border-l2，最后一行没有），段头与页脚一律不画线。
+   圆角只用宿主那几档：卡片 / 判决条 20、输入框 12、chips 8、问号 50%。 */
+.dshmn-page{display:flex;flex-direction:column;width:100%;max-width:760px;margin:0 auto;min-width:0;color:var(--dsw-alias-label-primary);font-size:14px;line-height:22px}
+.dshmn-mono{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:11px;line-height:16px;font-variant-numeric:tabular-nums}
+
+/* 页头：标题 18/600 独占一行，右上只有动作组（脏读数 + 保存 + 放弃改动）。
+   不画线、不放说明、不占第二层高度——它是内容区第一行，不是第二条标题栏。 */
+.dshmn-head{display:flex;align-items:flex-start;justify-content:space-between;gap:12px 16px;margin:0 0 24px;min-width:0;flex-wrap:wrap}
+.dshmn-headText{display:flex;flex-direction:column;gap:12px;min-width:0;flex:1 1 auto}
+.dshmn-title{margin:0;min-width:0;color:var(--dsw-alias-label-primary);font-size:18px;line-height:26px;font-weight:600}
+.dshmn-lead{margin:0;min-width:0;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}
+.dshmn-headActions{display:flex;align-items:center;justify-content:flex-end;gap:8px;flex:none;flex-wrap:wrap;min-width:0}
+.dshmn-stamp{flex:none;display:inline-flex;align-items:center;gap:6px;color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:16px;font-variant-numeric:tabular-nums}
 .dshmn-stamp[data-tone=busy]{color:var(--dsw-alias-label-secondary)}
 .dshmn-stamp[data-tone=error]{color:var(--dsw-alias-state-error-primary)}
-
-/* ── 判决条：全页唯一的填充面 ────────────────────────────────────────────── */
-.dshmn-verdict{display:flex;flex-direction:column;gap:8px;padding:14px 16px;border-radius:12px;min-width:0;
-  background:var(--dsw-alias-bg-module-platform);border:.5px solid var(--dsw-alias-border-l3)}
+.dshmn-stamp[data-tone=dirty]{color:var(--dsw-alias-label-primary)}
+
+/* ── 判决条：全页唯一的填充面，也是唯一的状态色 hero ─────────────────────
+   左侧 3px 竖条与标题色都由 data-tone 决定，颜色全部来自 state token（不硬编码）。
+   三态：可发信 = success / 需补配置 = warn / 已关闭 = label-tertiary。 */
+/* 按钮：按宿主线上规则（.primary/.outline + .sm）自绘 —— 见 Button() 注释里为什么不能等宿主原语 */
+.dshmn-btn{display:inline-flex;align-items:center;justify-content:center;gap:6px;box-sizing:border-box;
+  height:28px;padding:0 10px;border:none;border-radius:8px;font-family:inherit;
+  font-size:12px;line-height:18px;cursor:pointer;background:transparent;color:var(--dsw-alias-label-primary)}
+.dshmn-btn[data-variant=primary]{background:var(--dsw-alias-button-primary-fill);color:var(--dsw-alias-label-primary-foreground)}
+.dshmn-btn[data-variant=primary]:hover:not(:disabled){background:var(--dsw-alias-button-primary-hover)}
+.dshmn-btn[data-variant=outline]{border:.5px solid var(--dsw-alias-border-l3)}
+.dshmn-btn[data-variant=outline]:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover)}
+.dshmn-btn:disabled{opacity:.5;cursor:not-allowed}
+.dshmn-btn:focus-visible{outline:2px solid var(--dsw-alias-border-l3);outline-offset:2px}
+
+.dshmn-verdict{display:flex;flex-direction:column;gap:8px;min-width:0;padding:18px 20px 16px;border-radius:20px;
+  background:var(--dsw-alias-bg-module-platform);border-left:3px solid var(--dsw-alias-label-tertiary)}
+.dshmn-verdict[data-tone=done]{border-left-color:var(--dsw-alias-state-success-primary)}
+.dshmn-verdict[data-tone=warning]{border-left-color:var(--dsw-alias-state-warn-primary)}
+.dshmn-verdict[data-tone=idle]{border-left-color:var(--dsw-alias-label-tertiary)}
+.dshmn-verdict[data-tone=error]{border-left-color:var(--dsw-alias-state-error-primary)}
 .dshmn-verdictHead{display:flex;align-items:center;gap:8px;min-width:0;flex-wrap:wrap}
-.dshmn-verdictTitle{margin:0;min-width:0;color:var(--dsw-alias-label-primary);font-size:16px;line-height:24px;font-weight:500}
-.dshmn-verdictWhy{margin:0;color:var(--dsw-alias-label-secondary);font-size:13px;line-height:20px}
-.dshmn-verdictFoot{display:flex;align-items:center;justify-content:flex-end;gap:8px;flex-wrap:wrap;margin-top:2px}
-.dshmn-evidence{display:flex;flex-direction:column;gap:2px;margin-top:2px;padding-top:10px;min-width:0;
-  border-top:.5px solid var(--dsw-alias-border-l3);color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}
+.dshmn-verdictTitle{margin:0;min-width:0;color:var(--dsw-alias-label-primary);font-size:18px;line-height:26px;font-weight:600}
+.dshmn-verdict[data-tone=done] .dshmn-verdictTitle{color:var(--dsw-alias-state-success-primary)}
+.dshmn-verdict[data-tone=warning] .dshmn-verdictTitle{color:var(--dsw-alias-state-warn-primary)}
+.dshmn-verdict[data-tone=idle] .dshmn-verdictTitle{color:var(--dsw-alias-label-tertiary)}
+.dshmn-verdict[data-tone=error] .dshmn-verdictTitle{color:var(--dsw-alias-state-error-primary)}
+.dshmn-verdictWhy{margin:0;color:var(--dsw-alias-label-secondary);font-size:14px;line-height:22px}
+.dshmn-verdictFoot{display:flex;align-items:center;justify-content:flex-end;gap:8px;flex-wrap:wrap;margin-top:4px}
+.dshmn-evidence{display:flex;flex-direction:column;gap:4px;min-width:0;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}
 .dshmn-evidenceKey{color:var(--dsw-alias-label-tertiary)}
 .dshmn-evidence[data-ok=false] .dshmn-evidenceKey{color:var(--dsw-alias-state-error-primary)}
 .dshmn-evidence .dshmn-mono{color:var(--dsw-alias-label-secondary);word-break:break-all}
 
-/* ── 分组：段头 + 发丝线。不做卡片、不编号 ──────────────────────────────── */
-.dshmn-group{display:flex;flex-direction:column;margin-top:24px;min-width:0}
-.dshmn-groupHead{display:flex;align-items:baseline;justify-content:space-between;gap:12px;flex-wrap:wrap;
-  padding-bottom:6px;border-bottom:.5px solid var(--dsw-alias-border-l3)}
-.dshmn-groupTitle{margin:0;color:var(--dsw-alias-label-primary);font-size:14px;line-height:22px;font-weight:500}
-.dshmn-groupState{flex:none;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:22px;font-variant-numeric:tabular-nums}
-.dshmn-groupBody{display:flex;flex-direction:column;min-width:0}
-
-/* ── 条目：分隔线长在条目上，这样"父行 + 缩进子行"之间只画一条线 ─────────── */
-.dshmn-item{display:flex;flex-direction:column;gap:8px;padding:12px 0;min-width:0;
+/* ── 三张卡片：靠 .5px 描边成立，不靠底色（浅色主题下所有 bg-layer 都是纯白）──
+   描边 + radius 20 + padding 14 16 + 内部 gap 12，与宿主 settings 的 rowCard 同构。 */
+.dshmn-card{display:flex;flex-direction:column;gap:12px;min-width:0;padding:14px 16px;
+  border:.5px solid var(--dsw-alias-border-l4);border-radius:20px}
+.dshmn-card + .dshmn-card{margin-top:12px}
+.dshmn-verdict + .dshmn-card{margin-top:16px}
+.dshmn-cardHead{display:flex;align-items:baseline;justify-content:space-between;gap:12px;flex-wrap:wrap;min-width:0}
+.dshmn-cardTitle{margin:0;color:var(--dsw-alias-label-primary);font-size:14px;line-height:22px;font-weight:500}
+.dshmn-cardState{flex:none;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px;font-variant-numeric:tabular-nums}
+.dshmn-cardBody{display:flex;flex-direction:column;min-width:0}
+/* 卡片自己已经给了 14px 上内边距：里面的第一个元素不要再叠一层上边距 */
+.dshmn-cardBody>:first-child{padding-top:0}
+.dshmn-cardBody>:last-child{padding-bottom:0;border-bottom:none}
+
+/* ── 行：线只长在行自己身上（.5px border-l2，最后一行没有），上下各 16px ────── */
+.dshmn-item{display:flex;flex-direction:column;gap:8px;padding:16px 0;min-width:0;
   border-bottom:.5px solid var(--dsw-alias-border-l2)}
 .dshmn-item:last-child{padding-bottom:0;border-bottom:none}
-.dshmn-itemHead{display:flex;align-items:flex-start;justify-content:space-between;gap:16px;min-width:0}
-.dshmn-itemText{display:flex;flex-direction:column;gap:4px;flex:1 1 auto;min-width:0}
-.dshmn-itemTitle{color:var(--dsw-alias-label-primary);font-size:14px;line-height:22px}
-.dshmn-itemCtrl{flex:none;display:flex;align-items:center;gap:8px;min-height:22px}
-/* 缩进子行：把"它只对上面那一项生效"画成结构，而不是再写一句说明 */
-.dshmn-sub{display:flex;flex-direction:column;gap:8px;margin-left:3px;padding-left:12px;min-width:0;
+.dshmn-itemHead{display:flex;align-items:baseline;justify-content:space-between;gap:12px;min-width:0}
+.dshmn-labelRow{display:inline-flex;align-items:center;gap:6px;min-width:0}
+
+/* ── 开关行：标题 14/22·400 + 问号 + 开关。说明折进问号里，默认不占版面 ───────── */
+.dshmn-row{display:flex;flex-direction:column;gap:8px;padding:16px 0;min-width:0;
+  border-bottom:.5px solid var(--dsw-alias-border-l2)}
+.dshmn-row:last-child{padding-bottom:0;border-bottom:none}
+.dshmn-rowHead{display:flex;align-items:center;justify-content:space-between;gap:12px;min-width:0}
+.dshmn-rowTitle{display:flex;align-items:center;gap:6px;min-width:0;color:var(--dsw-alias-label-primary);font-size:14px;line-height:22px;font-weight:400}
+.dshmn-rowName{min-width:0}
+.dshmn-rowCtrl{flex:none;display:flex;align-items:center;gap:8px;min-height:22px}
+.dshmn-rowNote{margin:0;max-width:44em;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}
+/* 问号：原生 button（点击开合，触屏点得到，键盘 tab 得到），16×16 只占一个行内空位 */
+.dshmn-q{flex:none;box-sizing:border-box;display:inline-flex;align-items:center;justify-content:center;
+  width:16px;height:16px;padding:0;cursor:pointer;
+  border:.5px solid var(--dsw-alias-border-l4);border-radius:50%;background:none;
+  color:var(--dsw-alias-label-tertiary);font:inherit;font-size:11px;line-height:1}
+.dshmn-q:hover{color:var(--dsw-alias-label-primary);border-color:var(--dsw-alias-border-l3)}
+.dshmn-q[aria-expanded=true]{color:var(--dsw-alias-label-primary);background:var(--dsw-alias-interactive-bg-hover);
+  border-color:var(--dsw-alias-border-l3)}
+
+/* ── 折叠标题（「更多」「还有 3 种情况」）：一行文字按钮，展开后缩进一道竖线 ── */
+.dshmn-fold{display:inline-flex;align-items:center;align-self:flex-start;gap:4px;padding:0;cursor:pointer;
+  border:none;background:none;color:var(--dsw-alias-label-secondary);font:inherit;font-size:13px;line-height:20px;
+  text-decoration:underline;text-underline-offset:3px;text-decoration-color:var(--dsw-alias-border-l4)}
+.dshmn-fold:hover{color:var(--dsw-alias-label-primary)}
+.dshmn-fold[aria-expanded=true]{color:var(--dsw-alias-label-primary);text-decoration:none}
+.dshmn-foldBody{display:flex;flex-direction:column;gap:8px;min-width:0;margin-top:8px;padding-left:12px;
   border-left:.5px solid var(--dsw-alias-border-l2)}
-.dshmn-sub[data-muted=true]{opacity:.5}
+.dshmn-q:focus-visible,.dshmn-fold:focus-visible,.dshmn-link:focus-visible,.dshmn-segBtn:focus-visible{
+  outline:2px solid var(--dsw-alias-brand-primary);outline-offset:2px}
 
-/* ── 字段：标签在上、控件满宽（宿主 settings-models 的 fieldLabel 同款） ── */
-.dshmn-field{display:flex;flex-direction:column;gap:6px;min-width:0}
-.dshmn-label{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px;font-weight:500}
+/* ── 字段：标签在上、控件满宽（宿主 settings 的字段同款）────────────────────── */
+.dshmn-field{display:flex;flex-direction:column;gap:8px;min-width:0}
+.dshmn-label{color:var(--dsw-alias-label-primary);font-size:13px;line-height:1.5;font-weight:500}
 .dshmn-hint{margin:0;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px;max-width:44em}
 .dshmn-error{margin:0;color:var(--dsw-alias-state-error-primary);font-size:12px;line-height:18px;word-break:break-word}
 .dshmn-credState{display:inline-flex;align-items:center;gap:6px;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}
@@ -5803,94 +5729,58 @@ window.__ModuleLoader__.load({
 
 /* ── 输入 ──────────────────────────────────────────────────────────────── */
 /* 宿主的 Input 原语是 content-box 的 inline-flex（padding 0 8px + .5px 描边）,
-   所以光给 width:100% 会让它比父级宽出 18px、顶出内容列。必须一起给 border-box。 */
+   所以光给 width:100% 会让它比父级宽出 18px、顶出内容列。必须一起给 border-box。
+   这里是原语缺席时的兜底输入框：底色 / 描边 / 圆角与宿主 Input 对齐（bg-layer-3 + border-l4 + 12）。 */
 .dshmn-inputWrap{box-sizing:border-box;display:flex;width:100%;min-width:0}
 .dshmn-inputWrap>*{box-sizing:border-box;width:100%;min-width:0}
-.dshmn-textarea{box-sizing:border-box;width:100%;min-height:64px;padding:8px 10px;resize:vertical;outline:none;
-  border:.5px solid var(--dsw-alias-border-l4);border-radius:8px;background:var(--dsw-alias-bg-layer-1);
+.dshmn-textarea{box-sizing:border-box;width:100%;min-height:52px;padding:8px 10px;resize:vertical;outline:none;
+  border:.5px solid var(--dsw-alias-border-l4);border-radius:12px;background:var(--dsw-alias-bg-layer-3);
   color:var(--dsw-alias-label-primary);font:inherit;font-size:14px;line-height:22px}
 .dshmn-textarea::placeholder{color:var(--dsw-alias-label-tertiary)}
-.dshmn-select{box-sizing:border-box;width:100%;height:36px;padding:0 10px;outline:none;
-  border:.5px solid var(--dsw-alias-border-l4);border-radius:8px;background:var(--dsw-alias-bg-layer-1);
-  color:var(--dsw-alias-label-primary);font:inherit;font-size:14px}
+.dshmn-select{box-sizing:border-box;width:100%;height:32px;padding:0 10px;outline:none;
+  border:.5px solid var(--dsw-alias-border-l4);border-radius:12px;background:var(--dsw-alias-bg-layer-3);
+  color:var(--dsw-alias-label-primary);font:inherit;font-size:14px;line-height:22px}
 .dshmn-textarea:focus-visible,.dshmn-select:focus-visible{border-color:var(--dsw-alias-brand-primary);
   box-shadow:0 0 0 2px var(--dsw-alias-border-l3)}
 .dshmn-textarea[aria-invalid=true]{border-color:var(--dsw-alias-state-error-primary)}
 
-/* ── 发件人清单：一行一个身份，选中用 module 面（与 segBtn 的选中语言一致）──── */
-/* 清单本身是个带描边的容器，条目之间只画发丝线——和 Group 的语言保持一致。 */
-.dshmn-senders{display:flex;flex-direction:column;border:.5px solid var(--dsw-alias-border-l4);
-  border-radius:8px;background:var(--dsw-alias-bg-layer-1);overflow:hidden}
-.dshmn-sender{display:flex;align-items:center;gap:10px;padding:0 6px 0 10px;min-height:46px;cursor:pointer;
-  border-bottom:.5px solid var(--dsw-alias-border-l2)}
-.dshmn-sender:last-child{border-bottom:none}
-.dshmn-sender:hover{background:var(--dsw-alias-interactive-bg-hover)}
-.dshmn-sender[data-active=true]{background:var(--dsw-alias-bg-module-platform)}
-.dshmn-senderRadio{flex:none;width:15px;height:15px;margin:0;cursor:pointer;accent-color:var(--dsw-alias-brand-primary)}
-.dshmn-senderBody{flex:1 1 auto;min-width:0;display:flex;flex-direction:column;padding:7px 0}
-.dshmn-senderName{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;
-  color:var(--dsw-alias-label-primary);font-size:14px;line-height:20px}
-.dshmn-sender[data-active=true] .dshmn-senderName{font-weight:500}
-.dshmn-senderAddr{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;
-  color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}
-.dshmn-senderBadge{flex:none;color:var(--dsw-alias-state-success-primary);font-size:12px;line-height:18px}
-.dshmn-senderIcon{flex:none;box-sizing:border-box;width:26px;height:26px;display:inline-flex;align-items:center;
-  justify-content:center;padding:0;cursor:pointer;border:none;border-radius:6px;background:none;
-  color:var(--dsw-alias-label-tertiary);font:inherit;font-size:15px;line-height:1}
-.dshmn-senderIcon:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}
-.dshmn-senderIcon:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}
-.dshmn-senderEmpty{padding:12px;color:var(--dsw-alias-label-tertiary);font-size:13px;line-height:22px}
-.dshmn-senderAdd{box-sizing:border-box;align-self:flex-start;display:inline-flex;align-items:center;gap:6px;
-  margin:8px 10px;height:30px;padding:0 13px;cursor:pointer;font:inherit;font-size:13px;line-height:18px;
-  border:.5px dashed var(--dsw-alias-border-l4);border-radius:15px;background:transparent;
-  color:var(--dsw-alias-label-secondary)}
-.dshmn-senderAdd:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}
-.dshmn-senderAdd:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:2px}
-
-/* SMTP 三个短字段排一行；窄屏折成一列——别竖着排三个满宽输入。 */
-.dshmn-grid{display:grid;grid-template-columns:minmax(0,1fr) 88px 104px;gap:10px;align-items:start;min-width:0}
-.dshmn-num{display:inline-flex;align-items:center;gap:6px;min-width:0}
-.dshmn-numBox{width:78px;min-width:0}
-.dshmn-numBox>*,.dshmn-numBox input{box-sizing:border-box;width:100%;min-width:0}
-.dshmn-unit{flex:none;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}
-
-/* ── 单选：宿主"外观"三张卡的形态 —— 未选=白底+发丝线，选中=module 面 ──── */
-.dshmn-seg{display:flex;align-items:center;gap:8px;flex-wrap:wrap}
-.dshmn-segBtn{box-sizing:border-box;height:32px;padding:0 14px;cursor:pointer;font:inherit;font-size:13px;line-height:20px;
-  border:.5px solid var(--dsw-alias-border-l4);border-radius:16px;background:var(--dsw-alias-bg-layer-1);
+/* 两列：主机 + 用户名。端口 / 加密在「更多」里，同样两列，只是端口窄一点。 */
+.dshmn-two{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1fr);gap:12px 16px;align-items:start;min-width:0}
+.dshmn-twoPort{display:grid;grid-template-columns:96px minmax(0,1fr);gap:12px 16px;align-items:start;min-width:0}
+
+/* ── 预设 chips：一行横向滚动（窄屏也不折成三排），滚动条藏起来 ─────────────── */
+.dshmn-chips{display:flex;align-items:center;gap:8px;min-width:0;overflow-x:auto;overflow-y:hidden;padding:2px 0;
+  scrollbar-width:none;-ms-overflow-style:none}
+.dshmn-chips::-webkit-scrollbar{display:none}
+.dshmn-segBtn{box-sizing:border-box;flex:none;height:28px;padding:0 12px;cursor:pointer;white-space:nowrap;
+  font:inherit;font-size:12px;line-height:18px;
+  border:.5px solid var(--dsw-alias-border-l4);border-radius:8px;background:none;
   color:var(--dsw-alias-label-secondary)}
 .dshmn-segBtn:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}
-.dshmn-segBtn[data-active=true]{background:var(--dsw-alias-bg-module-platform);border-color:var(--dsw-alias-border-l3);
-  color:var(--dsw-alias-label-primary);font-weight:500}
-.dshmn-segBtn:focus-visible,.dshmn-link:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:2px}
+.dshmn-segBtn[data-active=true]{background:var(--dsw-alias-bg-module-platform);border-color:var(--dsw-alias-brand-primary);color:var(--dsw-alias-brand-primary);font-weight:600;
+  color:var(--dsw-alias-label-primary);font-weight:600}
 
 /* ── 文字按钮 ──────────────────────────────────────────────────────────── */
-.dshmn-link{color:var(--dsw-alias-label-secondary);font:inherit;font-size:12px;line-height:18px;cursor:pointer;
+.dshmn-link{color:var(--dsw-alias-label-secondary);font:inherit;font-size:13px;line-height:20px;cursor:pointer;
   padding:0;border:none;background:none;text-decoration:underline;text-underline-offset:3px;
   text-decoration-color:var(--dsw-alias-border-l4)}
 .dshmn-link:hover{color:var(--dsw-alias-label-primary)}
 .dshmn-link:disabled{color:var(--dsw-alias-label-tertiary);cursor:default;text-decoration:none}
 
-/* ── 折叠区与页脚 ──────────────────────────────────────────────────────── */
-.dshmn-disclose{margin-top:0}
-.dshmn-discloseBody{display:flex;flex-direction:column;gap:4px;padding-top:10px;min-width:0}
-/* 展开后的内容：缩进 + 一道左竖线，跟 SMTP 子块同一套语言——
-   折叠区打开后必须一眼看出"这些东西属于上面那一行"，而不是又一组平铺的设置。 */
-.dshmn-stack{display:flex;flex-direction:column;gap:14px;min-width:0;margin-top:10px;
-  padding-left:12px;border-left:1px solid var(--dsw-alias-border-l2)}
-/* 内容自带行节奏时（Row 自己有内边距和发丝线）只保留缩进，别再叠一层间距 */
-.dshmn-stack[data-rows=true]{gap:0}
-.dshmn-foot{display:flex;align-items:center;justify-content:flex-end;gap:12px;flex-wrap:wrap;margin-top:24px;
-  padding-top:14px;border-top:.5px solid var(--dsw-alias-border-l3)}
-.dshmn-helpBody{white-space:pre-wrap;color:var(--dsw-alias-label-secondary);font-size:13px;line-height:21px}
+/* ── 页脚与帮助正文：页脚不画线，只留一条 12/18 的链接 ───────────────────── */
+.dshmn-foot{display:flex;align-items:center;justify-content:flex-end;gap:12px;flex-wrap:wrap;margin-top:16px;padding-top:16px}
+.dshmn-foot .dshmn-link{font-size:12px;line-height:18px}
+.dshmn-helpBody{white-space:pre-wrap;color:var(--dsw-alias-label-secondary);font-size:14px;line-height:22px}
 
 /* ── 窄屏：宿主 settings 页的断点就是 560px ─────────────────────────────── */
 @media (max-width:560px){
-  .dshmn-head{flex-direction:column;gap:4px}
+  .dshmn-head{flex-direction:column;align-items:stretch;gap:12px}
+  .dshmn-headActions{justify-content:flex-start}
   .dshmn-verdictFoot{justify-content:flex-start}
-  .dshmn-grid{grid-template-columns:minmax(0,1fr)}
-  .dshmn-numBox{width:auto;flex:1 1 auto}
+  .dshmn-two,.dshmn-twoPort{grid-template-columns:minmax(0,1fr)}
+  .dshmn-card{padding:12px 14px}
 }
+
 `;
 
 
@@ -5936,10 +5826,25 @@ window.__ModuleLoader__.load({
       return h('span', { 'aria-hidden': 'true' }, '✓');
     }
 
-    /** 按钮。 */
+    /**
+     * 按钮。
+     *
+     * 实测：当前宿主版本**没有** P.Button 这个原语（web bundle 里只有 MenuItemButton），
+     * 所以兜底分支才是实际走的那条。之前它退化成 .dshmn-link（带下划线的文字），
+     * 页面上因此一个"有体量"的按钮都没有——这是整页显得扁平的重要原因。
+     * 这里按宿主线上按钮的规则自绘：primary = button-primary-fill + label-primary-foreground，
+     * outline = 0.5px border-l3 + 透明底，尺寸照 sm（高 28 / 12px 字 / 圆角 8）。
+     */
     function Button(props) {
       if (typeof P.Button === 'function') return h(P.Button, props);
-      return h('button', { type: 'button', className: 'dshmn-link', onClick: props.onClick, disabled: props.disabled }, props.children);
+      return h('button', {
+        type: 'button',
+        className: 'dshmn-btn',
+        'data-variant': props.variant ?? 'outline',
+        disabled: props.disabled,
+        title: props.title,
+        onClick: props.onClick,
+      }, props.children);
     }
 
     /** 输入框（宿主原语自带 0.5px 发丝描边与 focus-within 主题色）。 */
@@ -5971,102 +5876,55 @@ window.__ModuleLoader__.load({
       }, children);
     }
 
-    /**
-     * 折叠区。优先用宿主原语，取不到再退化为本地实现。
-     * @param {object} props 折叠参数
-     * @returns {object} React 元素
-     */
-    function Disclosure(props) {
-      const { title, open, onToggle, children } = props;
-      if (typeof P.DisclosureRow === 'function') {
-        return h('div', { className: 'dshmn-disclose' }, h(P.DisclosureRow, {
-          title,
-          open: open === true,
-          expandable: true,
-          expandOnRowClick: true,
-          onToggle,
-        }, children));
-      }
-      const head = h('button', {
-        type: 'button',
-        className: 'dshmn-link',
-        'aria-expanded': open === true,
-        onClick: onToggle,
-      }, `${open === true ? '▾' : '▸'} ${title}`);
-      const body = open === true ? h('div', { className: 'dshmn-discloseBody' }, children) : null;
-      return h('div', { className: 'dshmn-disclose' }, head, body);
-    }
+    // 折叠区（「更多」「还有 3 种情况」）统一用下面这个 foldHead 拼在页内：
+    // 开合状态留在 MailNotifyPage 自己的 useState 里，于是「收起时标题带当前值」与
+    // 「开合状态可断言」两件事同时成立；旧的 Disclosure 包装随之删除。
 
     // ---------------------------------------------------------------------------
     // 页面
     // ---------------------------------------------------------------------------
 
     /**
-     * 一个分组：段头（名字 + 这一段的结论）+ 一条发丝线，内容靠行与行之间的分隔线组织。
+     * 一张卡片（宿主 models / agent-preset / account 三页同款）：
+     * .5px 描边 + radius 20 + padding 14 16 + 内部 gap 12；标题 14/22·500，右侧可带一条 12/18 状态读数。
      *
-     * **不编号、不套卡片。** 以前是 `1 收件人 / 2 怎么发 / 3 什么时候发给我` 三张同款灰卡，
-     * 编号把并列的三个设置组伪装成步骤序列（内容并不是步骤），三块同款灰又让主次消失。
-     * @param {object} props 分组参数
+     * **不编号。** 三张卡片是并列的三个设置组，编号会把并列伪装成步骤序列（内容并不是步骤）。
+     * **不靠底色。** 卡片底色等于面板底色（浅色主题下所有 bg-layer 都是纯白），
+     * 卡片只靠描边成立——这也正是宿主 settings 卡片的样子。
+     * 每张卡片另带一个语义修饰类（dshmn-card-recipients / -transport / -outcomes），
+     * 它们只是给 DOM 一个稳定的抓手（和宿主的 data-* 一个用途），样式仍由 .dshmn-card 一份承担。
+     * @param {object} props 卡片参数（kind 是修饰类后缀）
      * @returns {object} React 元素
      */
-    function Group(props) {
-      const { title, state, children } = props;
-      return h('section', { className: 'dshmn-group', 'aria-label': title },
-        h('div', { className: 'dshmn-groupHead' },
-          h('h3', { className: 'dshmn-groupTitle' }, title),
-          state === undefined ? null : h('span', { className: 'dshmn-groupState' }, state)),
-        h('div', { className: 'dshmn-groupBody' }, children));
+    function Card(props) {
+      const { title, state, kind, children } = props;
+      const className = kind === undefined ? 'dshmn-card' : `dshmn-card dshmn-card-${kind}`;
+      return h('section', { className, 'aria-label': title },
+        h('div', { className: 'dshmn-cardHead' },
+          h('h3', { className: 'dshmn-cardTitle' }, title),
+          state === undefined ? null : h('span', { className: 'dshmn-cardState' }, state)),
+        h('div', { className: 'dshmn-cardBody' }, children));
     }
 
     /**
-     * 一行：标题 + 说明在左，控件在右。
-     * @param {object} props 行参数
-     * @returns {object} React 元素
-     */
-    function Row(props) {
-      const { title, hint, control, htmlFor, children } = props;
-      return h('div', { className: 'dshmn-item' },
-        h('div', { className: 'dshmn-itemHead' },
-          h('div', { className: 'dshmn-itemText' },
-            htmlFor === undefined
-              ? h('div', { className: 'dshmn-itemTitle' }, title)
-              : h('label', { className: 'dshmn-itemTitle', htmlFor }, title),
-            hint === undefined ? null : h('div', { className: 'dshmn-hint' }, hint)),
-          control === undefined ? null : h('div', { className: 'dshmn-itemCtrl' }, control)),
-        children);
-    }
-
-    /**
-     * 缩进子行：表达"这一项只对上面那一项生效"，而不是再补一句说明。
-     * 父项关掉时整块压暗，但仍然可见——它没被删掉，只是暂时不参与。
-     * @param {object} props 子行参数
+     * 折叠标题：一行原生按钮（点击开合，键盘 tab 得到），标题自带 ▸/▾ 表示开合状态。
+     *
+     * 不用宿主原语 DisclosureRow：它把标题包进自己的结构里，而这一轮要求
+     * 「收起时把当前值写在标题上」，也需要单测能直接看见开合状态。
+     * @param {string} id 受控内容区的 id（aria-controls）
+     * @param {string} label 标题文字（已含当前值）
+     * @param {boolean} open 是否展开
+     * @param {Function} onToggle 点击开合
      * @returns {object} React 元素
      */
-    function Sub(props) {
-      const { title, hint, control, muted } = props;
-      return h('div', { className: 'dshmn-sub', 'data-muted': muted === true ? 'true' : 'false' },
-        h('div', { className: 'dshmn-itemHead' },
-          h('div', { className: 'dshmn-itemText' },
-            h('div', { className: 'dshmn-itemTitle' }, title),
-            hint === undefined ? null : h('div', { className: 'dshmn-hint' }, hint)),
-          control === undefined ? null : h('div', { className: 'dshmn-itemCtrl' }, control)));
-    }
-
-    /** 带单位后缀的数字输入（贴在一行里，所以宽度定死；单位常驻可见）。 */
-    function NumberField({ id, value, unit, onChange, onBlur, placeholder, label }) {
-      return h('span', { className: 'dshmn-num' },
-        h('span', { className: 'dshmn-numBox' },
-          h(TextInput, {
-            id,
-            type: 'number',
-            inputMode: 'numeric',
-            value: value ?? '',
-            placeholder,
-            'aria-label': label,
-            onChange: (event) => onChange(event.target.value === '' ? '' : Number(event.target.value)),
-            onBlur,
-          })),
-        h('span', { className: 'dshmn-unit' }, unit));
+    function foldHead(id, label, open, onToggle) {
+      return h('button', {
+        type: 'button',
+        className: 'dshmn-fold',
+        'aria-expanded': open === true ? 'true' : 'false',
+        'aria-controls': id,
+        onClick: onToggle,
+      }, (open === true ? '▾ ' : '▸ ') + label);
     }
 
     /**
@@ -6078,9 +5936,15 @@ window.__ModuleLoader__.load({
       const { remotes } = props;
       const t = (key, params) => i18n.t(key, params);
 
-      const [ready, setReady] = React.useState(remotes.current !== null);
+      /** settings 远程真的可用了吗。ready 只认它——rpc / credentials 先到都不算。 */
+      const settingsAvailable = () => typeof remotes.current?.settings?.describe === 'function';
+      // 就绪的判定必须收到 settings 上：只看 remotes.current 非空的话，connection 先注入就会把 ready
+      // 烧成 true，而 load() 当时读不到 settings、直接返回——之后 settings 真的到了也没人再叫它，
+      // 这一页就永远停在空态（按钮全禁用，连读失败都不报）。
+      const [ready, setReady] = React.useState(() => settingsAvailable());
       const [attempt, setAttempt] = React.useState(0);
       const [draft, setDraft] = React.useState({});
+      const [baseline, setBaseline] = React.useState({});
       const [save, setSave] = React.useState({ phase: 'idle', at: 0, error: '' });
       const [now, setNow] = React.useState(() => Date.now());
       const [credentialState, setCredentialState] = React.useState({});
@@ -6088,26 +5952,20 @@ window.__ModuleLoader__.load({
       const [credCheck, setCredCheck] = React.useState(0);
       const [pwDraft, setPwDraft] = React.useState({});
       const [pwClear, setPwClear] = React.useState({});
+      const [pwEdit, setPwEdit] = React.useState({});
       const [resetting, setResetting] = React.useState(false);
       const [confirmReset, setConfirmReset] = React.useState(false);
       const [helpKind, setHelpKind] = React.useState(null);
-      const [test, setTest] = React.useState({ phase: 'idle', transport: '', ms: 0, error: '' });
-      const [lastDelivery, setLastDelivery] = React.useState(null);
-      const [capability, setCapability] = React.useState('unknown');
+      const [test, setTest] = React.useState({ phase: 'idle', ms: 0, error: '' });
       const [showMoreOutcomes, setShowMoreOutcomes] = React.useState(false);
-      const [showSender, setShowSender] = React.useState(false);
-      /** 发件人弹层的编辑态：null = 关闭；{ index, name, address }，index === 清单长度 表示新增。 */
-      const [senderEdit, setSenderEdit] = React.useState(null);
-      /** 发件人弹层的就地报错文案（空串 = 没报错）。 */
-      const [senderErr, setSenderErr] = React.useState('');
-      const [showAdvanced, setShowAdvanced] = React.useState(false);
-      const [customHost, setCustomHost] = React.useState(false);
+      /** 端口 / 加密收在「更多」里，默认收起（偏离默认值时标题会带上现值）。 */
+      const [moreOpen, setMoreOpen] = React.useState(false);
+      /** 每个事件开关行自己的说明开合：点问号切一行，互不影响。 */
+      const [openHints, setOpenHints] = React.useState({});
 
       const draftRef = React.useRef({});
       const baselineRef = React.useRef({});
       const viewRef = React.useRef(null);
-      const timers = React.useRef({});
-      const pwTimers = React.useRef({});
       // 语言切换时强制重渲染（locale 服务只在变化时通知，不驱动 React）
       const [, setLocaleRev] = React.useState(0);
 
@@ -6117,33 +5975,62 @@ window.__ModuleLoader__.load({
         return locale.subscribe(() => setLocaleRev((n) => n + 1));
       }, []);
 
-      // 远程命名空间迟到：最多轮询 40 次（约 6 秒）
+      // 远程命名空间迟到：最多轮询 40 次（约 6 秒）。只认 settings，别的服务晚到不算就绪。
       React.useEffect(() => {
         if (ready || attempt >= 40) return undefined;
         const timer = setTimeout(() => {
-          if (remotes.current !== null) setReady(true);
+          if (settingsAvailable()) setReady(true);
           setAttempt((n) => n + 1);
         }, 150);
         return () => clearTimeout(timer);
-      }, [ready, attempt, remotes]);
+      }, [ready, attempt]);
 
-      const load = React.useCallback(async () => {
+      /**
+       * 读一次配置，并按 **配置指纹** 认领本插件的那一项。
+       *
+       * 认领规则：ns 是 profile 入口 id（换 profile 就变），客户端不许写死。别拿 describe() 里的
+       * schema 当指纹——它是 schema.toJSON() 的快照（只有 uid/refs，没有 dict），按 dict 找永远
+       * 找不到。稳定指纹在 value 里：只有本插件同时声明 smtpHost 与 smtpPasswordRef。
+       *
+       * @param {{ preserveDraft?: boolean }} [options] preserveDraft = 冲突恢复模式：
+       *   用户的草稿**一个字都不动**（那是他刚填、还没写进去的东西），只把基线对齐服务端最新值、
+       *   revision 换成新的（viewRef.current 就是 revision 的持有者），下一次保存才不会再撞同一个值。
+       * @returns {Promise<void>}
+       */
+      const load = React.useCallback(async (options) => {
         const bridge = remotes.current;
+        const preserveDraft = options?.preserveDraft === true;
         if (bridge === null) return;
+        // settings 还没注入 ≠ 读不到配置：它只是还没到。这一档不落成 loadFailed，
+        // 免得把一次正常的迟到渲染成红色报错（ready 会为它再放行一次装载）。
+        if (typeof bridge?.settings?.describe !== 'function') {
+          setSave({ phase: 'unserved', at: 0, error: '' });
+          return;
+        }
         try {
           const described = unwrap(await bridge.settings.describe());
           const namespaces = Array.isArray(described?.namespaces) ? described.namespaces : [];
-          const found = namespaces.find((item) => item && item.ns === NS) ?? null;
+          const found = namespaces.find((d) => d && d.value && typeof d.value === 'object'
+            && Object.hasOwn(d.value, 'smtpHost') && Object.hasOwn(d.value, 'smtpPasswordRef')) ?? null;
           viewRef.current = found;
           const value = found && found.value && typeof found.value === 'object' ? { ...found.value } : {};
-          draftRef.current = value;
-          baselineRef.current = value;
-          setDraft(value);
+          baselineRef.current = { ...value };
+          setBaseline({ ...value });
+          if (preserveDraft) {
+            // 冲突恢复：草稿留着，只把基线与 revision 抬到最新——这样再过一次保存就是干净的写。
+            setSave(found === null
+              ? { phase: 'unserved', at: 0, error: '' }
+              : { phase: 'conflictReloaded', at: 0, error: '' });
+            return;
+          }
+          draftRef.current = { ...value };
+          setDraft({ ...value });
           setSave(found === null
-            ? { phase: 'error', at: 0, error: t('status.notServed') }
+            ? { phase: 'unserved', at: 0, error: '' }
             : { phase: 'idle', at: 0, error: '' });
         } catch (err) {
-          setSave({ phase: 'error', at: 0, error: String(err?.message ?? err) });
+          // 读失败是**独立的一档**：它不是「保存失败」，重试也不该去调 saveAll()。
+          setSave({ phase: 'loadFailed', at: 0, error: String(err?.message ?? err) });
         }
       }, [remotes]);
 
@@ -6169,43 +6056,27 @@ window.__ModuleLoader__.load({
         }
       }, [remotes]);
 
-      /** 最近一次投递结果 + Host 能力探测。 */
-      const refreshDelivery = React.useCallback(async () => {
-        // 顺带探一次能力：typert 清单是**服务器启动时**扫描注册的，
-        // 所以"connection 在"不等于"mailNotify 端点在"。探不到就老实说不可用，
-        // 而不是给一个点下去必然报错的按钮。
-        if (remotes.current?.rpc === undefined) {
-          setCapability('missing');
-          return;
-        }
-        try {
-          const state = unwrap(await callRemote('state'));
-          setCapability('ready');
-          setLastDelivery(state?.recent?.[0] ?? null);
-        } catch (err) {
-          setCapability('missing');
-          console.warn('[dsh-notify-p] Host 未提供 mailNotify 端点（重启 DSH 后生效）/ endpoint unavailable:', err);
-        }
-      }, [remotes]);
-
-      // 首次就绪后装载
+      // 首次就绪后装载。读失败 / 认领不到之后**不再自动重试**：
+      // 那两档各自有出路（「重新读取」按钮 / 换个 profile 再看），自动重试只会把读数一直抖回别处，
+      // 也会让「重新读取」到底点了没点变得看不出来。
       React.useEffect(() => {
-        if (ready && viewRef.current === null) void load();
-      }, [ready, load, attempt]);
+        if (!ready || viewRef.current !== null) return;
+        if (save.phase === 'loadFailed' || save.phase === 'unserved') return;
+        void load();
+      }, [ready, load, attempt, save.phase]);
 
       // `viewRef.current` 是 load() 里赋的**引用**，赋值不会触发重渲染。
       // 所以依赖数组里写 viewRef.current 是无效的：首次挂载时它还是 null，
       // load() 完成后依赖没变，这个 effect 永远不会再跑一遍 —— 结果就是
-      // 凭据永远是「还没保存」、投递账本永远读不到、测试按钮永远不出现。
+      // 凭据永远是「还没保存」、测试按钮永远不出现。
       // 在渲染期把它取成一个普通值参与依赖，false→true 那一次就会把下面几条读都带起来。
       const loaded = viewRef.current !== null;
 
       React.useEffect(() => {
         if (ready && loaded) {
           void refreshCredentials([viewRef.current?.value?.smtpPasswordRef]);
-          void refreshDelivery();
         }
-      }, [ready, loaded, refreshCredentials, refreshDelivery, attempt]);
+      }, [ready, loaded, refreshCredentials, attempt]);
 
       // 「已保存 · N 秒前」需要一个会走的钟；只在保存过之后跑，离开保存态就停
       React.useEffect(() => {
@@ -6244,161 +6115,209 @@ window.__ModuleLoader__.load({
       }, [refreshCredentials]);
 
       /**
-       * 把若干字段写回 Host（即时生效的核心）。
-       * @param {string[]} keys 要提交的字段名
-       * @returns {Promise<void>}
-       */
-      const commit = React.useCallback(async (keys) => {
-        const bridge = remotes.current;
-        const view = viewRef.current;
-        if (bridge === null || view === null) return;
-        const base = baselineRef.current ?? {};
-        const ops = [];
-        for (const key of keys) {
-          const value = draftRef.current[key];
-          if (value === base[key]) continue;
-          if (value === '' || value === null || value === undefined) ops.push({ op: 'unset', path: [key] });
-          else ops.push({ op: 'set', path: [key], value });
-        }
-        if (ops.length === 0) return;
-        setSave({ phase: 'saving', at: 0, error: '' });
-        try {
-          const next = unwrap(await bridge.settings.mutate(NS, ops, view.revision));
-          if (next && typeof next === 'object') {
-            viewRef.current = next;
-            baselineRef.current = next.value && typeof next.value === 'object' ? { ...next.value } : {};
-          }
-          setSave({ phase: 'saved', at: Date.now(), error: '' });
-        } catch (err) {
-          setSave({ phase: 'error', at: 0, error: String(err?.message ?? err) });
-          // 冲突或失败都重读一次，避免本地草稿与 Host 漂移
-          await load();
-        }
-      }, [remotes, load]);
-
-      /**
-       * 改一个字段。
+       * 改一个字段：**只改本地草稿**，不碰 Host。写回只发生在点「保存」的时候。
        * @param {string} key 字段名
        * @param {unknown} value 新值
-       * @param {{ immediate?: boolean, delay?: number }} [opts] 提交策略
        * @returns {void}
        */
-      const setField = React.useCallback((key, value, opts = {}) => {
+      const setField = React.useCallback((key, value) => {
         draftRef.current = { ...draftRef.current, [key]: value };
         setDraft(draftRef.current);
-        clearTimeout(timers.current[key]);
-        if (opts.immediate === true) {
-          void commit([key]);
-          return;
-        }
-        timers.current[key] = setTimeout(() => void commit([key]), opts.delay ?? TEXT_DEBOUNCE_MS);
-      }, [commit]);
-
-      /** 立刻提交某字段（失焦兜底）。 */
-      const flush = React.useCallback((key) => {
-        clearTimeout(timers.current[key]);
-        void commit([key]);
-      }, [commit]);
+      }, []);
 
       /**
-       * 一次改多个字段并**合成一次提交**。
-       *
-       * 必须批量：`commit` 带的是同一个 revision，连续发多个即时写入会互相冲突，
-       * 后发的会被 Host 拒绝并被随后的 load() 回滚——表面看就是"预设填了一半"。
+       * 一次改多个字段，合成同一份草稿（邮箱服务商预设用）。
+       * 保存是一次 mutate，所以这里不需要按字段拆开写。
        * @param {object} patch 字段名到新值的映射
        * @returns {void}
        */
       const setFields = React.useCallback((patch) => {
         draftRef.current = { ...draftRef.current, ...patch };
         setDraft(draftRef.current);
-        for (const key of Object.keys(patch)) clearTimeout(timers.current[key]);
-        void commit(Object.keys(patch));
-      }, [commit]);
-
-      /** 当前生效的发件人清单（含老配置迁移）。纯函数很便宜，不必 memo。 */
-      const senders = migrateSenders(draft);
-      /** 当前生效的地址。 */
-      const senderAddr = activeSenderAddress(draft, senders);
+      }, []);
 
       /**
-       * 写发件人清单。
-       *
-       * **必须同时清掉旧的 senderName / fromAddress**：清单为空时 Host 会回落到旧字段，
-       * 不清就会"刚删掉的那条又回来了"。
-       * 用 setFields 合成一次提交，两个字段共用同一个 revision，不会互相冲突。
-       * @param {{name: string, address: string}[]} list 新清单
-       * @param {string} active 新的生效地址（'' 表示清单为空）
-       * @returns {void}
+       * 还挂在草稿里的凭据引用名。引用名由凭据行自己给出（硬约束 4），不从别处猜。
+       * @returns {string[]} 需要写进凭据库的引用名
        */
-      const writeSenders = React.useCallback((list, active) => {
-        setFields({ senders: list, activeSender: active, senderName: '', fromAddress: '' });
-      }, [setFields]);
-
-      /** 打开发件人弹层：index 传清单长度即"新增"。 */
-      const openSenderDialog = React.useCallback((index) => {
-        const entry = index < senders.length ? senders[index] : { name: '', address: '' };
-        setSenderEdit({ index, name: entry.name, address: entry.address });
-        setSenderErr('');
-      }, [senders]);
-
-      /** 关闭发件人弹层。 */
-      const closeSenderDialog = React.useCallback(() => {
-        setSenderEdit(null);
-        setSenderErr('');
-      }, []);
-
-      /** 保存发件人弹层里的内容；不合法就地报错、不写入。 */
-      const saveSenderDialog = React.useCallback(() => {
-        const issue = senderIssue(senders, senderEdit.index, senderEdit);
-        if (issue !== '') {
-          setSenderErr(t(`sender.issue.${issue}`));
-          return;
+      const pendingCredentialRefs = React.useCallback(() => {
+        const refs = new Set();
+        for (const [ref, value] of Object.entries(pwDraft)) {
+          if (String(value ?? '').trim() !== '') refs.add(ref);
         }
-        const next = senderCommit({ list: senders, active: senderAddr, editing: senderEdit.index }, senderEdit);
-        writeSenders(next.list, next.active);
-        setSenderEdit(null);
-        setSenderErr('');
-      }, [senders, senderEdit, senderAddr, writeSenders, t]);
-
-      /** 选中某条发件人。 */
-      const pickSender = React.useCallback((address) => {
-        writeSenders(senders, address);
-      }, [senders, writeSenders]);
-
-      /** 删掉某条发件人。 */
-      const removeSender = React.useCallback((index) => {
-        const next = senderRemove({ list: senders, active: senderAddr }, index);
-        writeSenders(next.list, next.active);
-      }, [senders, senderAddr, writeSenders]);
+        for (const [ref, flag] of Object.entries(pwClear)) {
+          if (flag === true) refs.add(ref);
+        }
+        return [...refs].filter((ref) => String(ref ?? '').trim() !== '');
+      }, [pwDraft, pwClear]);
 
       /**
-       * 写凭据。**目标引用名由调用方给定**（硬约束 4），绝不从草稿里猜。
+       * 写一条凭据。**目标引用名由调用方给定**（硬约束 4），绝不从草稿里猜。
+       * 只有 saveAll 会调它：保存是唯一写凭据库的时机；失败就抛出，由调用方转成「保存失败」。
        * @param {string} ref 凭据引用名
        * @returns {Promise<void>}
        */
       const commitCredential = React.useCallback(async (ref) => {
         const bridge = remotes.current;
-        const view = viewRef.current;
-        if (bridge === null || view === null) return;
+        if (bridge === null) return;
         const name = String(ref ?? '').trim();
         if (name === '') return;
-        const value = pwDraft[name] ?? '';
+        const value = String(pwDraft[name] ?? '');
         const clearing = pwClear[name] === true;
-        if (!clearing && value === '') return;
+        if (!clearing && value.trim() === '') return;
+        if (clearing) unwrap(await bridge.credentials.unset(name));
+        else unwrap(await bridge.credentials.set(name, value));
+        setPwDraft((prev) => ({ ...prev, [name]: '' }));
+        setPwClear((prev) => ({ ...prev, [name]: false }));
+        await refreshCredentials([name]);
+      }, [remotes, pwDraft, pwClear, refreshCredentials]);
+
+      /**
+       * 保存：把草稿与基线的差异一次性写回。
+       *
+       * 顺序与原子性（这是这一页唯一的写入口）：
+       *   1. 配置字段合成**一次** mutate(found.ns, ops, revision)；
+       *   2. 授权码草稿与已存值不同时，再把它写进凭据库；
+       *   3. 两步都成功才进入「已保存」，并把 revision 换成 mutate 返回的新值。
+       *
+       * 三种失败各有各的出路，**都不清空草稿**（用户填的东西留在原地）：
+       *   - revision 冲突（settings/conflict）：自动重读，草稿不动、revision 换新，让用户再点一次；
+       *   - 只写了半截：分开报「哪一半成功、哪一半没成」，并只给失败那一半的重试按钮；
+       *   - 两半都没成：退回「保存失败：原因」+ 重试（凭据那边的原因一并带上）。
+       * @returns {Promise<void>}
+       */
+      const saveAll = React.useCallback(async () => {
+        const bridge = remotes.current;
+        const view = viewRef.current;
+        if (bridge === null || view === null) return;
+        const ops = diffOps(draftRef.current, baselineRef.current);
+        const credRefs = pendingCredentialRefs();
+        if (ops.length === 0 && credRefs.length === 0) {
+          setSave({ phase: 'idle', at: 0, error: '' });
+          return;
+        }
+        setSave({ phase: 'saving', at: 0, error: '' });
+        // 两半各自记账。一句「保存失败」会把已经成功的那一半也抹掉，用户根本不知道该重试哪边，
+        // 于是他会把两边都重做一遍——凭据那半还可能是清空再重填。所以这里分开记、分开报。
+        let configError = '';
+        let credError = '';
+        if (ops.length > 0) {
+          try {
+            const next = unwrap(await bridge.settings.mutate(view.ns, ops, view.revision));
+            const after = next && typeof next === 'object' ? next : view;
+            // ns 一律以这次返回的为准：认领来的 ns 不能被任何写死的东西盖回去。
+            viewRef.current = {
+              ...after,
+              ns: typeof after.ns === 'string' && after.ns !== '' ? after.ns : view.ns,
+            };
+            // 配置这一段已经真的落盘，基线抬到刚发出去的那份草稿；
+            // 万一接下来凭据写失败，脏读数就只剩那一条凭据。
+            baselineRef.current = { ...draftRef.current };
+            setBaseline({ ...draftRef.current });
+          } catch (err) {
+            if (isConflict(err)) {
+              // 别人先改了：**自动重读**（草稿原样保留、revision 换成新的），再让用户点一次保存。
+              // 不重读的话重试会拿着旧 revision 再撞一次，这条路是死的。
+              await load({ preserveDraft: true });
+              return;
+            }
+            configError = String(err?.message ?? err);
+          }
+        }
+        // 配置那半失败也照旧写凭据：两半互不依赖，一次点击把能落盘的那半落盘。
+        for (const ref of credRefs) {
+          try {
+            await commitCredential(ref);
+          } catch (err) {
+            credError = String(err?.message ?? err);
+            break;
+          }
+        }
+        const credWrote = credRefs.length > 0 && credError === '';
+        if (configError === '' && credError === '') {
+          setSave({ phase: 'saved', at: Date.now(), error: '' });
+          return;
+        }
+        if (configError === '') {
+          // 配置成功、凭据失败：只该重试凭据。
+          setSave({ phase: 'partialCred', at: 0, error: credError, credError: '' });
+          return;
+        }
+        if (credWrote) {
+          // 凭据成功、配置失败：只该重试配置。
+          setSave({ phase: 'partialConfig', at: 0, error: configError, credError: '' });
+          return;
+        }
+        // 两半都没成（或压根没凭据可写）：退回到原来的「保存失败」一档，但把凭据的原因也带上。
+        setSave({ phase: 'error', at: 0, error: configError, credError });
+      }, [remotes, pendingCredentialRefs, commitCredential, load]);
+
+      /** 只重试授权码（配置那一半已经写成功了）。 */
+      const retryCredentials = React.useCallback(async () => {
+        const credRefs = pendingCredentialRefs();
+        if (credRefs.length === 0) {
+          setSave({ phase: 'idle', at: 0, error: '' });
+          return;
+        }
         setSave({ phase: 'saving', at: 0, error: '' });
         try {
-          if (clearing) unwrap(await bridge.credentials.unset(name));
-          else unwrap(await bridge.credentials.set(name, value));
-          setPwDraft((prev) => ({ ...prev, [name]: '' }));
-          setPwClear((prev) => ({ ...prev, [name]: false }));
+          for (const ref of credRefs) await commitCredential(ref);
           setSave({ phase: 'saved', at: Date.now(), error: '' });
-          await refreshCredentials([name, draftRef.current?.smtpPasswordRef]);
         } catch (err) {
-          setSave({ phase: 'error', at: 0, error: String(err?.message ?? err) });
+          setSave({ phase: 'partialCred', at: 0, error: String(err?.message ?? err), credError: '' });
         }
-      }, [remotes, pwDraft, pwClear, refreshCredentials]);
+      }, [pendingCredentialRefs, commitCredential]);
+
+      /** 只重试配置（授权码那一半已经写成功了）。 */
+      const retryConfig = React.useCallback(async () => {
+        const bridge = remotes.current;
+        const view = viewRef.current;
+        if (bridge === null || view === null) return;
+        const ops = diffOps(draftRef.current, baselineRef.current);
+        if (ops.length === 0) {
+          setSave({ phase: 'idle', at: 0, error: '' });
+          return;
+        }
+        setSave({ phase: 'saving', at: 0, error: '' });
+        try {
+          const next = unwrap(await bridge.settings.mutate(view.ns, ops, view.revision));
+          const after = next && typeof next === 'object' ? next : view;
+          viewRef.current = {
+            ...after,
+            ns: typeof after.ns === 'string' && after.ns !== '' ? after.ns : view.ns,
+          };
+          baselineRef.current = { ...draftRef.current };
+          setBaseline({ ...draftRef.current });
+          setSave({ phase: 'saved', at: Date.now(), error: '' });
+        } catch (err) {
+          if (isConflict(err)) {
+            await load({ preserveDraft: true });
+            return;
+          }
+          setSave({ phase: 'partialConfig', at: 0, error: String(err?.message ?? err), credError: '' });
+        }
+      }, [remotes, load]);
 
-      /** 恢复默认：清掉本命名空间在 settings.yaml 里的全部覆盖。 */
+      /**
+       * 放弃改动：草稿整体回滚到基线，授权码草稿一并清掉，读数回到「没有未保存的改动」。
+       * @returns {void}
+       */
+      const discardAll = React.useCallback(() => {
+        const base = baselineRef.current ?? {};
+        draftRef.current = { ...base };
+        setDraft({ ...base });
+        setPwDraft({});
+        setPwClear({});
+        setPwEdit({});
+        setSave({ phase: 'idle', at: 0, error: '' });
+      }, []);
+
+      /**
+       * 恢复全部默认：清掉本命名空间在 profile 里的全部覆盖，**立即生效**。
+       *
+       * 它是破坏性操作，所以照旧先弹确认；确认之后不再受「保存」按钮约束——
+       * 语义就是「把服务端的覆盖清空」，草稿随后按服务端的新值重建。
+       */
       const resetAll = React.useCallback(async () => {
         const bridge = remotes.current;
         const view = viewRef.current;
@@ -6406,65 +6325,75 @@ window.__ModuleLoader__.load({
         setResetting(true);
         setSave({ phase: 'saving', at: 0, error: '' });
         try {
-          const next = unwrap(await bridge.settings.replace(NS, {}, view.revision));
-          if (next && typeof next === 'object') viewRef.current = next;
+          const next = unwrap(await bridge.settings.replace(view.ns, {}, view.revision));
+          if (next && typeof next === 'object') {
+            viewRef.current = {
+              ...next,
+              ns: typeof next.ns === 'string' && next.ns !== '' ? next.ns : view.ns,
+            };
+          }
+          // 服务端覆盖已清空：**凭据草稿一并丢掉**。留着它在草稿里，会立刻又算出一项
+          // 「有 1 项改动未保存」，而那一项其实属于刚被重置掉的旧配置（授权码本身不受重置影响）。
+          setPwDraft({});
+          setPwClear({});
+          setPwEdit({});
           await load();
           setSave({ phase: 'saved', at: Date.now(), error: '' });
         } catch (err) {
+          // 失败不重读：重读会把用户还没保存的草稿冲掉。
           setSave({ phase: 'error', at: 0, error: String(err?.message ?? err) });
-          await load();
         } finally {
           setResetting(false);
           setConfirmReset(false);
         }
       }, [remotes, load]);
 
-      /** 发一封测试邮件。Host 没提供该能力时不显示按钮。 */
+      /**
+       * 发一封测试邮件。
+       *
+       * 结果是 RPC **当场**返回的：成败与原始报错直接进 test 态，
+       * 因为账本删掉之后，这条路径就是唯一的「真投递过没有」的证据。
+       */
       const sendTest = React.useCallback(async () => {
-        if (capability !== 'ready') return;
-        setTest({ phase: 'sending', transport: '', ms: 0, error: '' });
+        if (typeof remotes.current?.rpc?.call !== 'function') return;
+        setTest({ phase: 'sending', ms: 0, error: '' });
         try {
           const result = unwrap(await callRemote('test'));
           if (result && result.ok === false) {
-            setTest({ phase: 'fail', transport: String(result.transport ?? ''), ms: 0, error: String(result.error ?? '') });
+            setTest({ phase: 'fail', ms: 0, error: String(result.error ?? '') });
           } else {
             setTest({
               phase: 'ok',
-              transport: String(result?.transport ?? ''),
               ms: Number(result?.ms ?? 0),
               error: '',
             });
           }
-          setLastDelivery(result ?? null);
         } catch (err) {
-          setTest({ phase: 'fail', transport: '', ms: 0, error: String(err?.message ?? err) });
+          setTest({ phase: 'fail', ms: 0, error: String(err?.message ?? err) });
         }
-      }, [remotes, capability]);
-
-      // 离开页面时把还在防抖里的改动落盘，避免"改完就走"丢改动
-      React.useEffect(() => () => {
-        for (const [key, timer] of Object.entries(timers.current)) {
-          clearTimeout(timer);
-          void commit([key]);
-        }
-      }, [commit]);
+      }, [remotes]);
 
       // ---- 派生值 ----
       const recipients = parseRecipients(draft.recipients);
+      // 凭据行的写入目标由**草稿**给出（硬约束 4：写入目标跟着这一行走）。
       const smtpPasswordRef = String(draft.smtpPasswordRef ?? '').trim();
       const configured = (ref) => ref !== '' && credentialState[ref] === true;
+      // 判决条一律按**已保存的配置**（baseline）判定。
+      // 拿草稿下结论会当场骗人：草稿填齐就报「可以发信了」，而「发送测试邮件」用的正是已保存
+      // 配置，用户一点就失败——先被夸一句、再被打一巴掌，比什么都不说更糟。
+      const savedRecipients = parseRecipients(baseline.recipients);
+      const savedPasswordRef = String(baseline.smtpPasswordRef ?? '').trim();
       const statusKey = deriveStatus({
-        enabled: draft.enabled === true,
-        recipientCount: recipients.valid.length,
-        host: draft.smtpHost,
-        user: draft.smtpUser,
-        credentialConfigured: configured(smtpPasswordRef),
-        lastDelivery,
+        enabled: baseline.enabled === true,
+        recipientCount: savedRecipients.valid.length,
+        host: baseline.smtpHost,
+        user: baseline.smtpUser,
+        credentialConfigured: configured(savedPasswordRef),
       });
-      /** SMTP 这一段自己配好了没有——凭据行在下面很远，段头这一格是它唯一的上层读数。 */
-      const transportReady = configured(smtpPasswordRef)
-        && String(draft.smtpHost ?? '').trim() !== ''
-        && String(draft.smtpUser ?? '').trim() !== '';
+      /** SMTP 这一段自己配好了没有——凭据行在下面很远，段头这一格是它唯一的上层读数（同样按已保存值）。 */
+      const transportReady = configured(savedPasswordRef)
+        && String(baseline.smtpHost ?? '').trim() !== ''
+        && String(baseline.smtpUser ?? '').trim() !== '';
       const transportState = t(transportReady ? 'transportState.done' : 'transportState.todo');
       const STATUS_TITLE_KEY = {
         disabled: 'status.disabled',
@@ -6473,7 +6402,6 @@ window.__ModuleLoader__.load({
         needUser: 'status.needUser',
         needCredential: 'status.needCredential',
         ready: 'status.ready',
-        lastFailed: 'status.lastFailed',
       };
       /** 判决句：**全页最大的字号**，也是这一页真正要回答的那句话。 */
       const statusTitle = statusKey === 'needCredential'
@@ -6485,32 +6413,105 @@ window.__ModuleLoader__.load({
         'notifyAbortedByUser', 'notifyInterrupted', 'notifyMaxTokens']
         .filter((key) => draft[key] === true).length;
       const preset = matchPreset(draft.smtpHost);
-      const testSupported = capability === 'ready';
+      /** 远程桥接有没有接上；没接上时这一页连草稿都读不到，先不给人按钮。 */
+      const bridgeReady = remotes.current !== null;
+      /** 能不能真发一封：只看 connection 有没有把 RPC 接进来（不再探 Host 端点）。 */
+      const rpcReady = typeof remotes.current?.rpc?.call === 'function';
       const sending = test.phase === 'sending';
       /** 判决条那一档：状态→色调的映射只此一份。 */
       const tone = STATUS_TONE[statusKey] ?? 'idle';
 
+      // ---- 草稿 vs 基线：保存按钮的可用状态与整条读数都由这份差异决定 ----
+      /** 与基线不同的配置字段（保存时合成一条 mutate 的 ops）。 */
+      const pendingOps = diffOps(draft, baseline);
+      /** 还挂在草稿里的凭据引用名（授权码也算一项改动）。 */
+      const pendingCredRefs = pendingCredentialRefs();
+      /** 未保存的改动数：N 个配置字段 + 至多一条授权码。 */
+      const dirtyCount = pendingOps.length + pendingCredRefs.length;
+      /** 读数那一档的色调。半成功也算异常：那种状态绝不能长成「一切正常」的样子。 */
+      const saveTone = save.phase === 'error' || save.phase === 'unserved' || save.phase === 'loadFailed'
+        || save.phase === 'partialCred' || save.phase === 'partialConfig'
+        ? 'error'
+        : (save.phase === 'saving' ? 'busy' : (dirtyCount > 0 ? 'dirty' : 'idle'));
       /**
-       * 最近一次投递。没有就返回 null（此时只说"还没试过"，不摆一行空的）。
-       *
-       * 它同时是页面的第一条排错线索：分类（认证被拒 / 发件人被拒 / 网络）给出"该动哪里"，
-       * 原始报错原样附在后面——不改写才是真的可排错。
+       * 保存读数。只说这一刻的事实：干净 / 脏 / 保存中 / 已保存多久 / 失败原因 + 重试，
+       * 以及三种非干净结局各自的动作——读失败给「重新读取」、冲突给「再点一次保存」、
+       * 半成功只给失败那一半的重试。动作永远指向**这一次真正该做的事**，不是笼统的「重试」。
+       * @returns {object[]} 读数节点
        */
-      const deliveryView = lastDelivery === null ? null : (() => {
-        const error = classifySendError(lastDelivery.error);
-        return {
-          ok: lastDelivery.ok === true,
-          ago: relativeTime(lastDelivery.at, now),
-          elapsed: Number(lastDelivery.ms ?? 0),
-          raw: String(lastDelivery.error ?? ''),
-          error,
+      const saveReadout = () => {
+        if (save.phase === 'unserved') return [t('status.notServed')];
+        if (save.phase === 'loadFailed') {
+          // 读失败不是「保存失败」：这里一个字都不许写回，只重读。
+          return [
+            t('save.loadFailed', { error: save.error }),
+            h('button', {
+              type: 'button',
+              className: 'dshmn-link',
+              onClick: () => void load(),
+            }, t('save.reload')),
+          ];
+        }
+        if (save.phase === 'conflictReloaded') return [t('save.conflictReloaded')];
+        if (save.phase === 'partialCred') {
+          // 配置写进去了、授权码没写进去：只给授权码那一半的重试。
+          return [
+            t('save.credFailed', { error: save.error }),
+            h('button', {
+              type: 'button',
+              className: 'dshmn-link',
+              onClick: () => void retryCredentials(),
+            }, t('save.retryCred')),
+          ];
+        }
+        if (save.phase === 'partialConfig') {
+          // 授权码写进去了、配置没写进去：只给配置那一半的重试。
+          return [
+            t('save.configFailed', { error: save.error }),
+            h('button', {
+              type: 'button',
+              className: 'dshmn-link',
+              onClick: () => void retryConfig(),
+            }, t('save.retryConfig')),
+          ];
+        }
+        if (save.phase === 'error') {
+          return [
+            t('save.error', { error: save.error }),
+            String(save.credError ?? '') === '' ? null : t('save.credAlsoFailed', { error: save.credError }),
+            h('button', {
+              type: 'button',
+              className: 'dshmn-link',
+              onClick: () => void saveAll(),
+            }, t('save.retry')),
+          ].filter((node) => node !== null);
+        }
+        if (save.phase === 'saving') return [t('save.saving')];
+        if (dirtyCount > 0) return [t('save.dirty', { n: dirtyCount })];
+        if (save.phase === 'saved' && save.at > 0) {
+          const seconds = Math.max(0, Math.round((now - save.at) / 1000));
+          return [seconds === 0 ? t('save.savedJust') : t('save.savedAgo', { n: seconds })];
+        }
+        return [t('save.clean')];
+      };
+
+      // 有未保存改动时，关闭 / 离开页面要拦一下；没有改动就完全静默（日常切页不该被打断）。
+      React.useEffect(() => {
+        if (typeof window === 'undefined' || typeof window.addEventListener !== 'function') return undefined;
+        if (dirtyCount === 0) return undefined;
+        const guard = (event) => {
+          event.preventDefault();
+          event.returnValue = t('save.dirty', { n: dirtyCount });
+          return event.returnValue;
         };
-      })();
+        window.addEventListener('beforeunload', guard);
+        return () => window.removeEventListener('beforeunload', guard);
+      }, [dirtyCount]);
 
-      /** 测试按钮文案：发的时候说在发；之前失败过就说重测。 */
+      /** 测试按钮文案：发的时候说在发；刚才那次没成功就说重测。 */
       const testLabel = sending
         ? t('act.testing')
-        : (test.phase === 'fail' || (lastDelivery !== null && lastDelivery.ok === false) ? t('act.retest') : t('act.test'));
+        : (test.phase === 'fail' ? t('act.retest') : t('act.test'));
 
       /**
        * 「发送测试邮件」——本页唯一的主行动。
@@ -6522,10 +6523,10 @@ window.__ModuleLoader__.load({
        * @returns {object|null} React 元素
        */
       const testButton = (options) => {
-        if (capability === 'unknown') return null;
-        if (!testSupported) return h('span', { className: 'dshmn-hint' }, t('act.needsRestart'));
-        // 凭据行里用文字链接：手刚离开输入框，验证就在原地，不用滚回页顶；
-        // 但它不抢判决条的主按钮，所以只做链接。
+        if (!bridgeReady) return null;
+        if (!rpcReady) return h('span', { className: 'dshmn-hint' }, t('act.needsRestart'));
+        // 凭据行那处用文字链接：手刚离开授权码输入框，验证就在原地，不必滚回页首。
+        // 它和判决条是同一个动作，但主次分明——判决条是主按钮，这里是弱入口。
         if (options?.variant === 'link') {
           return h('button', {
             type: 'button',
@@ -6546,68 +6547,78 @@ window.__ModuleLoader__.load({
       };
 
       /**
-       * 判决条的动作 = **下一步该做的那一件事**（主按钮）+ 可选的一次验证。
+       * 判决条的动作区：**全页唯一主行动**是「发送测试邮件」，实心主按钮落在右下角。
        *
-       * 还没配完时主按钮是"去填写"（把光标送到缺的那一格），配好了才是发测试邮件；
-       * 验证按钮任何时候都在，因为"还差什么"恰恰要靠它一次点击问出来。
+       * 它不挑状态：配置只填了一半时，"怎么验证"恰恰最需要出现（一次点击就把缺什么问出来）。
+       * 没配完时左边再给一个次级按钮「启用 / 去填写」——它是下一步，但不跟主行动抢主次：
+       * 已关闭时是「启用」，缺字段时是「去填写」（把光标送到缺的那一格）。
+       * @returns {object[]} [次要的下一步, 实心主按钮]，主按钮永远在最后（右下角）
        */
-      const configAction = (() => {
-        if (statusKey === 'disabled') {
-          return h(Button, {
-            variant: 'primary',
-            size: 'sm',
-            onClick: () => setField('enabled', true, { immediate: true }),
-          }, t('act.enable'));
-        }
-        if (statusKey === 'ready' || statusKey === 'lastFailed') return testButton({ variant: 'primary' });
-        return h(Button, {
-          variant: 'primary',
-          size: 'sm',
-          onClick: () => focusMissing(),
-        }, t('act.goFill'));
-      })();
-      /** 还没配完时，测试仍然给，但降为次级：它是验证，不是下一步。 */
-      const secondaryTest = (statusKey === 'ready' || statusKey === 'lastFailed') ? null : testButton();
+      const verdictActions = () => {
+        const nextStep = statusKey === 'ready'
+          ? null
+          : (statusKey === 'disabled'
+            ? h(Button, {
+              variant: 'outline',
+              size: 'sm',
+              onClick: () => setField('enabled', true),
+            }, t('act.enable'))
+            : h(Button, {
+              variant: 'outline',
+              size: 'sm',
+              onClick: () => focusMissing(),
+            }, t('act.goFill')));
+        return [nextStep, testButton({ variant: 'primary' })];
+      };
+
+      /** 把光标送到某一格（元素不在就什么也不做）。 */
+      const focusField = (id) => {
+        const element = typeof document === 'undefined' || typeof document.getElementById !== 'function'
+          ? null
+          : document.getElementById(id);
+        if (element === null || element === undefined) return;
+        if (typeof element.scrollIntoView === 'function') element.scrollIntoView({ block: 'center' });
+        if (typeof element.focus === 'function') element.focus();
+      };
 
       /** 把用户送到缺的那一格，而不是让他自己在一屏里找。 */
       const focusMissing = () => {
-        const target = statusKey === 'needRecipients' ? 'dshmn-recipients'
+        focusField(statusKey === 'needRecipients' ? 'dshmn-recipients'
           : (statusKey === 'needHost' ? 'dshmn-smtp-host'
-            : (statusKey === 'needUser' ? 'dshmn-smtp-user' : 'dshmn-cred-smtp'));
-        const element = typeof document === 'undefined' ? null : document.getElementById(target);
-        if (element === null || element === undefined) return;
-        element.scrollIntoView({ block: 'center' });
-        element.focus();
+            : (statusKey === 'needUser' ? 'dshmn-smtp-user' : 'dshmn-cred-smtp')));
       };
 
       /**
-       * 判决条底部那条"读数"。
+       * 「发送测试邮件」这次点击的回执。
        *
-       * 它是这一页唯一能回答"真发得出去吗"的东西，所以放在判决条里、用一条发丝线跟判决分开。
-       * 失败时分类 + 原文都给：只给"发送失败"四个字等于没给线索。
+       * 账本删掉之后，这里是**唯一**能回答「真投递过没有」的地方，所以它必须
+       * 成功给用时、失败给分类 + 原文：只报一句「已发送」等于把人推回日志里。
+       * 状态只活在内存里、刷新页面即消失——它报的是这一次点击，不是历史。
        * @returns {object|null} React 元素
        */
-      const evidence = () => {
-        if (deliveryView === null) {
+      const testResult = () => {
+        if (test.phase === 'sending') {
           return h('div', { className: 'dshmn-evidence' },
-            h('span', { className: 'dshmn-evidenceKey' }, t('evidence.label')),
-            h('span', null, t('evidence.never')));
+            h('span', { className: 'dshmn-evidenceKey' }, t('act.testing')));
         }
-        const view = deliveryView;
-        const detail = view.ok
-          ? [h('span', { key: 'ok' }, t('evidence.ok', { ms: view.elapsed, ago: view.ago }))]
-          : [
-            h('span', { key: 'reason' }, `${t('evidence.fail')}：${view.error.label}（${view.ago}）`),
-            h('span', { key: 'hint', className: 'dshmn-hint' }, view.error.hint),
-            h('span', { key: 'raw', className: 'dshmn-mono' }, view.raw),
-          ];
-        return h('div', { className: 'dshmn-evidence', 'data-ok': view.ok ? 'true' : 'false' },
-          h('span', { className: 'dshmn-evidenceKey' }, t('evidence.label')),
-          ...detail);
+        if (test.phase === 'ok') {
+          return h('div', { className: 'dshmn-evidence', 'data-ok': 'true' },
+            h('span', { className: 'dshmn-evidenceKey' }, t('test.sent')),
+            h('span', null, t('test.sentMs', { ms: Number(test.ms ?? 0) })));
+        }
+        if (test.phase === 'fail') {
+          const reason = classifySendError(test.error);
+          return h('div', { className: 'dshmn-evidence', 'data-ok': 'false' },
+            h('span', { className: 'dshmn-evidenceKey' }, t('test.failed')),
+            h('span', null, reason.label),
+            h('span', { className: 'dshmn-hint' }, reason.hint),
+            h('span', { className: 'dshmn-mono' }, String(test.error ?? '')));
+        }
+        return null;
       };
       /**
        * 凭据行。保存前给输入框（这里才是要动手的地方）；保存后**不再摆一个空输入框**——
-       * 那样只会让人怀疑"是不是没存上"。存好之后是：✓ 已保存 + 测试 + 更换 + 清除。
+       * 那样只会让人怀疑"是不是没存上"。存好之后是：✓ 已保存 + 更换 + 清除（测试入口全页只在判决条一处）。
        * @param {string} fieldId 输入框 id
        * @param {string} labelKey 名称文案键
        * @param {string} ref 凭据引用名（写入目标由调用方给定，硬约束 4）
@@ -6617,16 +6628,21 @@ window.__ModuleLoader__.load({
        */
       const credentialField = (fieldId, labelKey, ref, hintKey, helpKey) => {
         const confirmed = configured(ref);
-        const clear = pwClear[ref] === true;
-        const editing = confirmed !== true || clear;
+        // 「更换」只是把输入框展开，不算一项改动；真正待清理的是 pwClear。
+        const editing = confirmed !== true || pwEdit[ref] === true;
+        // 「怎么拿授权码？」从行内链接收成标题旁的问号：和 8 个事件开关同一套交互，
+        // 省一行宽度，把位置让给真正的动作（更换 / 清除 / 发送测试邮件）。
         const helpButton = h('button', {
           type: 'button',
-          className: 'dshmn-link',
+          className: 'dshmn-q',
+          'aria-label': t(helpKey),
           onClick: () => setHelpKind(true),
-        }, t(helpKey));
+        }, '?');
         return h('div', { className: 'dshmn-item' },
           h('div', { className: 'dshmn-itemHead' },
-            h('label', { className: 'dshmn-label', htmlFor: fieldId }, t(labelKey)),
+            h('span', { className: 'dshmn-labelRow' },
+              h('label', { className: 'dshmn-label', htmlFor: fieldId }, t(labelKey)),
+              helpButton),
             h('span', { className: 'dshmn-credState', 'data-ok': confirmed ? 'true' : 'false' },
               confirmed ? h('span', { 'aria-hidden': 'true' }, h(CheckedMark, null)) : null,
               confirmed ? t('cred.saved') : t('cred.notSaved'))),
@@ -6641,8 +6657,6 @@ window.__ModuleLoader__.load({
                 setPwDraft((prev) => ({ ...prev, [ref]: value }));
                 setPwClear((prev) => ({ ...prev, [ref]: false }));
               },
-              onBlur: () => void commitCredential(ref),
-              onKeyDown: (event) => { if (event.key === 'Enter') void commitCredential(ref); },
             })
             : h('div', null,
               h(TextInput, {
@@ -6652,7 +6666,7 @@ window.__ModuleLoader__.load({
                 readOnly: true,
                 'aria-label': `${t(labelKey)}：${t('cred.saved')}`,
                 placeholder: t('cred.saved'),
-                onFocus: () => setPwClear((prev) => ({ ...prev, [ref]: true })),
+                onFocus: () => setPwEdit((prev) => ({ ...prev, [ref]: true })),
               })),
           h('div', { className: 'dshmn-hint' }, t(hintKey)),
           save.phase === 'saving' ? h('div', { className: 'dshmn-hint' }, t('save.checkingCred')) : null,
@@ -6669,7 +6683,7 @@ window.__ModuleLoader__.load({
               ? h('button', {
                 type: 'button',
                 className: 'dshmn-link',
-                onClick: () => setPwClear((prev) => ({ ...prev, [ref]: true })),
+                onClick: () => setPwEdit((prev) => ({ ...prev, [ref]: true })),
               }, t('cred.replace'))
               : null,
             confirmed
@@ -6679,40 +6693,97 @@ window.__ModuleLoader__.load({
                 onClick: () => {
                   setPwDraft((prev) => ({ ...prev, [ref]: '' }));
                   setPwClear((prev) => ({ ...prev, [ref]: true }));
-                  void commitCredential(ref);
                 },
               }, t('cred.clear'))
               : null,
-            helpButton,
             testButton({ variant: 'link' })));
       };
 
-      /** 分组头右侧那一格：只说这一段的结论，不摆装饰。 */
+      /**
+       * 一个事件开关的紧凑行：标题 + 问号 + 开关。
+       *
+       * 说明不再常显（8 行说明会把这一组撑成一屏），收进问号后面：**点击**开合而不是 hover，
+       * 触屏点得到；原生 button + aria-expanded / aria-controls，键盘 tab 得到。
+       * 说明文案仍然来自原来那对键（outcomes.*Hint），一个字都没重写。
+       * @param {string} field 配置字段名
+       * @param {string} titleKey 标题文案键
+       * @param {string} hintKey 说明文案键
+       * @returns {object} React 元素
+       */
+      const outcomeRow = (field, titleKey, hintKey) => {
+        const open = openHints[field] === true;
+        const noteId = `dshmn-note-${field}`;
+        return h('div', { className: 'dshmn-row', key: field },
+          h('div', { className: 'dshmn-rowHead' },
+            h('div', { className: 'dshmn-rowTitle' },
+              h('span', { className: 'dshmn-rowName' }, t(titleKey)),
+              h('button', {
+                type: 'button',
+                className: 'dshmn-q',
+                'aria-label': t(open ? 'hint.hide' : 'hint.show', { title: t(titleKey) }),
+                'aria-expanded': open ? 'true' : 'false',
+                'aria-controls': noteId,
+                onClick: () => setOpenHints((prev) => ({ ...prev, [field]: prev[field] !== true })),
+              }, '?')),
+            h('div', { className: 'dshmn-rowCtrl' }, h(Switch, {
+              checked: draft[field] === true,
+              label: t(titleKey),
+              onChange: (next) => setField(field, next),
+            }))),
+          open ? h('p', { className: 'dshmn-rowNote', id: noteId }, t(hintKey)) : null);
+      };
+
+      /**
+       * 「更多」标题上的当前值。
+       *
+       * 端口 / 加密收进折叠区，但"现在到底用什么"必须一眼看得到：只要这一对值偏离宿主
+       * 默认（465 · auto，见 lib/notify/config.js），就把它们摆到标题上。
+       */
+      const draftPort = draft.smtpPort === undefined || draft.smtpPort === null ? '' : String(draft.smtpPort);
+      const draftSecure = String(draft.smtpSecure ?? '');
+      const transportTweaked = (draftPort !== '' && Number(draftPort) !== DEFAULT_TRANSPORT.port)
+        || (draftSecure !== '' && draftSecure !== DEFAULT_TRANSPORT.secure);
+      const transportValue = [draftPort, draftSecure].filter((part) => part !== '').join(' · ');
+      const moreTitle = transportTweaked && transportValue !== ''
+        ? t('transport.moreWith', { value: transportValue })
+        : t('transport.more');
+
+      /** 收件人那一组的读数：只说个数，落在段头的小字里（不再占一行正文）。 */
       const recipientsState = recipients.valid.length > 0
         ? t('recipients.ok', { n: recipients.valid.length })
         : t('recipients.none');
 
       return h('div', { className: 'dshmn-page', 'data-build': BUILD },
 
-        // ---- 页头：这一页干什么 + 落盘读数（读数常驻，不自灭）----
-        h('div', { className: 'dshmn-head' },
-          h('p', { className: 'dshmn-lead' }, t('lead')),
-          h('div', {
-            className: 'dshmn-stamp',
-            'data-tone': save.phase === 'error' ? 'error' : (save.phase === 'saving' ? 'busy' : 'idle'),
-            'aria-live': 'polite',
-          },
-          save.phase === 'error'
-            ? h(React.Fragment, null,
-              t('save.error', { error: save.error }),
-              h('button', { type: 'button', className: 'dshmn-link', onClick: () => void load() }, t('save.reload')))
-            : (save.phase === 'saving'
-              ? t('save.saving')
-              : (save.phase === 'saved' && save.at > 0
-                ? t('save.savedAgo', { n: Math.max(0, Math.round((now - save.at) / 1000)) })
-                : t('save.auto'))))),
-
-        // ---- 判决条：全页唯一的填充面 ----
+        // ---- 页头：标题独占一行（18/600），右上只有动作组 ----
+        // 「脏读数 + 保存 + 放弃改动」是一个动作区：不画线、不放说明、不占第二层高度。
+        // 宿主的设置面板头（h54）只放 actions + close，所以内容区第一行就该是标题。
+        h('header', { className: 'dshmn-head' },
+          h('div', { className: 'dshmn-headText' },
+            h('h2', { className: 'dshmn-title' }, t('nav')),
+            h('p', { className: 'dshmn-lead' }, t('lead'))),
+          h('div', { className: 'dshmn-headActions' },
+            h('div', {
+              className: 'dshmn-stamp',
+              'data-tone': saveTone,
+              'aria-live': 'polite',
+            }, ...saveReadout()),
+            h(Button, {
+              variant: 'primary',
+              size: 'sm',
+              // 没有改动就禁用：主按钮不该在无事可做时还亮着。
+              disabled: dirtyCount === 0 || !bridgeReady || save.phase === 'saving',
+              title: t('act.saveHint'),
+              onClick: () => void saveAll(),
+            }, t('act.save')),
+            h(Button, {
+              variant: 'outline',
+              size: 'sm',
+              disabled: dirtyCount === 0 || !bridgeReady || save.phase === 'saving',
+              onClick: () => discardAll(),
+            }, t('act.discard')))),
+
+        // ---- 判决条：全页唯一的填充面（状态色 hero）；结论句 + 右下角那处主行动 ----
         h('section', {
           className: 'dshmn-verdict',
           'data-tone': tone,
@@ -6723,11 +6794,13 @@ window.__ModuleLoader__.load({
           h(Dot, { state: tone === 'done' ? 'done' : (tone === 'error' ? 'error' : (tone === 'warning' ? 'warning' : 'idle')) }),
           h('h2', { className: 'dshmn-verdictTitle' }, statusTitle)),
         h('p', { className: 'dshmn-verdictWhy' }, statusWhy),
-        evidence(),
-        h('div', { className: 'dshmn-verdictFoot' }, secondaryTest, configAction)),
+        // 口径明写：这句判决算的是**已保存的配置**，屏幕上没保存的改动不算数。
+        dirtyCount > 0 ? h('p', { className: 'dshmn-hint' }, t('status.unsavedDraft')) : null,
+        testResult(),
+        h('div', { className: 'dshmn-verdictFoot' }, ...verdictActions())),
 
-        // ---- 收件人 ----
-        h(Group, { title: t('group.recipients'), state: recipientsState },
+        // ---- 卡片一：收件人 ----
+        h(Card, { kind: 'recipients', title: t('group.recipients'), state: recipientsState },
         h('div', { className: 'dshmn-item' },
         h('div', { className: 'dshmn-field' },
           h('label', { className: 'dshmn-label', htmlFor: 'dshmn-recipients' }, t('recipients.label')),
@@ -6738,41 +6811,40 @@ window.__ModuleLoader__.load({
             placeholder: t('recipients.placeholder'),
             'aria-invalid': recipients.invalid.length > 0 ? 'true' : 'false',
             onChange: (event) => setField('recipients', event.target.value),
-            onBlur: () => flush('recipients'),
           }),
           h('div', { className: 'dshmn-hint' }, t('recipients.hint')),
           recipients.invalid.length > 0
             ? h('div', { className: 'dshmn-error', role: 'alert' }, t('recipients.invalid', { list: recipients.invalid.join('、') }))
             : null))),
 
-        // ---- 怎么发（只剩 SMTP 一种发送方式，不再让人选通道）----
-        h(Group, { title: t('group.transport'), state: transportState },
+        // ---- 卡片二：怎么发（只剩 SMTP 一种发送方式，不再让人选通道）----
+        h(Card, { kind: 'transport', title: t('group.transport'), state: transportState },
         h('div', { className: 'dshmn-item' },
           h('div', { className: 'dshmn-hint' }, t('smtp.note')),
-          h('div', { className: 'dshmn-sub' },
 
-          h('div', { className: 'dshmn-field' },
-            h('div', { className: 'dshmn-label' }, t('preset.label')),
-            h('div', { className: 'dshmn-seg', role: 'radiogroup', 'aria-label': t('preset.label') },
-              ...PRESETS.map((item) => h(Segment, {
-                key: item.id,
-                active: preset !== null && preset.id === item.id,
-                onClick: () => setFields({
-                  smtpHost: item.host,
-                  smtpPort: item.port,
-                  smtpSecure: item.secure,
-                  ...(draft.smtpUser === '' && userForPreset(item, recipients.valid) !== ''
-                    ? { smtpUser: userForPreset(item, recipients.valid) }
-                    : {}),
-                }),
-              }, item.name)),
-              h(Segment, {
-                active: preset === null,
-                onClick: () => setShowAdvanced(true),
-              }, t('preset.other'))),
-            preset === null ? null : h('div', { className: 'dshmn-hint' }, t('preset.detected', { name: preset.name }))),
-
-          h('div', { className: 'dshmn-grid' },
+          // 7 个服务商收成一行横向滚动的 chips：窄屏不折成三排，「其他」永远在最右。
+          h('div', { className: 'dshmn-chips', role: 'radiogroup', 'aria-label': t('preset.label') },
+            ...PRESETS.map((item) => h(Segment, {
+              key: item.id,
+              active: preset !== null && preset.id === item.id,
+              onClick: () => setFields({
+                smtpHost: item.host,
+                smtpPort: item.port,
+                smtpSecure: item.secure,
+                ...(draft.smtpUser === '' && userForPreset(item, recipients.valid) !== ''
+                  ? { smtpUser: userForPreset(item, recipients.valid) }
+                  : {}),
+              }),
+            }, item.name)),
+            h(Segment, {
+              active: preset === null,
+              // 「其他」= 自建中继：光标直接送到主机那一格
+              onClick: () => focusField('dshmn-smtp-host'),
+            }, t('preset.other'))),
+          preset === null ? null : h('div', { className: 'dshmn-hint' }, t('preset.detected', { name: preset.name })),
+
+          // 主行：主机 + 用户名（两列）。端口 / 加密折进下面的「更多」。
+          h('div', { className: 'dshmn-two' },
             h('div', { className: 'dshmn-field' },
               h('label', { className: 'dshmn-label', htmlFor: 'dshmn-smtp-host' }, t('smtp.host')),
               h(TextInput, {
@@ -6781,293 +6853,86 @@ window.__ModuleLoader__.load({
                 value: draft.smtpHost ?? '',
                 placeholder: 'smtp.example.com',
                 onChange: (event) => setField('smtpHost', event.target.value),
-                onBlur: () => flush('smtpHost'),
               })),
             h('div', { className: 'dshmn-field' },
-              h('label', { className: 'dshmn-label', htmlFor: 'dshmn-smtp-port' }, t('smtp.port')),
+              h('label', { className: 'dshmn-label', htmlFor: 'dshmn-smtp-user' }, t('smtp.user')),
               h(TextInput, {
-                id: 'dshmn-smtp-port',
+                id: 'dshmn-smtp-user',
                 type: 'text',
-                inputMode: 'numeric',
-                value: draft.smtpPort ?? '',
-                placeholder: '465',
-                'aria-label': t('smtp.port'),
-                onChange: (event) => setField('smtpPort', event.target.value === '' ? '' : Number(event.target.value), { delay: NUMBER_DEBOUNCE_MS }),
-                onBlur: () => flush('smtpPort'),
-              })),
-            h('div', { className: 'dshmn-field' },
-              h('label', { className: 'dshmn-label', htmlFor: 'dshmn-smtp-secure' }, t('smtp.secure')),
-              h('select', {
-                id: 'dshmn-smtp-secure',
-                className: 'dshmn-select',
-                value: draft.smtpSecure ?? 'auto',
-                onChange: (event) => setField('smtpSecure', event.target.value, { immediate: true }),
-              }, ...[['auto', 'auto'], ['tls', 'tls'], ['starttls', 'starttls'], ['plain', 'plain']]
-                .map(([value, text]) => h('option', { key: value, value }, text))))),
-
+                value: draft.smtpUser ?? '',
+                placeholder: `you${preset?.suffix ?? '@example.com'}`,
+                onChange: (event) => setField('smtpUser', event.target.value),
+              }),
+              accountMismatch(preset, draft.smtpUser)
+                ? h('div', { className: 'dshmn-error', role: 'alert' }, t('smtp.accountMismatch', {
+                  host: String(draft.smtpHost ?? ''),
+                  name: preset?.name ?? '',
+                  user: String(draft.smtpUser ?? ''),
+                  suffix: preset?.suffix ?? '',
+                }))
+                : null)),
+
+          // 端口 / 加密：默认收起。收起时标题上写清当前值（偏离默认才有内容），
+          // 所以"收起来"不等于"藏起来"——想知道现在用什么，看一眼标题就够。
           h('div', { className: 'dshmn-field' },
-            h('label', { className: 'dshmn-label', htmlFor: 'dshmn-smtp-user' }, t('smtp.user')),
-            h(TextInput, {
-              id: 'dshmn-smtp-user',
-              type: 'text',
-              value: draft.smtpUser ?? '',
-              placeholder: `you${preset?.suffix ?? '@example.com'}`,
-              onChange: (event) => setField('smtpUser', event.target.value),
-              onBlur: () => flush('smtpUser'),
-            }),
-            accountMismatch(preset, draft.smtpUser)
-              ? h('div', { className: 'dshmn-error', role: 'alert' }, t('smtp.accountMismatch', {
-                host: String(draft.smtpHost ?? ''),
-                name: preset?.name ?? '',
-                user: String(draft.smtpUser ?? ''),
-                suffix: preset?.suffix ?? '',
-              }))
-              : null),
-
-          credentialField('dshmn-cred-smtp', 'cred.smtp', smtpPasswordRef, 'cred.smtpHint', 'cred.smtpHelp')))),
-
-        // ---- 什么时候发给我 ----
-        h(Group, {
+            foldHead('dshmn-more-transport', moreTitle, moreOpen, () => setMoreOpen((value) => value !== true)),
+            moreOpen !== true
+              ? null
+              : h('div', { className: 'dshmn-foldBody', id: 'dshmn-more-transport' },
+                h('div', { className: 'dshmn-twoPort' },
+                  h('div', { className: 'dshmn-field' },
+                    h('label', { className: 'dshmn-label', htmlFor: 'dshmn-smtp-port' }, t('smtp.port')),
+                    h(TextInput, {
+                      id: 'dshmn-smtp-port',
+                      type: 'text',
+                      inputMode: 'numeric',
+                      value: draft.smtpPort ?? '',
+                      placeholder: '465',
+                      'aria-label': t('smtp.port'),
+                      onChange: (event) => {
+                        const raw = String(event.target.value ?? '');
+                        // 端口只收数字。Number('46a') 是 NaN：宿主会拒写，但报的是英文 SDK 错误，
+                        // 而且 NaN 跟谁都不相等，脏计数会一直挂着不清。非法字符根本别进草稿——
+                        // 受控输入会把框里的内容退回上一次的合法值。
+                        if (raw !== '' && !/^\d+$/.test(raw)) return;
+                        setField('smtpPort', raw === '' ? '' : Number(raw));
+                      },
+                    })),
+                  h('div', { className: 'dshmn-field' },
+                    h('label', { className: 'dshmn-label', htmlFor: 'dshmn-smtp-secure' }, t('smtp.secure')),
+                    h('select', {
+                      id: 'dshmn-smtp-secure',
+                      className: 'dshmn-select',
+                      value: draft.smtpSecure ?? 'auto',
+                      onChange: (event) => setField('smtpSecure', event.target.value),
+                    }, ...[['auto', 'auto'], ['tls', 'tls'], ['starttls', 'starttls'], ['plain', 'plain']]
+                      .map(([value, text]) => h('option', { key: value, value }, text)))))))),
+        credentialField('dshmn-cred-smtp', 'cred.smtp', smtpPasswordRef, 'cred.smtpHint', 'cred.smtpHelp')),
+
+        // ---- 卡片三：什么时候发给我（8 个开关单列，宿主同款行；窄屏最稳）----
+        // 说明不再常显：每行标题旁一个问号，点开才显示那一行的说明（文案键原样复用）。
+        h(Card, {
+          kind: 'outcomes',
           title: t('group.outcomes'),
           state: outcomesOn > 0 ? t('outcomes.countOn', { n: outcomesOn }) : t('outcomes.countOff'),
         },
-        // 时长下限是"任务完成"的子项（只对它生效），所以缩进成子行——因果关系看得见，
-        // 而不是隔着十行再补一句"只对完成生效"。
+        outcomeRow('notifyCompleted', 'outcomes.completed', 'outcomes.completedHint'),
+        outcomeRow('notifyError', 'outcomes.error', 'outcomes.errorHint'),
+        outcomeRow('notifyBlocked', 'outcomes.blocked', 'outcomes.blockedHint'),
+        outcomeRow('notifyApproval', 'outcomes.approval', 'outcomes.approvalHint'),
+        outcomeRow('includeSubagents', 'outcomes.subagents', 'outcomes.subagentsHint'),
         h('div', { className: 'dshmn-item' },
-          h('div', { className: 'dshmn-itemHead' },
-            h('div', { className: 'dshmn-itemText' },
-              h('div', { className: 'dshmn-itemTitle' }, t('outcomes.completed')),
-              h('div', { className: 'dshmn-hint' }, t('outcomes.completedHint'))),
-            h('div', { className: 'dshmn-itemCtrl' },
-              h(Switch, {
-                checked: draft.notifyCompleted === true,
-                label: t('outcomes.completed'),
-                onChange: (next) => setField('notifyCompleted', next, { immediate: true }),
-              }))),
-          h('div', { className: 'dshmn-sub', 'data-muted': draft.notifyCompleted === true ? 'false' : 'true' },
-            h('div', { className: 'dshmn-itemHead' },
-              h('div', { className: 'dshmn-itemText' },
-                h('label', { className: 'dshmn-itemTitle', htmlFor: 'dshmn-minduration' }, t('outcomes.minDuration')),
-                h('div', { className: 'dshmn-hint' }, t('outcomes.minDurationHint'))),
-              h('div', { className: 'dshmn-itemCtrl' },
-                h(NumberField, {
-                  id: 'dshmn-minduration',
-                  value: draft.minDurationMs,
-                  placeholder: '2000',
-                  unit: t('unit.ms'),
-                  label: t('outcomes.minDuration'),
-                  onChange: (value) => setField('minDurationMs', value, { delay: NUMBER_DEBOUNCE_MS }),
-                  onBlur: () => flush('minDurationMs'),
-                }))))),
-        h(Row, {
-          title: t('outcomes.error'),
-          hint: t('outcomes.errorHint'),
-          control: h(Switch, {
-            checked: draft.notifyError === true,
-            label: t('outcomes.error'),
-            onChange: (next) => setField('notifyError', next, { immediate: true }),
-          }),
-        }),
-        h(Row, {
-          title: t('outcomes.blocked'),
-          hint: t('outcomes.blockedHint'),
-          control: h(Switch, {
-            checked: draft.notifyBlocked === true,
-            label: t('outcomes.blocked'),
-            onChange: (next) => setField('notifyBlocked', next, { immediate: true }),
-          }),
-        }),
-        h(Row, {
-          title: t('outcomes.approval'),
-          hint: t('outcomes.approvalHint'),
-          control: h(Switch, {
-            checked: draft.notifyApproval === true,
-            label: t('outcomes.approval'),
-            onChange: (next) => setField('notifyApproval', next, { immediate: true }),
-          }),
-        }),
-        h(Row, {
-          title: t('outcomes.subagents'),
-          hint: t('outcomes.subagentsHint'),
-          control: h(Switch, {
-            checked: draft.includeSubagents === true,
-            label: t('outcomes.subagents'),
-            onChange: (next) => setField('includeSubagents', next, { immediate: true }),
-          }),
-        }),
-        h('div', { className: 'dshmn-item' },
-          h(Disclosure, {
-            title: t('outcomes.more'),
-            open: showMoreOutcomes,
-            onToggle: () => setShowMoreOutcomes((value) => !value),
-          },
-          h('div', { className: 'dshmn-stack', 'data-rows': 'true' },
-            h(Row, {
-              title: t('outcomes.aborted'),
-              hint: t('outcomes.abortedHint'),
-              control: h(Switch, {
-                checked: draft.notifyAbortedByUser === true,
-                label: t('outcomes.aborted'),
-                onChange: (next) => setField('notifyAbortedByUser', next, { immediate: true }),
-              }),
-            }),
-            h(Row, {
-              title: t('outcomes.interrupted'),
-              hint: t('outcomes.interruptedHint'),
-              control: h(Switch, {
-                checked: draft.notifyInterrupted === true,
-                label: t('outcomes.interrupted'),
-                onChange: (next) => setField('notifyInterrupted', next, { immediate: true }),
-              }),
-            }),
-            h(Row, {
-              title: t('outcomes.maxTokens'),
-              hint: t('outcomes.maxTokensHint'),
-              control: h(Switch, {
-                checked: draft.notifyMaxTokens === true,
-                label: t('outcomes.maxTokens'),
-                onChange: (next) => setField('notifyMaxTokens', next, { immediate: true }),
-              }),
-            })))),
+          foldHead('dshmn-more-outcomes', t('outcomes.more'), showMoreOutcomes,
+            () => setShowMoreOutcomes((value) => value !== true)),
+          showMoreOutcomes !== true
+            ? null
+            : h('div', { className: 'dshmn-foldBody', id: 'dshmn-more-outcomes' },
+              outcomeRow('notifyAbortedByUser', 'outcomes.aborted', 'outcomes.abortedHint'),
+              outcomeRow('notifyInterrupted', 'outcomes.interrupted', 'outcomes.interruptedHint'),
+              outcomeRow('notifyMaxTokens', 'outcomes.maxTokens', 'outcomes.maxTokensHint')))),
 
-        // ---- 可选设置（发件人、链接、排错）----
-        h('section', { className: 'dshmn-group', 'aria-label': t('group.optional') },
-          h('div', { className: 'dshmn-groupHead' },
-            h('h3', { className: 'dshmn-groupTitle' }, t('group.optional'))),
-          h('div', { className: 'dshmn-groupBody' },
-        h('div', { className: 'dshmn-item' },
-        h(Disclosure, {
-          title: t('group.sender'),
-          open: showSender,
-          onToggle: () => setShowSender((value) => !value),
-        },
-        h('div', { className: 'dshmn-stack' },
-          h('div', { className: 'dshmn-field' },
-            h('label', { className: 'dshmn-label' }, t('sender.listLabel')),
-            h('div', { className: 'dshmn-senders', role: 'radiogroup', 'aria-label': t('sender.listLabel') },
-              senders.length === 0
-                ? h('div', { className: 'dshmn-senderEmpty' }, t('sender.empty'))
-                : null,
-              ...senders.map((entry, index) => {
-                const isActive = entry.address === senderAddr;
-                return h('div', {
-                  key: entry.address,
-                  className: 'dshmn-sender',
-                  'data-active': isActive ? 'true' : 'false',
-                  onClick: () => pickSender(entry.address),
-                },
-                h('input', {
-                  type: 'radio',
-                  className: 'dshmn-senderRadio',
-                  name: 'dshmn-sender',
-                  checked: isActive,
-                  onChange: () => pickSender(entry.address),
-                  'aria-label': t('sender.useThis', { address: entry.address }),
-                }),
-                h('div', { className: 'dshmn-senderBody' },
-                  h('div', { className: 'dshmn-senderName' }, entry.name !== '' ? entry.name : t('sender.nameUnset')),
-                  h('div', { className: 'dshmn-senderAddr' }, entry.address)),
-                isActive ? h('span', { className: 'dshmn-senderBadge' }, t('sender.inUse')) : null,
-                h('button', {
-                  type: 'button',
-                  className: 'dshmn-senderIcon',
-                  title: t('sender.edit'),
-                  'aria-label': `${t('sender.edit')} ${entry.address}`,
-                  onClick: (event) => { event.stopPropagation(); openSenderDialog(index); },
-                }, '✎'),
-                h('button', {
-                  type: 'button',
-                  className: 'dshmn-senderIcon',
-                  title: t('sender.remove'),
-                  'aria-label': `${t('sender.remove')} ${entry.address}`,
-                  onClick: (event) => { event.stopPropagation(); removeSender(index); },
-                }, '×'));
-              }),
-              h('button', {
-                type: 'button',
-                className: 'dshmn-senderAdd',
-                onClick: () => openSenderDialog(senders.length),
-              }, t('sender.add'))),
-            h('div', { className: 'dshmn-hint' }, t('sender.listHint'))),
-          h(Row, {
-            title: t('link.enabled'),
-            hint: t('link.enabledHint'),
-            control: h(Switch, {
-              checked: draft.linkEnabled === true,
-              label: t('link.enabled'),
-              onChange: (next) => setField('linkEnabled', next, { immediate: true }),
-            }),
-          }),
-          h('div', { className: 'dshmn-field' },
-            h('label', { className: 'dshmn-label', htmlFor: 'dshmn-base' }, t('link.base')),
-            h(TextInput, {
-              id: 'dshmn-base',
-              type: 'text',
-              value: draft.publicBaseUrl ?? '',
-              placeholder: 'http://127.0.0.1:3081',
-              onChange: (event) => setField('publicBaseUrl', event.target.value),
-              onBlur: () => flush('publicBaseUrl'),
-            }),
-            h('div', { className: 'dshmn-hint' }, t('link.baseHint')))))),
-
-        // ---- 可选：高级（排错用）----
-        h('div', { className: 'dshmn-item' },
-        h(Disclosure, {
-          title: t('group.advanced'),
-          open: showAdvanced,
-          onToggle: () => setShowAdvanced((value) => !value),
-        },
-        h('div', { className: 'dshmn-stack' },
-          h('div', { className: 'dshmn-field' },
-            h('label', { className: 'dshmn-label', htmlFor: 'dshmn-settle' }, t('adv.settle')),
-            h(NumberField, {
-              id: 'dshmn-settle',
-              value: draft.settleMs,
-              placeholder: '1500',
-              unit: t('unit.ms'),
-              label: t('adv.settle'),
-              onChange: (value) => setField('settleMs', value, { delay: NUMBER_DEBOUNCE_MS }),
-              onBlur: () => flush('settleMs'),
-            }),
-            h('div', { className: 'dshmn-hint' }, t('adv.settleHint'))),
-          h('div', { className: 'dshmn-field' },
-            h('label', { className: 'dshmn-label', htmlFor: 'dshmn-rate' }, t('adv.rate')),
-            h(NumberField, {
-              id: 'dshmn-rate',
-              value: draft.ratePerMinute,
-              placeholder: '10',
-              unit: t('unit.perMin'),
-              label: t('adv.rate'),
-              onChange: (value) => setField('ratePerMinute', value, { delay: NUMBER_DEBOUNCE_MS }),
-              onBlur: () => flush('ratePerMinute'),
-            }),
-            h('div', { className: 'dshmn-hint' }, t('adv.rateHint'))),
-          h('div', { className: 'dshmn-field' },
-            h('label', { className: 'dshmn-label', htmlFor: 'dshmn-pwref' }, t('adv.pwRef')),
-            h(TextInput, {
-              id: 'dshmn-pwref',
-              type: 'text',
-              value: draft.smtpPasswordRef ?? '',
-              onChange: (event) => setField('smtpPasswordRef', event.target.value),
-              onBlur: () => {
-                flush('smtpPasswordRef');
-                void refreshCredentials([draftRef.current.smtpPasswordRef]);
-              },
-            }),
-            h('div', { className: 'dshmn-hint' }, t('adv.pwRefHint'))),
-          h('div', { className: 'dshmn-field' },
-            h('label', { className: 'dshmn-label', htmlFor: 'dshmn-statepath' }, t('adv.statePath')),
-            h(TextInput, {
-              id: 'dshmn-statepath',
-              type: 'text',
-              value: draft.statePath ?? '',
-              onChange: (event) => setField('statePath', event.target.value),
-              onBlur: () => flush('statePath'),
-            }),
-            h('div', { className: 'dshmn-hint' }, t('adv.statePathHint')))))),
-          )),
-
-        // ---- 页脚：清空覆盖是破坏性操作，所以压到最下面、只用文字链接 ----
+        // ---- 页脚：清空覆盖是破坏性操作，所以压到最下面、只用一条 12/18 的文字链接 ----
+        // 页脚不画线：线只长在行自己身上，页脚不是一段内容。
         h('div', { className: 'dshmn-foot' },
           h('button', {
             type: 'button',
@@ -7099,40 +6964,7 @@ window.__ModuleLoader__.load({
             closeLabel: t('cred.helpClose'),
             footer: h(Button, { variant: 'outline', size: 'sm', onClick: () => setHelpKind(null) }, t('cred.helpClose')),
           }, h('div', { className: 'dshmn-helpBody' }, t('cred.smtpHelpBody')))
-          : null,
-
-        // ---- 发件人弹层（添加 / 编辑同一套）----
-        // 保存按钮**不置灰**：不合法时点一下就地报错，比灰着一个说不清原因的按钮好。
-        (typeof P.Modal === 'function' && senderEdit !== null
-          ? h(P.Modal, {
-            open: true,
-            onClose: closeSenderDialog,
-            title: t(senderEdit.index >= senders.length ? 'sender.addTitle' : 'sender.editTitle'),
-            closeLabel: t('sender.cancel'),
-            footer: h(React.Fragment, null,
-              h(Button, { variant: 'outline', size: 'sm', onClick: closeSenderDialog }, t('sender.cancel')),
-              h(Button, { variant: 'primary', size: 'sm', onClick: saveSenderDialog }, t('sender.save'))),
-          },
-          h('div', { className: 'dshmn-field' },
-            h('label', { className: 'dshmn-label', htmlFor: 'dshmn-sender-name' }, t('sender.name')),
-            h(TextInput, {
-              id: 'dshmn-sender-name',
-              type: 'text',
-              value: senderEdit.name,
-              onChange: (event) => setSenderEdit({ ...senderEdit, name: event.target.value }),
-            }),
-            h('div', { className: 'dshmn-hint' }, t('sender.nameHint'))),
-          h('div', { className: 'dshmn-field' },
-            h('label', { className: 'dshmn-label', htmlFor: 'dshmn-sender-addr' }, t('sender.address')),
-            h(TextInput, {
-              id: 'dshmn-sender-addr',
-              type: 'text',
-              value: senderEdit.address,
-              onChange: (event) => setSenderEdit({ ...senderEdit, address: event.target.value }),
-            }),
-            h('div', { className: 'dshmn-hint' }, t('sender.addressHint'))),
-          senderErr !== '' ? h('div', { className: 'dshmn-error', role: 'alert' }, senderErr) : null)
-          : null))));
+          : null));
     }
 
     /**
@@ -7146,7 +6978,29 @@ window.__ModuleLoader__.load({
       const message = typeof error === 'string'
         ? error
         : (error && typeof error === 'object' && typeof error.message === 'string' ? error.message : JSON.stringify(error ?? response));
-      throw new Error(message);
+      const failure = new Error(message);
+      // RemoteError 的真实形状（@deepseek-ai/dsh-typert-protocol）：一个真 Error，带 code 与 details。
+      // **一定要把 code 带出来**：冲突恢复只认 code，把它丢掉就只剩一句人话，
+      // 重试必然拿着旧 revision 再撞一次，用户只能关掉设置页再进来。
+      if (error && typeof error === 'object') {
+        if (typeof error.code === 'string') failure.code = error.code;
+        if (error.details !== undefined) failure.details = error.details;
+      }
+      throw failure;
+    }
+
+    /**
+     * 这次写失败，是不是「我读到之后别人又改了」？
+     *
+     * 判别一律靠 code（settings 控制器对 provider 的拒绝只分两档）：
+     *   - settings/conflict：revision 被别处推走了，正确反应是**重读 + 重放**；
+     *   - settings/rejected：请求本身不成立（只读 provider / schema 校验 / 存储故障），重试没用。
+     * @param {unknown} error 捕获到的异常
+     * @returns {boolean} true 表示是 revision 冲突
+     */
+    function isConflict(error) {
+      const code = typeof error?.code === 'string' ? error.code : '';
+      return code === 'settings/conflict' || code === 'conflict';
     }
 
     /**
@@ -7154,8 +7008,8 @@ window.__ModuleLoader__.load({
      *
      * 走 connection 的通用 RPC 而不是挂 remote 命名空间：本插件的 client 半是手写包，
      * 没有生成出来的 remote 声明，而 `/api` + `<namespace>/<method>` 是同一套网关，
-     * 参数与清单里声明的 parameters 必须完全一致（这里两个方法都是零参数）。
-     * @param {'test'|'state'} method 方法名
+     * 参数与清单里声明的 parameters 必须完全一致（test 是零参数）。
+     * @param {'test'} method 方法名
      * @returns {Promise<unknown>} Remote 的 `{ ok, value }` 信封
      */
     function callRemote(method) {
@@ -7191,7 +7045,7 @@ window.__ModuleLoader__.load({
         }
 
         // Host 动作走 connection 的通用 RPC：`/api` + `<namespace>/<method>`。
-        // 参数必须与清单声明的 parameters 完全一致——test/state 都是零参数，所以是空对象。
+        // 参数必须与清单声明的 parameters 完全一致——test 是零参数，所以是空对象。
         try {
           ctx.inject(['connection'], (scoped) => {
             const rpc = scoped.connection?.rpc;
@@ -7205,7 +7059,7 @@ window.__ModuleLoader__.load({
 
         try {
           ctx.inject(['locale'], (scoped) => {
-            ctx.effect(() => scoped.locale.register(NS, { zh: ZH, en: EN }), 'dsh-notify-p: dictionaries');
+            ctx.effect(() => scoped.locale.register(LOCALE_NS, { zh: ZH, en: EN }), 'dsh-notify-p: dictionaries');
             i18n.locale = scoped.locale;
             console.info('[dsh-notify-p] 文案字典已注册 / locale dictionaries registered');
           });
@@ -7230,7 +7084,7 @@ window.__ModuleLoader__.load({
         }
       },
       /** 给离线单测用的接线口（浏览器运行时不会读它）。 */
-      __internals: { parseRecipients, migrateSenders, activeSenderAddress, senderIssue, senderCommit, senderRemove, deriveStatus, matchPreset, presetForAddress, dotState, accountMismatch, userForPreset, relativeTime, PRESETS, ZH, EN, CSS, fmt, i18n },
+      __internals: { parseRecipients, deriveStatus, matchPreset, presetForAddress, dotState, accountMismatch, userForPreset, PRESETS, ZH, EN, CSS, fmt, diffOps, i18n },
     };
   },
 });
@@ -8172,6 +8026,1899 @@ window.__ModuleLoader__.load({
   }
   //#endregion
 
+  //#region workspace rows
+  /**
+   * Workspace-sidebar tags, whole-group hiding, and the "Workspaces" settings table.
+   *
+   * Why the merge glue: the three bundled parts are byte-locked by
+   * test/merged-client.test.mjs, and the shipped workspace browser is a single
+   * opaque seat (sidebar.workspaces, kind single) with no per-row children, so a
+   * tag can only be injected and hiding can only be a style rule. Both are built
+   * to fail silently and never throw into the host's render tree.
+   *
+   * Host contract (read-only reference: @deepseek-ai/dsh-client-ui-workspace):
+   *   [data-slot="sidebar.workspaces"]
+   *     div.groupSection                        one per workspace; children nest
+   *       div[role="treeitem"][data-row-key="workspace:<id>"]
+   *         span.projectText > span.title
+   *         span.rowActions                     hover actions ("⋯" + new session)
+   *       div[role="group"] > div.groupSection    child workspaces
+   *       div[role="treeitem"][data-row-key="session:<id>"][aria-selected]
+   *       button[data-row-key="overflow:<key>"]
+   *
+   * Tag placement is row-level: the badge is a direct child of the workspace
+   * row, immediately before span.rowActions (or at the row's end when the host
+   * renders no actions). margin-left:auto pushes it to the right edge; the
+   * row's own gap supplies the minimum spacing from the name. The idempotency
+   * key is data-lookout-ws-tag="<workspaceId>".
+   *
+   * Hiding is one generated rule per hidden workspace, with every selector
+   * scoped to the group wrapper one/two levels above the keyed row (the shipped
+   * HoverCard wraps its anchor in a <span>):
+   *   div:has(> [data-row-key="workspace:<id>"]),
+   *   div:has(>span>[data-row-key="workspace:<id>"]), {display:none!important}
+   * plus .*groupSection variants of the same two shapes. :has() hides the whole
+   * group (workspace row + its sessions + the "expand" button) without touching
+   * React. No rule is ever generated for a workspace that contains the CURRENT
+   * session, nor for any of its ancestors.
+   *
+   * Preferences live on the Host (iconCustom/getWorkspacePrefs /
+   * setWorkspacePrefs, full-document replace) with a localStorage mirror used
+   * first on load and kept as the fallback when RPC is unavailable. A save
+   * failure is reported once, never per keystroke.
+   *
+   * Breaker (the row-menu pattern): three consecutive scans that place nothing
+   * while there IS work to place stop the feature for the page, warn once,
+   * explain once, and can be reset from the settings switch.
+   */
+  /**
+   * Own locale namespace. locale.register() THROWS when a namespace already owns a
+   * locale, and the file-row menu above already registers zh/en under
+   * "dsh-lookout"; sharing it would silently drop these dictionaries.
+   */
+  const WS_ROWS_NS = "dsh-lookout-workspaces";
+  const WS_TAG_ATTR = "data-lookout-ws-tag";
+  const WS_TAG_TEXT_ATTR = "data-lookout-ws-tag-text";
+  const WS_TOAST_ATTR = "data-lookout-ws-toast";
+  const WS_STYLE_KEY = "lookout-workspace-rows";
+  const WS_HIDE_STYLE_KEY = "lookout-workspace-hide";
+  const WS_PREFS_LOCAL_KEY = "dsh-lookout.workspacePrefs";
+  const WS_ROWS_ENABLED_KEY = "dsh-lookout:workspace-rows:enabled";
+  const WS_ROWS_DISMISSED_KEY = "dsh-lookout:workspace-rows:gave-up-dismissed";
+  const WS_MAX_FAILURES = 3;
+  const WS_SCAN_DEBOUNCE = 200;
+  const WS_QUIET_MS = 250;
+  const WS_TOAST_MS = 3000;
+  const WS_SAVE_DEBOUNCE = 250;
+  const WS_TAG_MAX = 6;
+  /** Pin replay: coalesce list churn, then move only what is out of place. */
+  const WS_PIN_DEBOUNCE = 150;
+  const WS_PIN_MAX_ROUNDS = 5;
+  const WS_PIN_MAX_MOVES = 32;
+  /** A refused reorder backs off, then gives up: no RPC hammering on a broken host. */
+  const WS_PIN_RETRY_MS = 2000;
+  const WS_PIN_MAX_FAILURES = 3;
+  /** Same eight names the Host normalizes to; anything else falls back to gray. */
+  const WS_COLORS = ["red", "orange", "yellow", "green", "cyan", "blue", "purple", "gray"];
+  const WS_COLOR_DEFAULT = "gray";
+  /**
+   * Literal colours for the eight tag dots. Each capsule keeps the host's grey
+   * fill and secondary text colour and draws only its dot in the accent hue;
+   * the rest of the row keeps --dsw-alias-* tokens so light/dark still follows
+   * the host; these hues have no token equivalent.
+   */
+  const WS_COLOR_FALLBACK = {
+    red: "#e5484d",
+    orange: "#f76b15",
+    yellow: "#d9a123",
+    green: "#30a46c",
+    cyan: "#00a2c7",
+    blue: "#3e63dd",
+    purple: "#8e4ec6",
+    gray: "#8b8d98"
+  };
+  const WS_ROW_KEY_ATTR = "data-row-key";
+  const WS_WORKSPACE_PREFIX = "workspace:";
+  const WS_SESSION_PREFIX = "session:";
+  const WS_CONTAINER_SELECTOR = '[data-slot="sidebar.workspaces"]';
+  const WS_CONTAINER_FALLBACK = '[data-slot="sidebar"]';
+  /** Workspace ids are uuid-ish; refuse anything a CSS attribute string cannot carry safely. */
+  const WS_ID_PATTERN = /^[A-Za-z0-9._:-]{1,200}$/;
+  const WS_HIDE_CSS_HEADER = "/* dsh-lookout: hidden workspaces (regenerated on every paint) */";
+
+  const WS_ROWS_CSS = [
+    ".dsh-lookout-ws-tag{display:inline-flex;align-items:center;gap:4px;flex:none;max-width:9em;margin-left:auto;padding:0 6px;height:16px;border-radius:999px;background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-secondary);font-size:11px;line-height:16px;pointer-events:none;overflow:hidden;white-space:nowrap;}",
+    ".dsh-lookout-ws-tag-dot{flex:none;width:6px;height:6px;border-radius:50%;background:" + WS_COLOR_FALLBACK.gray + ";}",
+    ".dsh-lookout-ws-tag-text{min-width:0;overflow:hidden;text-overflow:ellipsis;}",
+    ".dsh-lookout-ws-toast{position:fixed;left:50%;bottom:24px;z-index:90;display:flex;align-items:center;gap:10px;max-width:min(92vw,560px);padding:9px 12px;transform:translateX(-50%);border:1px solid var(--dsw-alias-border-l2);border-radius:10px;background:var(--dsw-alias-toast-bg);color:var(--dsw-alias-label-primary-inverted);font-size:12px;line-height:1.5;box-shadow:0 8px 24px var(--dsw-alias-bg-mask-drop);}",
+    ".dsh-lookout-ws-toast button{flex:none;padding:3px 8px;border:1px solid var(--dsw-alias-border-l2);border-radius:6px;background:transparent;color:inherit;font:inherit;cursor:pointer;}"
+  ].concat(WS_COLORS.map((name) => '.dsh-lookout-ws-tag[data-color="' + name + '"] .dsh-lookout-ws-tag-dot{background:' + WS_COLOR_FALLBACK[name] + ";}")).join("\n");
+
+  /** Chinese fallback for every translate call, also used when locale is unavailable. */
+  const WS_ROWS_ZH = {
+    nav: "工作区管理",
+    toggleLabel: "在侧栏显示工作区标签，并按设置隐藏工作区",
+    toggleHint: "标签只显示在侧栏工作区行右侧（悬停时出现在「⋯」按钮左边）；隐藏是把整个工作区收起（连同它下面的会话和「展开」按钮）。当前会话所在的工作区永远不会被隐藏。这些偏好存在宿主侧，宿主升级后若定位不到工作区行，只会不显示，侧栏本身不受影响。",
+    colName: "工作区",
+    colTag: "标签",
+    colColor: "颜色",
+    colPin: "置顶",
+    colHide: "隐藏",
+    tagPlaceholder: "最多 6 字",
+    pinnedHint: "置顶的工作区排在列表最前；取消置顶会尽量放回原来的位置。子工作区不单独置顶，跟着它的上级工作区排列。",
+    pinChildHint: "子工作区不单独置顶，跟着上级工作区排列。",
+    pinUnavailable: "拿不到工作区服务，置顶只会保存偏好，不会调整顺序。",
+    pinFailed: "工作区置顶没有生效，列表可能保持原样。",
+    cleanup: "清理失效项",
+    cleaned: "已清理 {n} 个失效项",
+    cleanNone: "没有可清理的失效项",
+    empty: "还没有工作区。",
+    colorRed: "红",
+    colorOrange: "橙",
+    colorYellow: "黄",
+    colorGreen: "绿",
+    colorCyan: "青",
+    colorBlue: "蓝",
+    colorPurple: "紫",
+    colorGray: "灰",
+    givingUp: "工作区标签连续注入失败，已自动停止；侧栏本身不受影响。",
+    dismiss: "不再提示",
+    saveFailed: "工作区偏好保存失败，改动只保留在本机。"
+  };
+  const WS_ROWS_EN = {
+    nav: "Workspaces",
+    toggleLabel: "Show workspace tags in the sidebar and hide workspaces as configured",
+    toggleHint: "A tag sits at the right end of the workspace row, just left of the hover actions; hiding collapses a whole workspace group, including its sessions and the expand button. The workspace that holds the current session is never hidden. Preferences live on the host, so a host upgrade can at worst stop the tags from appearing \u2014 the sidebar itself is unaffected.",
+    colName: "Workspace",
+    colTag: "Tag",
+    colColor: "Colour",
+    colPin: "Pin",
+    colHide: "Hide",
+    tagPlaceholder: "Up to 6 characters",
+    pinnedHint: "Pinned workspaces sit at the top of the list; unpinning puts one back where it was. Child workspaces are not pinned on their own \u2014 they follow their parent.",
+    pinChildHint: "Child workspaces are not pinned on their own; they follow their parent workspace.",
+    pinUnavailable: "The workspace service is unavailable, so pinning only saves the preference and never reorders.",
+    pinFailed: "Pinning did not take effect; the list may look unchanged.",
+    cleanup: "Remove stale entries",
+    cleaned: "Removed {n} stale entries",
+    cleanNone: "No stale entries to remove",
+    empty: "No workspaces yet.",
+    colorRed: "Red",
+    colorOrange: "Orange",
+    colorYellow: "Yellow",
+    colorGreen: "Green",
+    colorCyan: "Cyan",
+    colorBlue: "Blue",
+    colorPurple: "Purple",
+    colorGray: "Gray",
+    givingUp: "The workspace tags could not be injected repeatedly and stopped; the sidebar itself is unaffected.",
+    dismiss: "Do not show again",
+    saveFailed: "Workspace preferences could not be saved; changes stay in this browser only."
+  };
+
+  const WS_STYLE_TITLE = { fontSize: 13, fontWeight: 600, color: "var(--dsw-alias-label-primary)", marginBottom: 8 };
+  const WS_STYLE_HINT = { marginTop: 6, fontSize: 12, lineHeight: 1.6, color: "var(--dsw-alias-label-tertiary)" };
+  const WS_STYLE_TABLE = { borderCollapse: "collapse", fontSize: 12, color: "var(--dsw-alias-label-primary)" };
+  const WS_STYLE_TH = { padding: "4px 8px", textAlign: "left", fontWeight: 500, color: "var(--dsw-alias-label-tertiary)", borderBottom: "1px solid var(--dsw-alias-border-l2)" };
+  const WS_STYLE_TD = { padding: "4px 8px", borderBottom: "1px solid var(--dsw-alias-border-l2)", verticalAlign: "middle" };
+  const WS_STYLE_ACTIONS = { display: "flex", alignItems: "center", gap: 12, marginTop: 10 };
+  const WS_STYLE_TOGGLE = { display: "inline-flex", alignItems: "center", gap: 6, fontSize: 12, color: "var(--dsw-alias-label-primary)", cursor: "pointer" };
+
+  function wsRowsFallbackText(key, params) {
+    const template = typeof WS_ROWS_ZH[key] === "string" ? WS_ROWS_ZH[key] : key;
+    if (params === null || params === undefined || typeof params !== "object") return template;
+    let text = template;
+    for (const name of Object.keys(params)) text = text.split("{" + name + "}").join(String(params[name]));
+    return text;
+  }
+
+  /** Tag normalization matches the Host: drop control characters, trim, cap at 6 Unicode characters. */
+  function wsRowsNormalizeTag(input) {
+    if (typeof input !== "string") return "";
+    const cleaned = input.replace(/\p{Cc}/gu, "").trim();
+    return [...cleaned].slice(0, WS_TAG_MAX).join("");
+  }
+
+  function wsRowsNormalizeColor(input) {
+    return WS_COLORS.indexOf(input) >= 0 ? input : WS_COLOR_DEFAULT;
+  }
+
+  function wsRowsValidId(input) {
+    return typeof input === "string" && WS_ID_PATTERN.test(input);
+  }
+
+  function wsRowsEmptyDoc() {
+    return { version: 1, workspaces: {} };
+  }
+
+  function wsRowsNormalizeEntry(input) {
+    const source = input !== null && typeof input === "object" && !Array.isArray(input) ? input : {};
+    return {
+      tag: wsRowsNormalizeTag(source.tag),
+      color: wsRowsNormalizeColor(source.color),
+      pinned: source.pinned === true,
+      hidden: source.hidden === true,
+      pinAnchor: typeof source.pinAnchor === "string" ? source.pinAnchor : null
+    };
+  }
+
+  /** Never throws: a corrupt cache or a bad Host response degrades to the empty document. */
+  function wsRowsNormalizeDoc(input) {
+    const doc = wsRowsEmptyDoc();
+    if (input === null || typeof input !== "object" || Array.isArray(input)) return doc;
+    const workspaces = input.workspaces;
+    if (workspaces === null || typeof workspaces !== "object" || Array.isArray(workspaces)) return doc;
+    for (const [id, entry] of Object.entries(workspaces)) {
+      if (!wsRowsValidId(id)) continue;
+      if (id === "__proto__" || id === "constructor" || id === "prototype") continue;
+      doc.workspaces[id] = wsRowsNormalizeEntry(entry);
+    }
+    return doc;
+  }
+
+  /** An entry that carries no preference at all is dropped instead of being kept as junk. */
+  function wsRowsIsDefaultEntry(entry) {
+    return entry.tag === "" && entry.pinned !== true && entry.hidden !== true && entry.pinAnchor === null;
+  }
+
+  function wsRowsReadFlag(key, fallback) {
+    try {
+      const raw = window.localStorage.getItem(key);
+      if (raw === "1") return true;
+      if (raw === "0") return false;
+      return fallback;
+    } catch { return fallback; }
+  }
+
+  function wsRowsWriteFlag(key, value) {
+    try { window.localStorage.setItem(key, value ? "1" : "0"); } catch { /* advisory */ }
+  }
+
+  function wsRowsReadLocalPrefs() {
+    try {
+      const raw = window.localStorage.getItem(WS_PREFS_LOCAL_KEY);
+      if (typeof raw !== "string" || raw === "") return wsRowsEmptyDoc();
+      return wsRowsNormalizeDoc(JSON.parse(raw));
+    } catch { return wsRowsEmptyDoc(); }
+  }
+
+  function wsRowsWriteLocalPrefs(doc) {
+    try { window.localStorage.setItem(WS_PREFS_LOCAL_KEY, JSON.stringify(doc)); } catch { /* advisory */ }
+  }
+
+  /** One warning per page at most, and only for a real degradation. */
+  let wsRowsWarned = false;
+  function wsRowsWarn(message, error) {
+    if (wsRowsWarned) return;
+    wsRowsWarned = true;
+    try { console.warn("dsh-lookout: " + message, error); } catch { /* no console */ }
+  }
+
+  /** The table's row list: live workspaces first, the stored ids when the host list is unavailable. */
+  function wsRowsTableRows(prefs, items) {
+    const doc = wsRowsNormalizeDoc(prefs);
+    const rows = [];
+    const seen = new Set();
+    const roots = wsPinRootIds(items);
+    if (Array.isArray(items)) {
+      for (const item of items) {
+        if (item === null || typeof item !== "object") continue;
+        const id = typeof item.workspaceId === "string" ? item.workspaceId : (typeof item.id === "string" ? item.id : "");
+        if (!wsRowsValidId(id) || seen.has(id)) continue;
+        seen.add(id);
+        const title = typeof item.title === "string" && item.title.trim() !== ""
+          ? item.title
+          : (typeof item.name === "string" && item.name.trim() !== "" ? item.name : id);
+        rows.push({
+          id,
+          name: title,
+          child: items.length > 0 && !roots.has(id),
+          entry: doc.workspaces[id] !== undefined ? doc.workspaces[id] : wsRowsNormalizeEntry(null)
+        });
+      }
+    }
+    if (rows.length === 0) {
+      for (const id of Object.keys(doc.workspaces)) rows.push({ id, name: id, child: false, entry: doc.workspaces[id] });
+    }
+    return rows;
+  }
+
+  function wsRowsKnownIds(items) {
+    const ids = [];
+    if (!Array.isArray(items)) return ids;
+    for (const item of items) {
+      if (item === null || typeof item !== "object") continue;
+      const id = typeof item.workspaceId === "string" ? item.workspaceId : (typeof item.id === "string" ? item.id : "");
+      if (wsRowsValidId(id)) ids.push(id);
+    }
+    return ids;
+  }
+
+  /** Path spelling used by the shipped workspace list: forward slashes, no trailing slash. */
+  function wsPinNormalizePath(value) {
+    if (typeof value !== "string") return "";
+    const trimmed = value.trim();
+    if (trimmed === "") return "";
+    const normalized = trimmed.replace(/\\/g, "/").replace(/\/+$/, "");
+    return normalized === "" ? "/" : normalized;
+  }
+
+  /**
+   * Workspaces that are roots rather than children: a path sitting under
+   * another registered workspace's path is a child and never pins on its own.
+   * An item without a usable path counts as a root (topology unknown, never
+   * guess); a stored pin on a child is ignored but never deleted.
+   * @returns Set of root workspace ids.
+   */
+  function wsPinRootIds(items) {
+    const entries = [];
+    if (Array.isArray(items)) {
+      for (const item of items) {
+        if (item === null || typeof item !== "object") continue;
+        const id = typeof item.workspaceId === "string" && item.workspaceId !== ""
+          ? item.workspaceId
+          : (typeof item.id === "string" ? item.id : "");
+        if (!wsRowsValidId(id)) continue;
+        entries.push({ id, path: wsPinNormalizePath(item.path) });
+      }
+    }
+    const roots = new Set();
+    for (const entry of entries) {
+      let child = false;
+      if (entry.path !== "") {
+        for (const parent of entries) {
+          if (parent === entry || parent.path === "") continue;
+          const under = parent.path === "/"
+            ? entry.path.charAt(0) === "/"
+            : entry.path.indexOf(parent.path + "/") === 0;
+          if (under) { child = true; break; }
+        }
+      }
+      if (!child) roots.add(entry.id);
+    }
+    return roots;
+  }
+
+  /**
+   * The minimum moves that put every pinned ROOT workspace at the front while
+   * keeping their current relative order. Returns null when the list already
+   * satisfies that, so a settled list makes ZERO insertBefore calls.
+   *
+   * Only the pinned workspaces that are not already in the correct prefix move;
+   * each is inserted before the same first unpinned workspace, which keeps the
+   * moved block in order without reading the list between awaits.
+   * @param prefsDoc - the preference document.
+   * @param items - the live workspace list (workspaceId / path / title).
+   * @returns { steps, key } or null.
+   */
+  function wsPinPlan(prefsDoc, items) {
+    const doc = wsRowsNormalizeDoc(prefsDoc);
+    const ids = [];
+    if (Array.isArray(items)) {
+      for (const item of items) {
+        if (item === null || typeof item !== "object") continue;
+        const id = typeof item.workspaceId === "string" && item.workspaceId !== ""
+          ? item.workspaceId
+          : (typeof item.id === "string" ? item.id : "");
+        if (wsRowsValidId(id) && ids.indexOf(id) < 0) ids.push(id);
+      }
+    }
+    if (ids.length === 0) return null;
+    const roots = wsPinRootIds(items);
+    const pinned = [];
+    for (const id of ids) {
+      const entry = doc.workspaces[id];
+      if (entry === undefined || entry.pinned !== true) continue;
+      if (!roots.has(id)) continue; // a child's historical pin is ignored, not cleared
+      pinned.push(id);
+    }
+    if (pinned.length === 0) return null;
+    let placed = 0;
+    while (placed < pinned.length && ids[placed] === pinned[placed]) placed++;
+    if (placed >= pinned.length) return null;
+    // ids[placed] is non-pinned by construction, so it is the stable anchor.
+    const before = ids[placed];
+    const steps = [];
+    for (let index = placed; index < pinned.length; index++) steps.push({ id: pinned[index], before });
+    return { steps, key: steps.map((step) => step.id + ">" + step.before).join("|") };
+  }
+
+  /** Escape a value for a double-quoted CSS string; control characters are quoted numerically. */
+  function wsRowsCssString(value) {
+    let out = "";
+    for (const character of String(value)) {
+      const code = character.codePointAt(0);
+      if (character === '"' || character === "\\") out += "\\" + character;
+      else if (code < 0x20 || code === 0x7f) out += "\\" + code.toString(16) + " ";
+      else out += character;
+    }
+    return out;
+  }
+
+  function wsRowsStart(ctx, require) {
+    let controller = null;
+    try {
+      controller = wsRowsInstall(ctx, require);
+    } catch (error) {
+      wsRowsWarn("工作区标签初始化失败,已跳过(不影响宿主):", error);
+      return;
+    }
+    try {
+      if (ctx !== null && ctx !== undefined && typeof ctx.effect === "function") {
+        ctx.effect(() => () => { try { controller.dispose(); } catch { /* best effort */ } }, "dsh-lookout: workspace rows");
+      } else if (ctx !== null && ctx !== undefined && typeof ctx.on === "function") {
+        ctx.on("dispose", () => { try { controller.dispose(); } catch { /* best effort */ } });
+      }
+    } catch (error) {
+      wsRowsWarn("工作区标签挂到生命周期失败:", error);
+    }
+  }
+
+  /**
+   * Install tags + hiding + the settings table, and return the controller.
+   * Every DOM lookup is guarded: a host upgrade can only cost the tags.
+   * @returns {object} controller: dispose / snapshot / subscribe / updateEntry /
+   * cleanupMissing / paintNow / domWorkspaceIds / setEnabled / isEnabled.
+   */
+  function wsRowsInstall(ctx, require) {
+    let disposed = false;
+    let enabled = wsRowsReadFlag(WS_ROWS_ENABLED_KEY, true);
+    let prefs = wsRowsReadLocalPrefs();
+    let localDirty = false;
+    let translate = wsRowsFallbackText;
+    let observer = null;
+    let observerRoot = null;
+    let retryTimer = 0;
+    let scanTimer = 0;
+    let saveTimer = 0;
+    let painting = false;
+    let paintedAt = 0;
+    let failures = 0;
+    let givenUp = false;
+    let saveFailedOnce = false;
+    let toast = null;
+    let toastTimer = 0;
+    const prefListeners = new Set();
+    // ---- pinning --------------------------------------------------------
+    // The workspace service arrives late (ctx.inject) and is optional: tags,
+    // hiding and the preferences table never wait for it.
+    let pinService = null;
+    let pinUnsubscribe = null;
+    let pinTimer = 0;
+    let pinRunning = false;
+    let pinDirty = false;
+    let pinWarned = false;
+    let pinFailedOnce = false;
+    let pinFailures = 0;
+    let pinSuspended = false;
+    let pinCooldownUntil = 0;
+
+    // ---- locale ---------------------------------------------------------
+    try {
+      const locale = ctx !== null && ctx !== undefined ? ctx.locale : null;
+      if (locale !== null && locale !== undefined && typeof locale.register === "function") {
+        const register = () => locale.register(WS_ROWS_NS, { zh: WS_ROWS_ZH, en: WS_ROWS_EN });
+        if (typeof ctx.effect === "function") ctx.effect(register, "dsh-lookout: workspace rows dictionaries");
+        else register();
+      }
+      if (locale !== null && locale !== undefined && typeof locale.bind === "function") {
+        const bound = locale.bind(WS_ROWS_NS);
+        translate = (key, params) => {
+          let text = key;
+          try { text = bound(key, params); } catch { text = key; }
+          return typeof text === "string" && text !== key ? text : wsRowsFallbackText(key, params);
+        };
+      }
+    } catch (error) { /* Chinese fallback is already in place */ }
+
+    const api = {
+      snapshot: snapshot,
+      subscribe: subscribePrefs,
+      updateEntry: updateEntry,
+      cleanupMissing: cleanupMissing,
+      paintNow: paint,
+      pinNow: pinNow,
+      domWorkspaceIds: domWorkspaceIds,
+      setEnabled: setEnabled,
+      isEnabled: () => enabled === true
+    };
+
+    // ---- settings page --------------------------------------------------
+    // Own section (order 56, right after the file-row menu at 55): the three
+    // bundled parts own their pages and are byte-locked.
+    try {
+      const React = require("react");
+      if (React !== null && typeof React.createElement === "function" && typeof React.useState === "function") {
+        function WorkspaceRowsSection(props) {
+          const label = props !== null && props !== undefined && typeof props.t === "function" ? props.t : translate;
+          const [view, setView] = React.useState(() => prefs);
+          const [on, setOn] = React.useState(() => enabled);
+          const [notice, setNotice] = React.useState("");
+          React.useEffect(() => subscribePrefs(setView), []);
+          const useWorkspaces = props !== null && props !== undefined ? props.useWorkspaces : null;
+          const snapshotState = typeof useWorkspaces === "function" ? useWorkspaces((state) => state) : undefined;
+          const items = snapshotState !== null && typeof snapshotState === "object" && Array.isArray(snapshotState.items) ? snapshotState.items : [];
+          const rows = wsRowsTableRows(view, items);
+          const commit = (id, patch) => { updateEntry(id, patch); };
+          const onCleanup = () => {
+            const live = wsRowsKnownIds(items);
+            const ids = live.length > 0 ? live : domWorkspaceIds();
+            const removed = cleanupMissing(ids);
+            setNotice(removed > 0 ? label("cleaned", { n: removed }) : label("cleanNone"));
+          };
+          const header = React.createElement("thead", null,
+            React.createElement("tr", null,
+              ["colName", "colTag", "colColor", "colPin", "colHide"].map((key) =>
+                React.createElement("th", { key, style: WS_STYLE_TH }, label(key)))));
+          const body = React.createElement("tbody", null,
+            rows.map((row) => React.createElement("tr", { key: row.id, "data-lookout-ws-row": row.id },
+              React.createElement("td", { style: WS_STYLE_TD }, row.name),
+              React.createElement("td", { style: WS_STYLE_TD },
+                React.createElement("input", {
+                  "data-lookout-ws-field": "tag",
+                  "data-lookout-ws-id": row.id,
+                  type: "text",
+                  maxLength: WS_TAG_MAX,
+                  value: row.entry.tag,
+                  placeholder: label("tagPlaceholder"),
+                  style: { width: 96 },
+                  onChange: (event) => commit(row.id, { tag: event.target.value })
+                })),
+              React.createElement("td", { style: WS_STYLE_TD },
+                React.createElement("select", {
+                  "data-lookout-ws-field": "color",
+                  "data-lookout-ws-id": row.id,
+                  value: row.entry.color,
+                  onChange: (event) => commit(row.id, { color: event.target.value })
+                }, WS_COLORS.map((name) =>
+                  React.createElement("option", { key: name, value: name },
+                    label("color" + name.charAt(0).toUpperCase() + name.slice(1)))))),
+              React.createElement("td", { style: WS_STYLE_TD },
+                React.createElement("input", {
+                  "data-lookout-ws-field": "pinned",
+                  "data-lookout-ws-id": row.id,
+                  type: "checkbox",
+                  checked: row.entry.pinned === true,
+                  disabled: row.child === true,
+                  title: row.child === true ? label("pinChildHint") : undefined,
+                  onChange: (event) => commit(row.id, { pinned: event.target.checked === true })
+                })),
+              React.createElement("td", { style: WS_STYLE_TD },
+                React.createElement("input", {
+                  "data-lookout-ws-field": "hidden",
+                  "data-lookout-ws-id": row.id,
+                  type: "checkbox",
+                  checked: row.entry.hidden === true,
+                  onChange: (event) => commit(row.id, { hidden: event.target.checked === true })
+                })))));
+          return React.createElement("div", { "data-lookout-settings": "workspaces" },
+            React.createElement("div", { style: WS_STYLE_TITLE }, label("nav")),
+            rows.length === 0
+              ? React.createElement("div", { style: WS_STYLE_HINT }, label("empty"))
+              : React.createElement("table", { style: WS_STYLE_TABLE, "data-lookout-ws-table": "" }, header, body),
+            rows.some((row) => row.child === true)
+              ? React.createElement("div", { style: WS_STYLE_HINT }, label("pinChildHint"))
+              : null,
+            React.createElement("div", { style: WS_STYLE_ACTIONS },
+              React.createElement("button", {
+                type: "button",
+                "data-lookout-ws-cleanup": "",
+                onClick: onCleanup
+              }, label("cleanup")),
+              React.createElement("label", { style: WS_STYLE_TOGGLE },
+                React.createElement("input", {
+                  type: "checkbox",
+                  "data-lookout-ws-toggle": "",
+                  checked: on,
+                  onChange: (event) => {
+                    const next = event.target.checked === true;
+                    setOn(next);
+                    setEnabled(next);
+                  }
+                }),
+                React.createElement("span", null, label("toggleLabel")))),
+            notice !== "" ? React.createElement("div", { style: WS_STYLE_HINT }, notice) : null,
+            React.createElement("div", { style: WS_STYLE_HINT }, label("toggleHint")),
+            React.createElement("div", { style: WS_STYLE_HINT }, label("pinnedHint")));
+        }
+        const slots = ctx !== null && ctx !== undefined ? ctx.slots : null;
+        if (slots !== null && slots !== undefined && typeof slots.inject === "function" && typeof slots.register === "function") {
+          slots.inject("settings.section", () => slots.register({
+            name: "settings.section",
+            id: "lookout-workspaces",
+            order: 56,
+            label: () => translate("nav"),
+            locale: WS_ROWS_NS,
+            inject: () => ({ t: translate, wsRows: api })
+          }, (props) => React.createElement(WorkspaceRowsSection, Object.assign({}, props, {
+            t: props !== null && props !== undefined && typeof props.t === "function" ? props.t : translate,
+            wsRows: api
+          }))));
+        }
+      }
+    } catch (error) {
+      // Settings are optional; the tags and hiding are not.
+    }
+
+    // ---- styles ---------------------------------------------------------
+    function ensureStyleTag(key, css) {
+      try {
+        const existing = document.querySelector('style[data-plugin-css="' + key + '"]');
+        if (existing !== null && existing !== undefined) {
+          // A linked (hot-reloaded) client keeps its <style> tags alive. Refresh
+          // stale text so a new build's CSS actually reaches the page.
+          if (existing.textContent !== css) {
+            try { existing.textContent = css; } catch { /* tag gone */ }
+          }
+          return existing;
+        }
+        const tag = document.createElement("style");
+        tag.setAttribute("data-plugin", "dsh-lookout");
+        tag.setAttribute("data-plugin-css", key);
+        tag.textContent = css;
+        const head = document.head !== null && document.head !== undefined ? document.head : document.body;
+        if (head !== null && head !== undefined) head.appendChild(tag);
+        return tag;
+      } catch { return null; }
+    }
+
+    function ensureStaticStyle() {
+      ensureStyleTag(WS_STYLE_KEY, WS_ROWS_CSS);
+    }
+
+    function ensureHideStyleTag() {
+      return ensureStyleTag(WS_HIDE_STYLE_KEY, "");
+    }
+
+    // ---- DOM lookups ----------------------------------------------------
+    function container() {
+      try {
+        return document.querySelector(WS_CONTAINER_SELECTOR) || document.querySelector(WS_CONTAINER_FALLBACK) || null;
+      } catch { return null; }
+    }
+
+    function allRowNodes(root) {
+      try {
+        return Array.prototype.slice.call(root.querySelectorAll("[" + WS_ROW_KEY_ATTR + "]"));
+      } catch { return []; }
+    }
+
+    function workspaceRows(root) {
+      return allRowNodes(root).filter((node) => {
+        const key = node.getAttribute(WS_ROW_KEY_ATTR);
+        return typeof key === "string" && key.indexOf(WS_WORKSPACE_PREFIX) === 0;
+      });
+    }
+
+    function rowIdOf(row) {
+      const key = row.getAttribute(WS_ROW_KEY_ATTR);
+      if (typeof key !== "string" || key.indexOf(WS_WORKSPACE_PREFIX) !== 0) return null;
+      const id = key.slice(WS_WORKSPACE_PREFIX.length);
+      return wsRowsValidId(id) ? id : null;
+    }
+
+    function domWorkspaceIds() {
+      const root = container();
+      if (root === null) return [];
+      const ids = [];
+      for (const row of workspaceRows(root)) {
+        const id = rowIdOf(row);
+        if (id !== null) ids.push(id);
+      }
+      return ids;
+    }
+
+    /**
+     * The title element inside one workspace row.
+     *
+     * Primary match: the class token the shipped row gives its title
+     * (YDXeBa_title -> a token ending in "title"). Fallback: the only descendant
+     * span that holds text and no element children. Ambiguity yields null (a
+     * missing badge), never a badge on the wrong row.
+     */
+    function findTitleElement(row) {
+      let spans;
+      try { spans = Array.prototype.slice.call(row.querySelectorAll("span")); } catch { return null; }
+      for (const span of spans) {
+        const tokens = String(span.className === null || span.className === undefined ? "" : span.className).split(/\s+/);
+        for (const token of tokens) {
+          if (token !== "" && /(?:^|[_-])title$/i.test(token)) return span;
+        }
+      }
+      const holders = [];
+      for (const span of spans) {
+        const text = typeof span.textContent === "string" ? span.textContent.trim() : "";
+        if (text === "") continue;
+        let hasElementChild = false;
+        for (const child of span.children) {
+          if (child.tagName === "SPAN" || child.tagName === "DIV" || child.tagName === "BUTTON" || child.tagName === "SVG") {
+            hasElementChild = true;
+            break;
+          }
+        }
+        if (!hasElementChild) holders.push(span);
+      }
+      return holders.length === 1 ? holders[0] : null;
+    }
+
+    /**
+     * The direct child span that holds the row's hover actions: the "⋯" menu
+     * and the new-session button. The shipped row gives it a class token ending
+     * in "rowActions"; a row without one puts the tag at the row's end instead.
+     */
+    function findRowActions(row) {
+      let children;
+      try { children = Array.prototype.slice.call(row.children); } catch { return null; }
+      for (const child of children) {
+        if (child.tagName !== "SPAN") continue;
+        const tokens = String(child.className === null || child.className === undefined ? "" : child.className).split(/\s+/);
+        for (const token of tokens) {
+          if (token !== "" && /(?:^|[_-])rowActions$/i.test(token)) return child;
+        }
+      }
+      return null;
+    }
+
+    /**
+     * Where the badge goes: the workspace row itself (div.projectRow), as a
+     * direct child immediately before span.rowActions (or at the row's end when
+     * the host renders no actions). The title only has to exist: the badge no
+     * longer lives inside its flex column, so nothing has to be flipped to a row.
+     */
+    function findTagAnchor(row) {
+      return findTitleElement(row) === null ? null : row;
+    }
+
+    /** True when the badge already sits at its home: row end, left of rowActions. */
+    function badgeInPlace(row, badge, actions) {
+      let children;
+      try { children = Array.prototype.slice.call(row.children); } catch { return false; }
+      const badgeIndex = children.indexOf(badge);
+      if (badgeIndex < 0) return false;
+      if (actions === null || actions.parentNode !== row) return badgeIndex === children.length - 1;
+      return badgeIndex === children.indexOf(actions) - 1;
+    }
+
+    /** Insert or move the badge to its home: row end, but left of rowActions. */
+    function placeBadge(row, badge, actions) {
+      if (actions !== null && actions.parentNode === row) row.insertBefore(badge, actions);
+      else row.appendChild(badge);
+    }
+
+    function badgeIn(row, id) {
+      let nodes;
+      try { nodes = Array.prototype.slice.call(row.querySelectorAll("[" + WS_TAG_ATTR + "]")); } catch { return null; }
+      for (const node of nodes) if (node.getAttribute(WS_TAG_ATTR) === id) return node;
+      return null;
+    }
+
+    function createBadge(id, tag, color) {
+      const badge = document.createElement("span");
+      badge.className = "dsh-lookout-ws-tag";
+      badge.setAttribute(WS_TAG_ATTR, id);
+      badge.setAttribute("data-color", color);
+      badge.title = tag;
+      const dot = document.createElement("span");
+      dot.className = "dsh-lookout-ws-tag-dot";
+      dot.setAttribute("aria-hidden", "true");
+      const text = document.createElement("span");
+      text.className = "dsh-lookout-ws-tag-text";
+      text.setAttribute(WS_TAG_TEXT_ATTR, "");
+      text.textContent = tag;
+      badge.appendChild(dot);
+      badge.appendChild(text);
+      return badge;
+    }
+
+    function updateBadge(badge, tag, color) {
+      badge.setAttribute("data-color", color);
+      badge.title = tag;
+      for (const child of badge.children) {
+        if (child.getAttribute(WS_TAG_TEXT_ATTR) !== null && child.textContent !== tag) { child.textContent = tag; break; }
+      }
+    }
+
+    /**
+     * Reconcile every rendered workspace row against the preferences.
+     *
+     * The badge is row-level: it must be a direct child of the row, immediately
+     * before rowActions, pushed right by margin-left:auto. A badge left in the
+     * old title-anchored spot (inside span.projectText), elsewhere under the
+     * sidebar, or on the wrong side of the row is moved, never duplicated.
+     */
+    function syncBadges(root, rows) {
+      let placed = 0;
+      let missed = 0;
+      let wanted = 0;
+      const known = new Set();
+      for (const row of rows) {
+        const id = rowIdOf(row);
+        if (id === null) continue;
+        known.add(id);
+        const entry = prefs.workspaces[id];
+        const tag = entry !== undefined ? entry.tag : "";
+        if (tag === "") continue;
+        wanted++;
+        const anchor = findTagAnchor(row);
+        if (anchor === null) { missed++; continue; }
+        const actions = findRowActions(anchor);
+        let badge = badgeIn(anchor, id);
+        if (badge === null) {
+          // Migrate a badge an older version left outside this row.
+          try { badge = root.querySelector("[" + WS_TAG_ATTR + '="' + id + '"]'); } catch { badge = null; }
+        }
+        if (badge === null) placeBadge(anchor, createBadge(id, tag, entry.color), actions);
+        else {
+          if (!badgeInPlace(anchor, badge, actions)) placeBadge(anchor, badge, actions);
+          updateBadge(badge, tag, entry.color);
+        }
+        placed++;
+      }
+      let stale;
+      try { stale = Array.prototype.slice.call(root.querySelectorAll("[" + WS_TAG_ATTR + "]")); } catch { stale = []; }
+      for (const badge of stale) {
+        const id = badge.getAttribute(WS_TAG_ATTR);
+        const entry = id !== null ? prefs.workspaces[id] : undefined;
+        if (entry === undefined || entry.tag === "" || !known.has(id)) {
+          try { badge.remove(); } catch { /* gone */ }
+        }
+      }
+      return { placed, missed, wanted };
+    }
+
+    // ---- current-session protection ------------------------------------
+    /** The workspaces the official uiWorkspace service says hold the open session. */
+    function officialCurrentWorkspaceIds() {
+      const ids = new Set();
+      try {
+        const service = ctx !== null && ctx !== undefined && typeof ctx.get === "function" ? ctx.get("uiWorkspace") : null;
+        if (service === null || service === undefined) return ids;
+        const selection = service.selection !== null && service.selection !== undefined && typeof service.selection.getSnapshot === "function"
+          ? service.selection.getSnapshot()
+          : null;
+        const sessionId = selection !== null && typeof selection === "object" ? selection.sessionId : undefined;
+        if (typeof sessionId !== "string" || sessionId === "") return ids;
+        const list = service.workspaces !== null && service.workspaces !== undefined && service.workspaces.list !== null && service.workspaces.list !== undefined
+          ? service.workspaces.list.getSnapshot()
+          : null;
+        const items = list !== null && typeof list === "object" && Array.isArray(list.items) ? list.items : [];
+        let current = null;
+        for (const item of items) {
+          if (item === null || typeof item !== "object") continue;
+          if (!Array.isArray(item.sessionIds) || item.sessionIds.indexOf(sessionId) < 0) continue;
+          if (typeof item.workspaceId === "string" && item.workspaceId !== "") { current = item; break; }
+        }
+        if (current === null) return ids;
+        ids.add(current.workspaceId);
+        const normalizePath = (value) => String(value).replace(/\\/g, "/").replace(/\/+$/, "");
+        const currentPath = typeof current.path === "string" ? normalizePath(current.path) : "";
+        if (currentPath !== "") {
+          for (const item of items) {
+            if (item === null || typeof item !== "object") continue;
+            if (typeof item.workspaceId !== "string" || item.workspaceId === current.workspaceId) continue;
+            const candidate = typeof item.path === "string" ? normalizePath(item.path) : "";
+            if (candidate !== "" && currentPath.indexOf(candidate + "/") === 0) ids.add(item.workspaceId);
+          }
+        }
+      } catch { /* no service: the DOM signals below still protect */ }
+      return ids;
+    }
+
+    function workspaceIdOfElement(element) {
+      const key = element.getAttribute(WS_ROW_KEY_ATTR);
+      if (typeof key !== "string" || key.indexOf(WS_WORKSPACE_PREFIX) !== 0) return null;
+      const id = key.slice(WS_WORKSPACE_PREFIX.length);
+      if (id === "") return "";
+      return wsRowsValidId(id) ? id : null;
+    }
+
+    /**
+     * The workspace this group wrapper owns.
+     *
+     * HoverCard renders its anchor inside a wrapper <span> (the shipped row is a
+     * direct child of that span), so the keyed row is either a direct child of
+     * the group wrapper or one level below it. One level only: nested child
+     * workspaces live under div[role="group"], never as a direct grandchild.
+     */
+    function directWorkspaceChildId(element) {
+      let children;
+      try { children = element.children; } catch { return null; }
+      if (children === null || children === undefined) return null;
+      for (const child of children) {
+        const direct = workspaceIdOfElement(child);
+        if (direct !== null) return direct;
+        let inner;
+        try { inner = child.children; } catch { inner = null; }
+        if (inner === null || inner === undefined) continue;
+        for (const nested of inner) {
+          const id = workspaceIdOfElement(nested);
+          if (id !== null) return id;
+        }
+      }
+      return null;
+    }
+
+    /** Every workspace group that contains this node, nearest first. */
+    function ancestorWorkspaceIds(node, root) {
+      const ids = [];
+      let element = node.parentElement;
+      while (element !== null && element !== undefined && element !== root) {
+        const id = directWorkspaceChildId(element);
+        if (id !== null) ids.push(id);
+        element = element.parentElement;
+      }
+      return ids;
+    }
+
+    /** The shipped row marks the group holding the open session with a *folderActive class. */
+    function marksCurrentGroup(row) {
+      let nodes;
+      try { nodes = Array.prototype.slice.call(row.querySelectorAll("span,div")); } catch { return false; }
+      for (const node of nodes) {
+        const tokens = String(node.className === null || node.className === undefined ? "" : node.className).split(/\s+/);
+        for (const token of tokens) if (token !== "" && /folderActive$/i.test(token)) return true;
+      }
+      return false;
+    }
+
+    /**
+     * Workspace ids whose group must never be hidden.
+     *
+     * Three independent signals, unioned: the official service, the selected
+     * session row (aria-selected / aria-current), and the folderActive mark that
+     * also covers a COLLAPSED group whose session rows are not rendered. If a
+     * selected session cannot be mapped to any workspace group, hide nothing at
+     * all (blockAll): a row the person is reading must never disappear.
+     */
+    function protectedIds(root) {
+      const ids = new Set();
+      let blockAll = false;
+      for (const id of officialCurrentWorkspaceIds()) ids.add(id);
+      for (const node of allRowNodes(root)) {
+        const key = node.getAttribute(WS_ROW_KEY_ATTR);
+        if (typeof key !== "string" || key.indexOf(WS_SESSION_PREFIX) !== 0) continue;
+        const selected = node.getAttribute("aria-selected") === "true" || node.getAttribute("aria-current") === "true";
+        if (!selected) continue;
+        // "" is the ungrouped bucket's key (data-row-key="workspace:"): it counts as
+        // "inside a group, but not inside any real workspace", so hiding the OTHER
+        // workspaces is still safe. Only a selected session with no group wrapper at
+        // all makes us hide nothing.
+        const groupIds = ancestorWorkspaceIds(node, root);
+        if (groupIds.length === 0) blockAll = true;
+        for (const id of groupIds) if (id !== "") ids.add(id);
+      }
+      for (const row of workspaceRows(root)) {
+        const id = rowIdOf(row);
+        if (id !== null && marksCurrentGroup(row)) ids.add(id);
+      }
+      return { ids, blockAll };
+    }
+
+    // ---- hiding ---------------------------------------------------------
+    function renderHide(root) {
+      const style = ensureHideStyleTag();
+      let hidden = 0;
+      let rules = [];
+      try {
+        const guard = protectedIds(root);
+        for (const id of Object.keys(prefs.workspaces)) {
+          if (prefs.workspaces[id].hidden !== true) continue;
+          hidden++;
+          if (guard.blockAll || guard.ids.has(id)) continue;
+          if (!WS_ID_PATTERN.test(id)) continue;
+          // Three shapes, all scoped to ONE or TWO levels above the keyed row, so
+          // an ancestor group is never matched by accident:
+          //   div > row                       (ungrouped bucket; no hover wrapper)
+          //   div > span > row                (the shipped HoverCard wrapper)
+          //   .*groupSection variants         (belt and braces for the two shapes)
+          const key = wsRowsCssString(WS_WORKSPACE_PREFIX + id);
+          const attr = "[" + WS_ROW_KEY_ATTR + '="' + key + '"]';
+          rules.push(
+            "div:has(>" + attr + ")," +
+            "div:has(>span>" + attr + ")," +
+            'div[class*="groupSection"]:has(>' + attr + ")," +
+            'div[class*="groupSection"]:has(>span>' + attr + ")" +
+            "{display:none!important;}"
+          );
+        }
+      } catch (error) {
+        rules = [];
+        wsRowsWarn("隐藏工作区样式生成失败,已跳过(不影响侧栏):", error);
+      }
+      if (style !== null && style !== undefined) {
+        const text = rules.length === 0 ? "" : WS_HIDE_CSS_HEADER + "\n" + rules.join("\n");
+        try { if (style.textContent !== text) style.textContent = text; } catch { /* gone */ }
+      }
+      return { rules: rules.length, wanted: hidden };
+    }
+
+    // ---- paint ----------------------------------------------------------
+    function paint() {
+      if (disposed || !enabled || givenUp) return;
+      const root = container();
+      if (root === null) return;
+      let rows;
+      try { rows = workspaceRows(root); } catch (error) { noteFailure(error); return; }
+      // Sidebar in rail mode, an empty list, or a build without workspace rows:
+      // nothing to place is NOT a failure.
+      if (rows.length === 0) return;
+      painting = true;
+      let placed = 0;
+      let missed = 0;
+      let wanted = 0;
+      let failure = null;
+      try {
+        const synced = syncBadges(root, rows);
+        placed += synced.placed;
+        missed += synced.missed;
+        wanted += synced.wanted;
+        const hide = renderHide(root);
+        placed += hide.rules;
+        wanted += hide.wanted;
+      } catch (error) {
+        failure = error;
+      } finally {
+        painting = false;
+        paintedAt = Date.now();
+      }
+      if (placed > 0) failures = 0;
+      else if (failure !== null) noteFailure(failure);
+      else if (wanted > 0 && missed > 0) noteFailure("这一轮没有任何工作区行能贴上标签: " + missed + " 个");
+    }
+
+    function noteFailure(why) {
+      if (givenUp || disposed) return;
+      failures++;
+      if (failures === 1) wsRowsWarn("工作区标签注入失败,已降级(不影响侧栏):", why);
+      if (failures < WS_MAX_FAILURES) return;
+      givenUp = true;
+      stopWatching();
+      if (!wsRowsReadFlag(WS_ROWS_DISMISSED_KEY, false)) showToast(translate("givingUp"), true);
+    }
+
+    // ---- watchers -------------------------------------------------------
+    function ensureObserver() {
+      if (disposed || !enabled || givenUp) return;
+      if (typeof window.MutationObserver !== "function") return;
+      const root = container();
+      if (root === null) return;
+      if (observer !== null && observerRoot === root) return;
+      if (observer !== null) { try { observer.disconnect(); } catch { /* gone */ } observer = null; }
+      observer = new window.MutationObserver(onMutations);
+      observerRoot = root;
+      observer.observe(root, { childList: true, subtree: true });
+    }
+
+    function onMutations() {
+      if (disposed || !enabled || givenUp) return;
+      try {
+        if (painting) return;
+        // Ignore only the settle window right after our own paint. Anything later
+        // must reconcile, or a host re-render that took a badge leaves it gone.
+        if (Date.now() - paintedAt < WS_QUIET_MS) return;
+        if (container() === null) { scheduleRetry(); return; }
+        scheduleScan();
+      } catch (error) { noteFailure(error); }
+    }
+
+    function scheduleScan() {
+      if (disposed || !enabled || givenUp) return;
+      if (scanTimer !== 0) { try { window.clearTimeout(scanTimer); } catch { /* gone */ } }
+      scanTimer = window.setTimeout(() => { scanTimer = 0; paint(); }, WS_SCAN_DEBOUNCE);
+    }
+
+    function scheduleRetry() {
+      if (disposed || !enabled || givenUp) return;
+      if (retryTimer !== 0) return;
+      retryTimer = window.setInterval(attachContainer, 1000);
+    }
+
+    function attachContainer() {
+      if (disposed || !enabled || givenUp) return true;
+      const root = container();
+      if (root === null) return false;
+      ensureObserver();
+      paint();
+      if (observer !== null && retryTimer !== 0) { try { window.clearInterval(retryTimer); } catch { /* gone */ } retryTimer = 0; }
+      return true;
+    }
+
+    function startWatching() {
+      if (disposed || !enabled || givenUp) return;
+      ensureObserver();
+      if (container() !== null) paint();
+      else scheduleRetry();
+      // No MutationObserver in this build: the 1s retry is the only updater left.
+      if (observer === null && retryTimer === 0) scheduleRetry();
+    }
+
+    function stopWatching() {
+      if (observer !== null) { try { observer.disconnect(); } catch { /* gone */ } observer = null; }
+      observerRoot = null;
+      if (retryTimer !== 0) { try { window.clearInterval(retryTimer); } catch { /* gone */ } retryTimer = 0; }
+      if (scanTimer !== 0) { try { window.clearTimeout(scanTimer); } catch { /* gone */ } scanTimer = 0; }
+      painting = false;
+    }
+
+    // ---- preferences ----------------------------------------------------
+    function snapshot() {
+      return wsRowsNormalizeDoc(prefs);
+    }
+
+    function subscribePrefs(listener) {
+      if (typeof listener !== "function") return () => {};
+      prefListeners.add(listener);
+      return () => { prefListeners.delete(listener); };
+    }
+
+    function notifyPrefs() {
+      for (const listener of prefListeners) {
+        try { listener(snapshot()); } catch { /* a listener must not break the paint */ }
+      }
+    }
+
+    function commitPrefs(next) {
+      prefs = wsRowsNormalizeDoc(next);
+      localDirty = true;
+      wsRowsWriteLocalPrefs(prefs);
+      notifyPrefs();
+      paint();
+      scheduleSave();
+    }
+
+    function updateEntry(id, patch) {
+      if (disposed || !wsRowsValidId(id)) return null;
+      if (id === "__proto__" || id === "constructor" || id === "prototype") return null;
+      const base = prefs.workspaces[id] !== undefined ? prefs.workspaces[id] : wsRowsNormalizeEntry(null);
+      const next = {
+        tag: base.tag,
+        color: base.color,
+        pinned: base.pinned,
+        hidden: base.hidden,
+        pinAnchor: base.pinAnchor
+      };
+      const wasPinned = base.pinned === true;
+      let pinOn = false;
+      let restoreAnchor = null;
+      if (patch !== null && typeof patch === "object") {
+        if (Object.hasOwn(patch, "tag")) next.tag = wsRowsNormalizeTag(patch.tag);
+        if (Object.hasOwn(patch, "color")) next.color = wsRowsNormalizeColor(patch.color);
+        if (Object.hasOwn(patch, "pinned")) {
+          next.pinned = patch.pinned === true;
+          // Pin: remember who this workspace sat behind, then replay to the top.
+          // Unpin: restore behind that anchor and clear it (a missing anchor
+          // leaves the row where it is).
+          if (next.pinned === true && !wasPinned) {
+            pinOn = true;
+            next.pinAnchor = capturePinAnchor(id);
+          } else if (next.pinned !== true && wasPinned) {
+            restoreAnchor = base.pinAnchor;
+            next.pinAnchor = null;
+          }
+        }
+        if (Object.hasOwn(patch, "hidden")) next.hidden = patch.hidden === true;
+        if (Object.hasOwn(patch, "pinAnchor")) next.pinAnchor = typeof patch.pinAnchor === "string" ? patch.pinAnchor : null;
+      }
+      const entry = wsRowsNormalizeEntry(next);
+      const workspaces = Object.assign({}, prefs.workspaces);
+      if (wsRowsIsDefaultEntry(entry)) delete workspaces[id];
+      else workspaces[id] = entry;
+      commitPrefs({ version: 1, workspaces });
+      if (pinOn) requestPinReplay(0);
+      else if (restoreAnchor !== null) restorePinAnchor(id, restoreAnchor);
+      return entry;
+    }
+
+    // ---- pinning --------------------------------------------------------
+    /**
+     * Bind the Client Workspace service late and non-blockingly. A host
+     * without `workspaces` (or an older one whose ctx cannot inject) keeps
+     * tags, hiding and the preferences table exactly as they were.
+     */
+    function bindWorkspaceService() {
+      if (disposed) return;
+      const inject = ctx !== null && ctx !== undefined && typeof ctx.inject === "function" ? ctx.inject : null;
+      if (inject === null) return;
+      try {
+        inject(["workspaces"], (scope) => {
+          if (disposed) return;
+          let service = null;
+          try { service = scope !== null && scope !== undefined ? scope.workspaces : null; } catch { service = null; }
+          if (service === null || typeof service !== "object" || typeof service.insertBefore !== "function") return;
+          pinService = service;
+          try {
+            const source = service.list;
+            if (source !== null && source !== undefined && typeof source.subscribe === "function") {
+              pinUnsubscribe = source.subscribe(onWorkspaceListChanged);
+            }
+          } catch (error) { notePinWarn("订阅工作区列表失败:", error); }
+          schedulePinReplay(0);
+        });
+      } catch (error) {
+        notePinWarn("工作区置顶初始化失败(不影响标签和隐藏):", error);
+      }
+    }
+
+    function pinItems() {
+      try {
+        const source = pinService !== null && pinService !== undefined ? pinService.list : null;
+        if (source === null || source === undefined || typeof source.getSnapshot !== "function") return [];
+        const snapshot = source.getSnapshot();
+        return snapshot !== null && typeof snapshot === "object" && Array.isArray(snapshot.items) ? snapshot.items : [];
+      } catch { return []; }
+    }
+
+    function pinWorkspaceIds() {
+      const ids = [];
+      for (const item of pinItems()) {
+        if (item === null || typeof item !== "object") continue;
+        const id = typeof item.workspaceId === "string" && item.workspaceId !== ""
+          ? item.workspaceId
+          : (typeof item.id === "string" ? item.id : "");
+        if (wsRowsValidId(id) && ids.indexOf(id) < 0) ids.push(id);
+      }
+      return ids;
+    }
+
+    /** One warning per page: a missing service is a degradation, never an error. */
+    function notePinWarn(message, error) {
+      if (pinWarned) return;
+      pinWarned = true;
+      try { console.warn("dsh-lookout: " + message, error); } catch { /* no console */ }
+    }
+
+    /** One toast and one warning per page; a broken reorder must never repeat. */
+    function notePinFailure(error) {
+      pinFailures++;
+      if (pinFailures >= WS_PIN_MAX_FAILURES) pinSuspended = true;
+      else pinCooldownUntil = Date.now() + WS_PIN_RETRY_MS;
+      if (pinFailedOnce) return;
+      pinFailedOnce = true;
+      notePinWarn("工作区置顶失败(只提示一次):", error);
+      try { showToast(translate("pinFailed"), false); } catch { /* best effort */ }
+    }
+
+    function onWorkspaceListChanged() {
+      if (disposed) return;
+      // Our own moves change the list too: fold them into the running replay
+      // instead of starting another one.
+      if (pinRunning) { pinDirty = true; return; }
+      schedulePinReplay(WS_PIN_DEBOUNCE);
+    }
+
+    function schedulePinReplay(delay) {
+      if (disposed || pinService === null || pinSuspended) return;
+      if (pinTimer !== 0) return;
+      let wait = typeof delay === "number" && delay > 0 ? delay : 0;
+      const now = Date.now();
+      if (pinCooldownUntil > now) wait = Math.max(wait, pinCooldownUntil - now);
+      pinTimer = window.setTimeout(() => { pinTimer = 0; void pinNow(); }, wait);
+    }
+
+    /** An explicit user action clears the failure backoff and replays immediately. */
+    function requestPinReplay(delay) {
+      pinSuspended = false;
+      pinFailures = 0;
+      pinCooldownUntil = 0;
+      if (pinTimer !== 0) { try { window.clearTimeout(pinTimer); } catch { /* gone */ } pinTimer = 0; }
+      schedulePinReplay(delay);
+    }
+
+    /**
+     * Replay pinned workspaces to the front. Zero insertBefore calls when the
+     * order already fits; otherwise the smallest set of moves (one per pinned
+     * workspace that is not already in the correct prefix). Re-entry from our
+     * own moves is folded into pinDirty, and the identical-plan guard plus the
+     * round/move caps stop a host that accepts a move without performing it.
+     * @returns a promise settled when this replay finished.
+     */
+    function pinNow() {
+      if (disposed || pinSuspended) return Promise.resolve();
+      const service = pinService;
+      if (service === null || typeof service.insertBefore !== "function") return Promise.resolve();
+      if (pinRunning) { pinDirty = true; return Promise.resolve(); }
+      pinRunning = true;
+      pinDirty = false;
+      return (async () => {
+        let moves = 0;
+        let lastKey = null;
+        let stalled = false;
+        try {
+          for (let round = 0; round < WS_PIN_MAX_ROUNDS; round++) {
+            if (disposed) break;
+            const plan = wsPinPlan(prefs, pinItems());
+            if (plan === null) { pinDirty = false; break; }
+            if (plan.key === lastKey) { stalled = true; break; }
+            lastKey = plan.key;
+            pinDirty = false;
+            let stop = false;
+            for (const step of plan.steps) {
+              if (disposed || moves >= WS_PIN_MAX_MOVES) { stop = true; break; }
+              try {
+                await service.insertBefore(step.id, step.before);
+                moves++;
+              } catch (error) {
+                notePinFailure(error);
+                stop = true;
+                break;
+              }
+            }
+            if (stop) break;
+          }
+        } finally {
+          pinRunning = false;
+          const pending = pinDirty;
+          pinDirty = false;
+          if (pending && !stalled && !disposed) schedulePinReplay(WS_PIN_DEBOUNCE);
+        }
+      })();
+    }
+
+    /** The workspace right before this one at pin time; null when it was first. */
+    function capturePinAnchor(id) {
+      if (pinService === null) { notePinWarn(translate("pinUnavailable")); return null; }
+      const ids = pinWorkspaceIds();
+      const at = ids.indexOf(id);
+      return at > 0 ? ids[at - 1] : null;
+    }
+
+    /**
+     * Unpin restore: move the workspace back behind its recorded anchor. An
+     * anchor that is gone (or null) leaves the workspace where it is, so a
+     * deletion elsewhere never makes the list jump.
+     */
+    function restorePinAnchor(id, anchor) {
+      if (disposed || pinService === null || typeof anchor !== "string" || anchor === "") return;
+      const ids = pinWorkspaceIds();
+      if (ids.indexOf(id) < 0) return;
+      const at = ids.indexOf(anchor);
+      if (at < 0) return; // anchor gone: stay put (the caller already cleared it)
+      const before = at + 1 < ids.length ? ids[at + 1] : undefined;
+      if (before === id) return; // already right behind the anchor: zero calls
+      try {
+        const result = pinService.insertBefore(id, before);
+        if (result !== null && typeof result === "object" && typeof result.then === "function") {
+          result.catch((error) => notePinFailure(error));
+        }
+      } catch (error) { notePinFailure(error); }
+    }
+
+    function cleanupMissing(ids) {
+      if (disposed) return 0;
+      const list = Array.isArray(ids) ? ids : [];
+      const known = new Set();
+      for (const id of list) if (wsRowsValidId(id)) known.add(id);
+      // Without a live list the button must not wipe every preference.
+      if (known.size === 0) return 0;
+      const workspaces = {};
+      let removed = 0;
+      for (const [id, entry] of Object.entries(prefs.workspaces)) {
+        if (known.has(id)) workspaces[id] = entry;
+        else removed++;
+      }
+      if (removed === 0) return 0;
+      commitPrefs({ version: 1, workspaces });
+      return removed;
+    }
+
+    function rpcFace() {
+      try {
+        if (ctx === null || ctx === undefined) return null;
+        let connection = ctx.connection;
+        if (connection === null || connection === undefined) {
+          connection = typeof ctx.get === "function" ? ctx.get("connection") : null;
+        }
+        const face = connection !== null && connection !== undefined ? connection.rpc : null;
+        return face !== null && face !== undefined && typeof face.call === "function" ? face : null;
+      } catch { return null; }
+    }
+
+    /** Startup pull: adopt the Host document, or keep the local mirror when RPC is unavailable. */
+    function loadFromHost() {
+      if (disposed) return;
+      const face = rpcFace();
+      if (face === null) return;
+      try {
+        face.call("/api", "iconCustom/getWorkspacePrefs", { args: {} }).then((response) => {
+          if (disposed) return;
+          if (response === null || typeof response !== "object" || response.ok !== true) return;
+          // A local edit that happened while the pull was in flight wins; push it.
+          if (localDirty) { scheduleSave(); return; }
+          prefs = wsRowsNormalizeDoc(response.value);
+          wsRowsWriteLocalPrefs(prefs);
+          notifyPrefs();
+          paint();
+        }).catch(() => { /* keep the local mirror */ });
+      } catch { /* keep the local mirror */ }
+    }
+
+    function scheduleSave() {
+      if (disposed) return;
+      if (saveTimer !== 0) { try { window.clearTimeout(saveTimer); } catch { /* gone */ } }
+      saveTimer = window.setTimeout(saveNow, WS_SAVE_DEBOUNCE);
+    }
+
+    function saveNow() {
+      saveTimer = 0;
+      if (disposed) return;
+      const face = rpcFace();
+      // No RPC: the localStorage mirror is the documented fallback, not an error.
+      if (face === null) return;
+      const request = snapshot();
+      try {
+        face.call("/api", "iconCustom/setWorkspacePrefs", { args: { request } }).then((response) => {
+          if (disposed) return;
+          if (response === null || typeof response !== "object" || response.ok !== true) { noteSaveFailure(response); return; }
+          localDirty = false;
+        }).catch(noteSaveFailure);
+      } catch (error) { noteSaveFailure(error); }
+    }
+
+    /** Saved once per page: a broken Host must not turn every keystroke into a toast. */
+    function noteSaveFailure(why) {
+      if (saveFailedOnce) return;
+      saveFailedOnce = true;
+      try { console.warn("dsh-lookout: 工作区偏好保存失败(只提示一次):", why); } catch { /* no console */ }
+      showToast(translate("saveFailed"), false);
+    }
+
+    // ---- switch ---------------------------------------------------------
+    function setEnabled(next) {
+      const on = next === true;
+      enabled = on;
+      wsRowsWriteFlag(WS_ROWS_ENABLED_KEY, on);
+      if (disposed) return;
+      if (!on) {
+        stopWatching();
+        hideToast();
+        removeBadges();
+        const style = ensureHideStyleTag();
+        if (style !== null && style !== undefined) { try { style.textContent = ""; } catch { /* gone */ } }
+        return;
+      }
+      givenUp = false;
+      failures = 0;
+      hideToast();
+      startWatching();
+      requestPinReplay(0);
+    }
+
+    function removeBadges() {
+      try { document.querySelectorAll("[" + WS_TAG_ATTR + "]").forEach((node) => { try { node.remove(); } catch { /* gone */ } }); } catch { /* gone */ }
+    }
+
+    // ---- toast ----------------------------------------------------------
+    function showToast(message, dismissable) {
+      if (disposed) return;
+      if (document.body === null || document.body === undefined) return;
+      hideToast();
+      const box = document.createElement("div");
+      box.className = "dsh-lookout-ws-toast";
+      box.setAttribute(WS_TOAST_ATTR, "");
+      box.setAttribute("role", "status");
+      box.setAttribute("aria-live", "polite");
+      const text = document.createElement("span");
+      text.className = "dsh-lookout-ws-toast-text";
+      text.textContent = message;
+      box.appendChild(text);
+      if (dismissable === true) {
+        const dismiss = document.createElement("button");
+        dismiss.type = "button";
+        dismiss.textContent = translate("dismiss");
+        dismiss.addEventListener("click", (event) => {
+          event.preventDefault();
+          event.stopPropagation();
+          wsRowsWriteFlag(WS_ROWS_DISMISSED_KEY, true);
+          hideToast();
+        });
+        box.appendChild(dismiss);
+      }
+      document.body.appendChild(box);
+      toast = box;
+      paintedAt = Date.now();
+      toastTimer = window.setTimeout(hideToast, WS_TOAST_MS);
+    }
+
+    function hideToast() {
+      if (toastTimer !== 0) { try { window.clearTimeout(toastTimer); } catch { /* gone */ } toastTimer = 0; }
+      if (toast !== null) { try { toast.remove(); } catch { /* gone */ } toast = null; }
+    }
+
+    // ---- lifecycle ------------------------------------------------------
+    function dispose() {
+      if (disposed) return;
+      disposed = true;
+      try { stopWatching(); } catch { /* best effort */ }
+      try { hideToast(); } catch { /* best effort */ }
+      try { removeBadges(); } catch { /* best effort */ }
+      if (saveTimer !== 0) { try { window.clearTimeout(saveTimer); } catch { /* gone */ } saveTimer = 0; }
+      if (pinTimer !== 0) { try { window.clearTimeout(pinTimer); } catch { /* gone */ } pinTimer = 0; }
+      if (pinUnsubscribe !== null) { try { pinUnsubscribe(); } catch { /* gone */ } pinUnsubscribe = null; }
+      pinService = null;
+      try {
+        document.querySelectorAll('style[data-plugin-css="' + WS_STYLE_KEY + '"],style[data-plugin-css="' + WS_HIDE_STYLE_KEY + '"]').forEach((node) => {
+          try { node.remove(); } catch { /* gone */ }
+        });
+      } catch { /* best effort */ }
+      prefListeners.clear();
+    }
+
+    ensureStaticStyle();
+    bindWorkspaceService();
+    startWatching();
+    loadFromHost();
+
+    return {
+      dispose,
+      snapshot,
+      subscribe: subscribePrefs,
+      updateEntry,
+      cleanupMissing,
+      paintNow: paint,
+      pinNow,
+      domWorkspaceIds,
+      setEnabled,
+      isEnabled: () => enabled === true
+    };
+  }
+  //#endregion
+
+  //#region session id in the sidebar hover card
+  /**
+   * The session id, printed inside the sidebar's session hover card.
+   *
+   * Why a slot instead of DOM patching: ui-workspace renders
+   * `renderSlot("sidebar.session.row.hover", { sessionId })` between the card's
+   * time line and its status lines, so this is a documented seat. No host markup
+   * is read or written, and a host upgrade that moves the card carries our line
+   * with it.
+   *
+   * The header badge of the byte-locked dsh-session-info part cannot be edited,
+   * so "move" is delivered as CSS: while this line is ON, that badge is hidden,
+   * which puts the id in exactly one place. Turning the switch OFF restores the
+   * header and drops the card line — i.e. the shipped behaviour, untouched.
+   */
+  const HOVER_SLOT = "sidebar.session.row.hover";
+  /** Own locale namespace: locale.register THROWS on a duplicate namespace. */
+  const HOVER_NS = "dsh-lookout-session-id";
+  /** localStorage switch; absent or unreadable means ON. */
+  const HOVER_ENABLED_KEY = "dsh-lookout:session-id:hover";
+  const HOVER_STYLE_KEY = "lookout-session-id-hover";
+  const HOVER_HIDE_STYLE_KEY = "lookout-session-id-hide";
+  const HOVER_LINE_CLASS = "dsh-lookout-session-id-hover";
+  const HOVER_TOAST_CLASS = "dsh-lookout-session-id-hover-toast";
+  const HOVER_TOAST_ATTR = "data-lookout-session-id-toast";
+  const HOVER_TOAST_MS = 2000;
+  /** The bundled part's own badge class, hidden while the card carries the id. */
+  const HOVER_HEADER_SELECTOR = ".dsh-session-info";
+
+  const HOVER_ZH = {
+    nav: "会话 ID",
+    toggleLabel: "在会话悬停卡片里显示会话 ID（顶部不再重复显示）",
+    toggleHint: "侧栏里鼠标停在某个会话上，弹出的卡片里会多一行等宽字：这个会话的完整 ID（session-…），点一下即可复制。开启时顶部那串会话 ID 会隐藏，避免同一个 ID 显示两处；关掉即恢复原样。",
+    copied: "已复制会话 ID",
+    copyFailed: "复制失败，请手动选择会话 ID 复制",
+    copyHint: "点击复制完整会话 ID",
+    ariaLabel: "复制完整会话 ID"
+  };
+  const HOVER_EN = {
+    nav: "Session ID",
+    toggleLabel: "Show the session ID in the session hover card (hidden in the header)",
+    toggleHint: "Hovering a session in the sidebar opens a card; this adds one monospace line with the session's full ID (session-…), and one click copies it. While this is on, the header stops showing the same id so it appears in exactly one place; turning it off restores the shipped behaviour.",
+    copied: "Session ID copied",
+    copyFailed: "Copy failed — select the session ID and copy it manually",
+    copyHint: "Click to copy the full session ID",
+    ariaLabel: "Copy the full session ID"
+  };
+
+  const HOVER_CSS = [
+    // One quiet line under the card's time, in the same voice as its status rows.
+    "." + HOVER_LINE_CLASS + "{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:11px;line-height:1.5;color:var(--dsw-alias-label-tertiary,#8b8b8b);opacity:.85;word-break:break-all;cursor:copy;user-select:text;}",
+    "." + HOVER_LINE_CLASS + ":hover,." + HOVER_LINE_CLASS + ":focus-visible{opacity:1;text-decoration:underline;outline:none;}",
+    "." + HOVER_TOAST_CLASS + "{position:fixed;left:50%;bottom:24px;z-index:2147482100;max-width:min(92vw,560px);padding:9px 12px;transform:translateX(-50%);border:1px solid var(--dsw-alias-border-l2,#444);border-radius:10px;background:var(--dsw-alias-bg-overlay,#222);color:var(--dsw-alias-label-primary,#fff);font-family:-apple-system,BlinkMacSystemFont,\"Segoe UI\",Roboto,\"Helvetica Neue\",Arial,sans-serif;font-size:12px;line-height:1.5;box-shadow:0 8px 24px var(--dsw-alias-bg-mask-drop,rgba(0,0,0,.25));}",
+    "." + HOVER_TOAST_CLASS + "[data-lookout-session-id-failed]{color:var(--dsw-alias-state-error-primary,#ff6b6b);}"
+  ].join("\n");
+
+  /** Chinese fallback for every translate call, used when locale is unavailable. */
+  function hoverFallbackText(key, params) {
+    const template = typeof HOVER_ZH[key] === "string" ? HOVER_ZH[key] : key;
+    if (params === null || params === undefined || typeof params !== "object") return template;
+    let text = template;
+    for (const name of Object.keys(params)) text = text.split("{" + name + "}").join(String(params[name]));
+    return text;
+  }
+
+  /** Whether the card line is wanted; storage that throws counts as ON. */
+  function hoverReadFlag() {
+    try {
+      const raw = window.localStorage.getItem(HOVER_ENABLED_KEY);
+      if (raw === "1") return true;
+      if (raw === "0") return false;
+      return true;
+    } catch { return true; }
+  }
+
+  /** Persist the switch; a storage failure only costs durability. */
+  function hoverWriteFlag(value) {
+    try { window.localStorage.setItem(HOVER_ENABLED_KEY, value ? "1" : "0"); } catch { /* advisory */ }
+  }
+
+  /** One warning per page at most, and only for a real degradation. */
+  let hoverWarned = false;
+  function hoverWarn(message, error) {
+    if (hoverWarned) return;
+    hoverWarned = true;
+    try { console.warn("dsh-lookout: " + message, error); } catch { /* no console */ }
+  }
+
+  /**
+   * Mount the card line, its settings switch and the header-hiding stylesheet.
+   * Swallows everything: a UI seat may never throw into the host apply().
+   * @param ctx - the merged plugin client context.
+   * @param require - the ModuleLoader require (React lives behind it).
+   * @returns {void}
+   */
+  function sessionIdHoverStart(ctx, require) {
+    try {
+      sessionIdHoverInstall(ctx, require);
+    } catch (error) {
+      hoverWarn("会话 ID 悬停卡片初始化失败,已跳过(不影响宿主):", error);
+    }
+  }
+
+  /**
+   * Install the seat and return its teardown.
+   * @param ctx - the merged plugin client context.
+   * @param require - the ModuleLoader require.
+   * @returns {() => void} disposer.
+   */
+  function sessionIdHoverInstall(ctx, require) {
+    let disposed = false;
+    let enabled = hoverReadFlag();
+    let translate = hoverFallbackText;
+    let toast = null;
+    let toastTimer = 0;
+    const toggleListeners = new Set();
+    const React = require("react");
+
+    /** Every card line and settings switch reads this, so one switch moves both. */
+    function notifyToggle() {
+      for (const listener of Array.from(toggleListeners)) { try { listener(enabled); } catch { /* gone */ } }
+    }
+
+    function subscribeToggle(listener) {
+      if (typeof listener !== "function") return () => {};
+      toggleListeners.add(listener);
+      return () => { toggleListeners.delete(listener); };
+    }
+
+    // ---- locale ---------------------------------------------------------
+    try {
+      const locale = ctx !== null && ctx !== undefined ? ctx.locale : null;
+      if (locale !== null && locale !== undefined && typeof locale.register === "function") {
+        const register = () => locale.register(HOVER_NS, { zh: HOVER_ZH, en: HOVER_EN });
+        if (typeof ctx.effect === "function") ctx.effect(register, "dsh-lookout: session id dictionaries");
+        else register();
+      }
+      if (locale !== null && locale !== undefined && typeof locale.bind === "function") {
+        const bound = locale.bind(HOVER_NS);
+        translate = (key, params) => {
+          let text = key;
+          try { text = bound(key, params); } catch { text = key; }
+          return typeof text === "string" && text !== key ? text : hoverFallbackText(key, params);
+        };
+      }
+    } catch (error) { /* the Chinese fallback is already in translate */ }
+
+    // ---- styles ---------------------------------------------------------
+    function ensureStyleTag(key, css) {
+      try {
+        const existing = document.querySelector('style[data-plugin-css="' + key + '"]');
+        if (existing !== null && existing !== undefined) {
+          if (typeof css === "string" && existing.textContent !== css) { try { existing.textContent = css; } catch { /* gone */ } }
+          return existing;
+        }
+        const tag = document.createElement("style");
+        tag.setAttribute("data-plugin", "dsh-lookout");
+        tag.setAttribute("data-plugin-css", key);
+        tag.textContent = typeof css === "string" ? css : "";
+        const head = document.head !== null && document.head !== undefined ? document.head : document.body;
+        if (head !== null && head !== undefined) head.appendChild(tag);
+        return tag;
+      } catch { return null; }
+    }
+
+    /**
+     * Hide the shipped header badge while the card carries the id.
+     *
+     * The badge lives in a byte-locked part, so it cannot be removed from the
+     * bundle; hiding it with one scoped rule is the reversible half of "move".
+     */
+    function syncHeaderBadge() {
+      if (disposed) return;
+      if (enabled) { ensureStyleTag(HOVER_HIDE_STYLE_KEY, HOVER_HEADER_SELECTOR + "{display:none !important;}"); return; }
+      try {
+        document.querySelectorAll('style[data-plugin-css="' + HOVER_HIDE_STYLE_KEY + '"]').forEach((node) => {
+          try { node.remove(); } catch { /* gone */ }
+        });
+      } catch { /* best effort */ }
+    }
+
+    // ---- toast + clipboard ----------------------------------------------
+    function hideToast() {
+      if (toastTimer !== 0) { try { window.clearTimeout(toastTimer); } catch { /* gone */ } toastTimer = 0; }
+      if (toast !== null) { try { toast.remove(); } catch { /* gone */ } toast = null; }
+    }
+
+    function showToast(message, ok) {
+      if (disposed) return;
+      if (document.body === null || document.body === undefined) return;
+      hideToast();
+      const box = document.createElement("div");
+      box.className = HOVER_TOAST_CLASS;
+      box.setAttribute(HOVER_TOAST_ATTR, "");
+      if (ok !== true) box.setAttribute("data-lookout-session-id-failed", "");
+      box.setAttribute("role", "status");
+      box.setAttribute("aria-live", "polite");
+      box.textContent = message;
+      document.body.appendChild(box);
+      toast = box;
+      toastTimer = window.setTimeout(hideToast, HOVER_TOAST_MS);
+    }
+
+    async function writeClipboard(text) {
+      try {
+        const primitives = require("@deepseek-ai/dsh-client-ui-primitives");
+        if (primitives !== null && primitives !== undefined && typeof primitives.writeClipboard === "function") {
+          const result = await primitives.writeClipboard(text);
+          if (result !== false) return true;
+        }
+      } catch { /* fall through to the browser API */ }
+      try {
+        if (typeof navigator !== "undefined" && navigator.clipboard !== null && navigator.clipboard !== undefined && typeof navigator.clipboard.writeText === "function") {
+          await navigator.clipboard.writeText(text);
+          return true;
+        }
+      } catch { /* fall through to the textarea */ }
+      try {
+        const area = document.createElement("textarea");
+        area.value = text;
+        area.setAttribute("readonly", "");
+        area.style.position = "fixed";
+        area.style.top = "0";
+        area.style.left = "-9999px";
+        area.style.opacity = "0";
+        document.body.appendChild(area);
+        try { area.focus(); area.select(); } catch { /* focus is advisory */ }
+        const copied = typeof document.execCommand === "function" && document.execCommand("copy") === true;
+        try { area.remove(); } catch { /* gone */ }
+        return copied;
+      } catch { return false; }
+    }
+
+    async function copyId(id) {
+      let copied = false;
+      try { copied = await writeClipboard(id); } catch { copied = false; }
+      if (disposed) return;
+      showToast(copied ? translate("copied") : translate("copyFailed"), copied === true);
+      return copied;
+    }
+
+    // ---- the card line ---------------------------------------------------
+    /**
+     * One card line: the full session id, click or Enter/Space to copy it.
+     *
+     * A `div[role=button]` rather than a `button`: the card is a passive panel
+     * and the row it describes owns the click that opens the session, so this
+     * line must stay a leaf that steals only its own events.
+     */
+    function SessionIdHoverLine(props) {
+      const [on, setOn] = React.useState(() => enabled);
+      React.useEffect(() => subscribeToggle(setOn), []);
+      const id = props !== null && props !== undefined && typeof props.sessionId === "string" ? props.sessionId : "";
+      if (on !== true || id === "") return null;
+      const label = props !== null && props !== undefined && typeof props.t === "function" ? props.t : translate;
+      const activate = (event) => {
+        if (event !== null && event !== undefined) {
+          if (typeof event.preventDefault === "function") event.preventDefault();
+          if (typeof event.stopPropagation === "function") event.stopPropagation();
+        }
+        void copyId(id);
+      };
+      const onKeyDown = (event) => {
+        if (event === null || event === undefined) return;
+        if (event.key !== "Enter" && event.key !== " " && event.key !== "Spacebar") return;
+        activate(event);
+      };
+      return React.createElement("div", {
+        className: HOVER_LINE_CLASS,
+        role: "button",
+        tabIndex: 0,
+        title: label("copyHint"),
+        "aria-label": label("ariaLabel"),
+        "data-lookout-session-id": id,
+        onClick: activate,
+        onKeyDown
+      }, id);
+    }
+
+    // ---- settings --------------------------------------------------------
+    function SessionIdHoverSection(props) {
+      const label = props !== null && props !== undefined && typeof props.t === "function" ? props.t : translate;
+      const [checked, setChecked] = React.useState(() => hoverReadFlag());
+      React.useEffect(() => subscribeToggle(setChecked), []);
+      const onChange = (event) => {
+        const next = event.target.checked === true;
+        setChecked(next);
+        setEnabled(next);
+      };
+      return React.createElement("div", { "data-lookout-settings": "session-id" },
+        React.createElement("div", { style: { fontSize: 13, fontWeight: 600, color: "var(--dsw-alias-label-primary)", marginBottom: 8 } }, label("nav")),
+        React.createElement("label", { style: { display: "inline-flex", alignItems: "center", gap: 6, fontSize: 12, color: "var(--dsw-alias-label-primary)", cursor: "pointer" } },
+          React.createElement("input", { type: "checkbox", checked, onChange }),
+          React.createElement("span", null, label("toggleLabel"))
+        ),
+        React.createElement("div", { style: { marginTop: 6, fontSize: 12, lineHeight: 1.6, color: "var(--dsw-alias-label-tertiary)" } }, label("toggleHint"))
+      );
+    }
+
+    /** Flip the line and the header rule together, then persist. */
+    function setEnabled(next) {
+      enabled = next === true;
+      hoverWriteFlag(enabled);
+      syncHeaderBadge();
+      if (!enabled) hideToast();
+      notifyToggle();
+    }
+
+    // ---- wiring ----------------------------------------------------------
+    ensureStyleTag(HOVER_STYLE_KEY, HOVER_CSS);
+    syncHeaderBadge();
+
+    try {
+      const slots = ctx !== null && ctx !== undefined ? ctx.slots : null;
+      if (slots !== null && slots !== undefined && typeof slots.inject === "function" && typeof slots.register === "function") {
+        // Order 1: above the scheduled-task section (order 10) and the status
+        // lines, directly under the card's time — the id reads as part of the
+        // card's own header, not as one more status.
+        slots.inject(HOVER_SLOT, () => slots.register({
+          name: HOVER_SLOT,
+          id: "lookout-session-id",
+          order: 1,
+          locale: HOVER_NS,
+          inject: () => ({ t: translate })
+        }, SessionIdHoverLine));
+        slots.inject("settings.section", () => slots.register({
+          name: "settings.section",
+          id: "lookout-session-id",
+          order: 57,
+          label: () => translate("nav"),
+          locale: HOVER_NS,
+          inject: () => ({ t: translate })
+        }, SessionIdHoverSection));
+      }
+    } catch (error) {
+      hoverWarn("会话 ID 插槽注册失败,已跳过(不影响宿主):", error);
+    }
+
+    function dispose() {
+      if (disposed) return;
+      disposed = true;
+      hideToast();
+      toggleListeners.clear();
+      try {
+        document.querySelectorAll('style[data-plugin-css="' + HOVER_STYLE_KEY + '"],style[data-plugin-css="' + HOVER_HIDE_STYLE_KEY + '"]').forEach((node) => { try { node.remove(); } catch { /* gone */ } });
+      } catch { /* best effort */ }
+    }
+
+    if (ctx !== null && ctx !== undefined && typeof ctx.effect === "function") {
+      try { ctx.effect(() => dispose, "dsh-lookout: session id in hover card"); } catch { /* best effort */ }
+    }
+    return dispose;
+  }
+  //#endregion
+
+
   window.__ModuleLoader__.load({
     id: "dsh-lookout",
     factory: (require) => {
@@ -8184,6 +9931,12 @@ window.__ModuleLoader__.load({
           // starts first and owns its own try/catch: a fault in any part (or a
           // missing files panel) only costs this feature, never the host.
           rowMenuStart(ctx, require);
+          // Workspace tags + hiding are independent of the three bundled parts for
+          // the same reason, and own their own try/catch inside wsRowsStart.
+          wsRowsStart(ctx, require);
+          // The session id in the sidebar's hover card rides an official slot
+          // (sidebar.session.row.hover), so it owns its own try/catch too.
+          sessionIdHoverStart(ctx, require);
           for (const m of __mods) { if (m && typeof m.apply === "function") m.apply(ctx); }
         },
       };