@cowwo/dsh-lookout 0.2.0 → 0.5.1

package/client/client.js

@@ -5039,13 +5039,24 @@ window.__ModuleLoader__.load({
 //
 // 这一页只回答两个问题：
 //   1. 配好了吗   → 分组状态点（已配置 / 未配置 / 不适用）
-//   2. 能发出去吗 → 顶部状态条 + 发送测试邮件 + 最近一次投递结果
+//   2. 能发出去吗 → 顶部状态条 + 发送测试邮件（点了当场回执成败与原始报错）
 // 其余一切让路：不额外套卡片、不加编号、不做中英同屏。
 //
-// 编辑模型：**没有保存/放弃按钮，改完即时生效**。按字段类型区别对待：
-//   - 开关 / 下拉 / 分段：立刻写
-//   - 数字 / 文本：防抖（停手再写）+ 失焦兜底
-//   - 密码：只在失焦或回车时写，且**每个凭据引用名各写各的**
+// 信息架构（ui18 = 零折叠骨架）：
+//   内容列 max-width 760 居中；页头**吸顶**（标题 18/26·600 + 说明 13/20 + 右侧脏读数/保存/放弃改动）；
+//   判决条 = 状态色 hero（bg-module-platform + 左侧 3px 状态色 + 18/26·600 标题 + 14/22 结论句
+//     + 12/18 人话摘要 + 主按钮在右下）；
+//   下面三张卡片：收件人 / 发信方式 / 通知时机（14/22·500 卡片标题 + 12/18 状态读数）；
+//   **全页零折叠**：没有「▸ 更多」、没有「还有 3 种情况」、没有问号按钮——
+//     端口 / 加密 / 主机 / 用户名宽屏一行四列（≤560px 两行两列）；
+//     8 个事件开关三列网格（窄屏一列、不分组），说明常显在格子下方（一行 12/18）；
+//     通知时机第一行是总开关（关闭后 8 个事件开关变灰禁用但不隐藏）；吸底条常驻「放弃 + 保存」。
+//   字号阶梯全部落在宿主网格上（只用整像素档，不再有半档字号）；圆角只用 4/8/12/16/20/28。
+//
+// 编辑模型：**显式保存**。所有控件只改本地草稿，点「保存」才一次性写回：
+//   - 配置字段：与基线不同的项合成一次 mutate(found.ns, ops, revision)
+//   - 授权码：草稿只活在内存里，保存成功时才写凭据库（写入目标由那一行决定）
+//   - 「放弃改动」把草稿整体回滚到基线；「恢复全部默认」不受保存按钮约束，立即生效
 //
 // 六条硬约束（前三条踩过，后三条是本轮修掉的）：
 //   1. 注册页面只依赖 `slots`。远程命名空间 / locale 各开一个非阻塞的 ctx.inject 去填；
@@ -5077,33 +5088,35 @@ 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.draft': '有未保存的授权码',
       'cred.replace': '更换',
       'cred.clear': '清除',
       'cred.placeholder': '粘贴授权码',
       'err.auth': '服务端拒绝了这组账号密码',
       'err.authHint': '多半是授权码不对或过期了：QQ 邮箱要的是「授权码」而不是登录密码，重新生成一个再填。',
       'err.rejected': '发件人被拒',
-      'err.rejectedHint': '收件服务器不接受这个发件人。换个发件地址（一般在「发件人与链接」里）再试。',
+      'err.rejectedHint': '收件服务器不接受这个发件人。发件地址由插件按服务端设置决定，确认这个邮箱被允许用来发信后再试。',
       'err.network': '连不上服务器',
       'err.networkHint': '检查主机名与端口；本机防火墙或公司网络也可能挡住 465 / 587。',
       'err.other': '发送失败',
@@ -5112,31 +5125,50 @@ 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.savedMin': '已保存 · {n} 分钟前',
+      'save.savedHour': '已保存 · {n} 小时前',
+      'save.savedDay': '已保存 · {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}',
 
+      // 判决条只按已保存的配置判定，四档会给四句不同的话（总开关关 > 事件全关 > 缺配置 > 可以发）。
       'status.disabled': '已关闭，不会发任何通知',
+      'status.allOff': '通知已全部关闭',
       'status.needRecipients': '还差一个收件人',
       'status.needHost': '还差 SMTP 服务器地址',
       'status.needUser': '还差 SMTP 用户名',
       'status.needCredential': '还差{cred}',
       'status.ready': '可以发信了',
-      'status.lastFailed': '上次发信失败',
       'status.notServed': '这一页读不到本插件的配置',
 
       // 判决下面那句人话。只说用户的事，不说实现的事。
       'status.why.disabled': '打开下面任意一种情况，才会开始通知你。',
+      'status.why.allOff': '至少打开一个事件才会收到邮件。',
       'status.why.needRecipients': '没有收件邮箱，邮件没有地方可去。',
       'status.why.needHost': '还没填服务器地址。',
       'status.why.needUser': '多数邮箱要求用户名和授权码成对出现。',
       'status.why.needCredential': '没填它，服务端会拒收这封信。',
       'status.why.ready': '配置齐了。发一封测试邮件，确认服务端真的收下。',
-      'status.why.lastFailed': '配置看着没问题，但上一次没发出去。',
+      // 判决条只按已保存的配置判定，这句把口径说透，免得"我明明填好了"变成困惑。
+      'status.unsavedDraft': '未保存的改动不参与判定。',
 
       'act.enable': '启用',
       'act.goFill': '去填写',
@@ -5144,15 +5176,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': '高级',
-
+      'group.transport': '发信方式',
+      'group.outcomes': '通知时机',
 
       'recipients.label': '收件邮箱',
       'recipients.placeholder': 'you@qq.com',
@@ -5161,12 +5193,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': '还没配好',
 
@@ -5176,6 +5202,10 @@ window.__ModuleLoader__.load({
       'preset.other': '其他',
       'preset.detected': '已按「{name}」填好',
 
+      // 通知时机第一行：总开关。关掉之后 8 个事件开关变灰禁用（但不隐藏）。
+      'notify.master': '邮件通知',
+      'notify.masterHint': '关闭后不再发送任何邮件',
+
       'smtp.host': 'SMTP 主机',
       'smtp.port': '端口',
       'smtp.secure': '加密',
@@ -5183,76 +5213,54 @@ 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：账户 → 安全性 → 高级安全选项 → 应用密码。',
       'cred.helpClose': '知道了',
-      'cred.clear': '清除',
 
+      // 8 个事件：标题是名词短语，说明压到一行（≤16 个中文字），常显在格子下方。
       'outcomes.completed': '任务完成',
-      'outcomes.completedHint': '会话正常干完一件活。',
+      'outcomes.completedHint': '正常跑完时',
       'outcomes.error': '任务出错',
-      'outcomes.errorHint': '会话报错终止。',
-      'outcomes.blocked': '卡住，需要你介入',
-      'outcomes.blockedHint': 'agent 需要你补充信息才能继续。',
+      'outcomes.errorHint': '报错终止时',
+      'outcomes.blocked': '卡住',
+      'outcomes.blockedHint': '等你补充信息时',
       'outcomes.approval': '等你审批',
-      'outcomes.approvalHint': '立即发送，不参与合并窗口。',
-      'outcomes.more': '还有 3 种情况（默认关）',
-      'outcomes.countOn': '{n} 项开启',
-      'outcomes.countOff': '全部关闭，不会通知你',
+      'outcomes.approvalHint': '等你点审批时',
+      'outcomes.subagents': '也通知子代理',
+      'outcomes.subagentsHint': '子代理也通知',
       'outcomes.aborted': '你主动停止',
-      'outcomes.abortedHint': '只包含你自己按停止的那次。',
+      'outcomes.abortedHint': '你按了停止',
       'outcomes.interrupted': '系统中断',
-      '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': '封/分钟',
+      'outcomes.interruptedHint': '系统中断时',
+      'outcomes.maxTokens': '长度上限',
+      'outcomes.maxTokensHint': '达到上限时',
+      'outcomes.countOn': '{n} 项开启',
+      'outcomes.countOff': '全部关闭',
+
+      // 判决条第三行的「人话摘要」用短名，一句话最多列两个事件。
+      'short.completed': '跑完',
+      'short.error': '出错',
+      'short.blocked': '卡住',
+      'short.approval': '等审批',
+      'short.subagents': '子代理',
+      'short.aborted': '停止',
+      'short.interrupted': '中断',
+      'short.maxTokens': '长度上限',
+
+      'summary.line': '{provider} · {host} → {to} · {events}',
+      'summary.noHost': '还没填主机',
+      'summary.noRecipient': '还没填收件人',
+      'summary.recipients': '{n} 位收件人',
+      'summary.custom': '自定义',
+      'summary.events': '{list}时通知',
+      'summary.eventsMore': '{list} 等 {n} 项时通知',
+      'summary.eventsOff': '通知已关闭',
 
       'danger.reset': '恢复全部默认',
       'danger.title': '恢复全部默认？',
-      'danger.body': '这会清掉本插件在 settings.yaml 里的全部覆盖（收件人、事件开关、节奏参数都会回到默认）。',
+      'danger.body': '这会清掉本插件在 profile 里的全部覆盖（收件人、事件开关、节奏参数都会回到默认），并立即生效——它不受「保存」按钮约束，这一页还没保存的草稿也会一起丢掉。',
       'danger.keep': '凭据库里已存的授权码不受影响。',
       'danger.ok': '恢复默认',
       'danger.cancel': '取消',
@@ -5260,19 +5268,19 @@ 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.draft': 'An unsaved authorization code',
       'cred.replace': 'Replace',
       'cred.clear': 'Clear',
       'cred.placeholder': 'Paste the authorization code',
       '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,30 +5289,44 @@ 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.savedMin': 'Saved · {n} min ago',
+      'save.savedHour': 'Saved · {n} h ago',
+      'save.savedDay': 'Saved · {n} d 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}',
 
       'status.disabled': 'Off — no notifications will be sent',
+      'status.allOff': 'All notifications are off',
       'status.needRecipients': 'One recipient missing',
       'status.needHost': 'SMTP host missing',
       '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.',
+      'status.why.allOff': 'Turn on at least one event to get an email.',
       'status.why.needRecipients': 'Without a recipient address there is nowhere for the mail to go.',
       'status.why.needHost': 'No server address is set.',
       '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 +5334,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',
-
+      'group.transport': 'Sending method',
+      'group.outcomes': 'When to notify',
 
       'recipients.label': 'Recipient addresses',
       'recipients.placeholder': 'you@qq.com, one per line',
@@ -5329,12 +5350,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',
 
@@ -5344,6 +5359,9 @@ window.__ModuleLoader__.load({
       'preset.other': 'Other',
       'preset.detected': 'Filled in for “{name}”',
 
+      'notify.master': 'Email notifications',
+      'notify.masterHint': 'When off, no email is sent at all',
+
       'smtp.host': 'SMTP host',
       'smtp.port': 'Port',
       'smtp.secure': 'Security',
@@ -5351,76 +5369,52 @@ 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.',
       'cred.helpClose': 'Got it',
-      'cred.clear': 'Clear',
 
       'outcomes.completed': 'Task completed',
-      'outcomes.completedHint': 'A session finished its work normally.',
+      'outcomes.completedHint': 'Finished normally',
       'outcomes.error': 'Task failed',
-      'outcomes.errorHint': 'A session ended with an error.',
-      'outcomes.blocked': 'Stuck — needs you',
-      'outcomes.blockedHint': 'The agent needs more from you to continue.',
+      'outcomes.errorHint': 'Ended with an error',
+      'outcomes.blocked': 'Stuck',
+      'outcomes.blockedHint': 'Needs your input',
       'outcomes.approval': 'Waiting for your approval',
-      'outcomes.approvalHint': 'Sent immediately, outside the coalesce window.',
-      'outcomes.more': '3 more cases (off by default)',
-      'outcomes.countOn': '{n} on',
-      'outcomes.countOff': 'All off — you will not be notified',
+      'outcomes.approvalHint': 'Waits for your approval',
+      'outcomes.subagents': 'Subagents too',
+      'outcomes.subagentsHint': 'Subagents too',
       'outcomes.aborted': 'You stopped it',
-      'outcomes.abortedHint': 'Only when you pressed stop yourself.',
+      'outcomes.abortedHint': 'You pressed stop',
       'outcomes.interrupted': 'Interrupted by the system',
-      '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',
+      'outcomes.interruptedHint': 'System interrupt',
+      'outcomes.maxTokens': 'Length cap',
+      'outcomes.maxTokensHint': 'Hit the cap',
+      'outcomes.countOn': '{n} on',
+      'outcomes.countOff': 'All off',
+
+      'short.completed': 'done',
+      'short.error': 'error',
+      'short.blocked': 'stuck',
+      'short.approval': 'approval',
+      'short.subagents': 'subagents',
+      'short.aborted': 'stop',
+      'short.interrupted': 'interrupt',
+      'short.maxTokens': 'token cap',
+
+      'summary.line': '{provider} · {host} → {to} · {events}',
+      'summary.noHost': 'no host yet',
+      'summary.noRecipient': 'no recipient yet',
+      'summary.recipients': '{n} recipients',
+      'summary.custom': 'Custom',
+      'summary.events': 'notify on {list}',
+      'summary.eventsMore': 'notify on {list} and {n} in all',
+      'summary.eventsOff': 'notifications are off',
 
       '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 +5458,23 @@ 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'] },
     ];
 
+    /**
+     * 8 个事件开关，一份真源：字段名 / 标题键 / 说明键 / 摘要短名。
+     *
+     * 通知时机卡片、卡片头读数、判决条的「事件全关」判定、人话摘要都读这一份表——
+     * 各写一遍必然漂：加了第 9 个事件时会漏掉某处。顺序就是格子顺序。
+     */
+    const OUTCOME_FIELDS = [
+      { field: 'notifyCompleted', title: 'outcomes.completed', hint: 'outcomes.completedHint', short: 'short.completed' },
+      { field: 'notifyError', title: 'outcomes.error', hint: 'outcomes.errorHint', short: 'short.error' },
+      { field: 'notifyBlocked', title: 'outcomes.blocked', hint: 'outcomes.blockedHint', short: 'short.blocked' },
+      { field: 'notifyApproval', title: 'outcomes.approval', hint: 'outcomes.approvalHint', short: 'short.approval' },
+      { field: 'includeSubagents', title: 'outcomes.subagents', hint: 'outcomes.subagentsHint', short: 'short.subagents' },
+      { field: 'notifyAbortedByUser', title: 'outcomes.aborted', hint: 'outcomes.abortedHint', short: 'short.aborted' },
+      { field: 'notifyInterrupted', title: 'outcomes.interrupted', hint: 'outcomes.interruptedHint', short: 'short.interrupted' },
+      { field: 'notifyMaxTokens', title: 'outcomes.maxTokens', hint: 'outcomes.maxTokensHint', short: 'short.maxTokens' },
+    ];
+
     /**
      * 解析收件人：一行一个（兼容逗号/分号），去空、去重、丢弃明显不含 @ 的项。
      * 规则必须与 Host 侧 lib/config.js 的 parseRecipients 保持一致。
@@ -5487,97 +5498,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 +5525,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,37 +5580,61 @@ window.__ModuleLoader__.load({
       return hit === undefined ? '' : hit;
     }
 
-    /** 状态条的取值顺序：先看能不能发，再看有没有真的发出去过。 */
+    /** 状态条的取值只由「配置齐不齐」与「有没有事件要通知」决定；投递历史已随账本一起删除。 */
     const STATUS_TONE = {
       disabled: 'idle',
+      allOff: 'warning',
       needRecipients: 'warning',
       needHost: 'warning',
       needUser: 'warning',
       needCredential: 'warning',
-      lastFailed: 'error',
       ready: 'done',
     };
 
     /**
      * 推导状态条要显示哪个结论。纯函数，输入全部来自草稿与凭据状态。
-     * SMTP 是唯一的发送方式，必填项是「主机 + 用户名 + 凭据」，缺哪个就报哪个——
-     * 只报主机会让用户填完主机才发现还是发不出去。
-     * @param {object} input 判定输入
+     *
+     * 优先级（上一档压住下一档，顺序就是这个人写下来的顺序）：
+     *   总开关关闭 > 8 个事件全关 > 缺配置（收件人 / 主机 / 用户名 / 凭据）> 可以发信。
+     * 总开关关着时谈"缺什么"没有意义；事件全关时谈「可以发信了」是骗人——信不会发出去。
+     * 投递历史不参与：账本已删，这里只回答「配置齐不齐」。
+     * @param {object} input 判定输入（不传 eventsOn 时跳过「事件全关」这一档）
      * @returns {string} 状态键
      */
     function deriveStatus(input) {
-      const { enabled, recipientCount, host, user, credentialConfigured, lastDelivery } = input ?? {};
+      const { enabled, eventsOn, recipientCount, host, user, credentialConfigured } = input ?? {};
       if (enabled !== true) return 'disabled';
+      if (eventsOn === 0) return 'allOff';
       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'} 状态点状态
@@ -5719,6 +5644,24 @@ window.__ModuleLoader__.load({
       return done === true ? 'done' : 'warning';
     }
 
+
+    /**
+     * 保存读数的"多久之前"。按量级退化，别让人去数 320 秒：
+     *   <60 秒 → 刚刚 / N 秒前；<60 分 → N 分钟前；<24 时 → N 小时前；否则 N 天前。
+     * @param {number} ms 距保存成功的毫秒数
+     * @param {Function} t 文案函数
+     * @returns {string} 读数
+     */
+    function agoText(ms, t) {
+      const seconds = Math.max(0, Math.floor(ms / 1000));
+      if (seconds < 60) return seconds === 0 ? t('save.savedJust') : t('save.savedAgo', { n: seconds });
+      const minutes = Math.floor(seconds / 60);
+      if (minutes < 60) return t('save.savedMin', { n: minutes });
+      const hours = Math.floor(minutes / 60);
+      if (hours < 24) return t('save.savedHour', { n: hours });
+      return t('save.savedDay', { n: Math.floor(hours / 24) });
+    }
+
     // ---------------------------------------------------------------------------
     // 样式
     //
@@ -5736,161 +5679,176 @@ window.__ModuleLoader__.load({
     //   面板是它的后代，直接引用按继承链正常求值，暗色自动跟着走。
     //
     // 量度（全部照抄宿主自己的设置页，别自己发明）：
-    //   内容列 ≈ 564px · 段标题 14/22·500 · 行标题 14/22 · 字段标签 12/18·500
-    //   说明 12/18 tertiary · 行间 .5px border-l2 · 段头下 .5px border-l3
-    //   填充面 = bg-module-platform（宿主"编辑器/选中态"用的就是这个）
+    //   内容列 max-width 760 居中 · 页标题 18/26·600 · 卡片标题 14/22·500 · 行标题 14/22·400
+    //   字段标签 13/20·500（primary） · 说明 12/18 tertiary · 小读数 11/16
+    //   卡片 = .5px settings-card-stroke + settings-card-fill + radius 20 + padding 14 16 + gap 12
+    //   行 = padding 16px 0 + 行自身 .5px border-l2（最后一行没有）；段头 / 页脚一律不画线
+    //   填充面 = bg-module-platform（宿主"编辑器/选中态"用的就是这个；卡片另用 settings-card-fill）
     //
-    // 纪律：全页零硬编码颜色（单测里有审计）。**全页只有一个填充面 —— 判决条。**
+    // 纪律：全页零硬编码颜色（单测里有审计）。**状态色填充面只有判决条一处**；
+    // 卡片的 fill / stroke 用宿主 settings 自己的 token（暗色下才不与页面同色）。
     // ---------------------------------------------------------------------------
 
     /** 一眼看出浏览器加载的是哪一版。放在根节点的 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 = 'ui18';
+
+    const CSS = `/* dsh-notify-p · 设置页样式（ui18 零折叠骨架；全页零硬编码颜色）
+字号阶梯（每一档都落在宿主网格上，全页只用整像素档，不许半档）：
+  页标题 18/26·600 ＝ 判决标题 18/26·600 > 卡片标题 14/22·500 > 行标题 14/22·400
+  > 页头说明 13/20 ＝ 字段标签 13/20·500 ＝ chips 13/18 > 说明 12/18 > 小读数 11/16
+骨架：内容列 max-width 760 居中；页头吸顶、吸底保存条常驻；三张卡片（card-fill 底 + card-stroke 描边）；
+判决条是唯一的状态色填充面（bg-module-platform）+ 左侧 3px 状态色；页脚无边框。
+线只长在行自己身上（.5px border-l2，最后一行没有），段头与页脚一律不画线。
+**零折叠**：没有「▸ 更多」、没有「还有 3 种情况」、没有问号按钮——这一页所有内容默认都在。
+圆角只用宿主那几档：卡片 / 判决条 20、输入框 12、chips 8。 */
+.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}
+
+/* ── 页头：吸顶常驻（自己带背景与内边距，滚过去不会盖住内容）───────────────
+   内容 = 标题 + 一行说明 + 右侧动作组（脏读数 + 保存 + 放弃改动）。 */
+.dshmn-head{position:sticky;top:0;z-index:2;display:flex;align-items:flex-start;justify-content:space-between;gap:12px 16px;margin:0 0 16px;padding:12px 0;min-width:0;flex-wrap:wrap;background:var(--dsw-alias-bg-layer-2)}
+.dshmn-headText{display:flex;flex-direction:column;gap:8px;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:13px;line-height:20px}
+.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（不硬编码）。
+   四档 tone：done（可发信）/ warning（缺配置、事件全关）/ idle（总开关关闭）/ error。 */
+/* 按钮：按宿主线上规则（.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-verdictSummary{margin:0;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px;word-break:break-word}
+.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;
+/* ── 三张卡片：card-stroke 描边 + card-fill 底（暗色下才不与页面同色）──────────
+   描边 + radius 20 + padding 14 16 + 内部 gap 12，与宿主 settings 的 rowCard 同构。 */
+.dshmn-card{display:flex;flex-direction:column;gap:12px;min-width:0;padding:14px 16px;
+  background:var(--dsw-alias-settings-card-fill);border:.5px solid var(--dsw-alias-settings-card-stroke);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;
-  border-left:.5px solid var(--dsw-alias-border-l2)}
-.dshmn-sub[data-muted=true]{opacity:.5}
-
-/* ── 字段：标签在上、控件满宽（宿主 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}
+.dshmn-itemHead{display:flex;align-items:baseline;justify-content:space-between;gap:12px 16px;min-width:0;flex-wrap:wrap}
+.dshmn-labelRow{display:inline-flex;align-items:center;gap:8px;min-width:0;flex-wrap:wrap}
+
+/* ── 通知时机：第一行总开关 + 8 个事件三列网格（窄屏一列，不分组）────────────── */
+.dshmn-master{display:flex;flex-direction:column;gap:6px;min-width:0;padding:16px 0 12px;
+  border-bottom:.5px solid var(--dsw-alias-border-l2)}
+.dshmn-masterHead{display:flex;align-items:center;justify-content:space-between;gap:12px;min-width:0}
+.dshmn-events{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:16px 28px;min-width:0;padding-top:4px}
+.dshmn-event{display:flex;flex-direction:column;gap:4px;min-width:0}
+.dshmn-eventHead{display:flex;align-items:center;justify-content:flex-start;gap:8px;min-width:0;min-height:22px;cursor:pointer}
+.dshmn-check{flex:none;width:16px;height:16px;margin:0;accent-color:var(--dsw-alias-brand-primary);cursor:pointer}
+.dshmn-check:disabled{cursor:not-allowed;opacity:.5}
+.dshmn-eventTitle{min-width:0;color:var(--dsw-alias-label-primary);font-size:14px;line-height:22px;font-weight:400}
+.dshmn-eventNote{margin:0;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}
+
+/* ── 字段：标签在上、控件满宽（宿主 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:20px;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}
 .dshmn-credState[data-ok=true]{color:var(--dsw-alias-state-success-primary)}
+.dshmn-credActions{display:inline-flex;align-items:center;gap:12px;flex-wrap:wrap;min-width:0}
 .dshmn-linkRow{display:flex;align-items:center;gap:12px;flex-wrap:wrap}
 
-/* ── 输入 ──────────────────────────────────────────────────────────────── */
+/* ── 输入 ────────────────────────────────────────────────────────────────── */
 /* 宿主的 Input 原语是 content-box 的 inline-flex（padding 0 8px + .5px 描边）,
-   所以光给 width:100% 会让它比父级宽出 18px、顶出内容列。必须一起给 border-box。 */
+   所以光给 width:100% 会让它比父级宽出 18px、顶出内容列。必须一起给 border-box。
+   兜底输入框：底色 / 描边 / 圆角与宿主 Input 对齐（bg-layer-1 + 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-input,.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-1);
   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-textarea:focus-visible,.dshmn-select:focus-visible{border-color:var(--dsw-alias-brand-primary);
+.dshmn-input::placeholder{color:var(--dsw-alias-label-tertiary)}
+.dshmn-input: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-input[aria-invalid=true]{border-color:var(--dsw-alias-state-error-primary)}
+
+/* 主机 / 端口 / 加密 / 用户名：宽屏一行四列（主机与用户名吃剩余宽度，端口与加密固定窄）。 */
+.dshmn-smtpGrid{display:grid;grid-template-columns:minmax(0,1fr) 88px 104px 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:13px;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-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-link:focus-visible,.dshmn-segBtn:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:2px}
 
-/* ── 折叠区与页脚 ──────────────────────────────────────────────────────── */
-.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}
-
-/* ── 窄屏：宿主 settings 页的断点就是 560px ─────────────────────────────── */
+/* ── 页脚与吸底条：页脚只留一条文字链；吸底条常驻底部，只放两个动作 ────────── */
+.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-savebar{position:sticky;bottom:0;z-index:2;display:flex;align-items:center;justify-content:flex-end;gap:8px;
+  flex-wrap:wrap;margin-top:8px;padding:12px 0;background:var(--dsw-alias-bg-layer-2)}
+.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-savebar{justify-content:flex-start}
+  .dshmn-smtpGrid{grid-template-columns:minmax(0,1fr) minmax(0,1fr)}
+  .dshmn-events{grid-template-columns:minmax(0,1fr)}
+  .dshmn-card{padding:12px 14px}
 }
+
 `;
 
 
@@ -5910,12 +5868,16 @@ window.__ModuleLoader__.load({
     /** 开关。原语缺失时用原生 checkbox 顶上。 */
     function Switch(props) {
       if (typeof P.Switch === 'function') return h(P.Switch, props);
+      // 兜底的 checkbox 要把额外 props 透传下去：事件格子用 data-event、总开关用 data-master
+      // 给自己一个稳定的 DOM 抓手（和宿主用 data-* 是同一个用途），视觉上不占位。
+      const { checked, disabled, label, onChange, ...rest } = props;
       return h('input', {
         type: 'checkbox',
-        checked: props.checked === true,
-        disabled: props.disabled === true,
-        'aria-label': props.label,
-        onChange: () => props.onChange(props.checked !== true),
+        checked: checked === true,
+        disabled: disabled === true,
+        'aria-label': label,
+        onChange: () => onChange(checked !== true),
+        ...rest,
       });
     }
 
@@ -5936,10 +5898,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 主题色）。 */
@@ -5948,7 +5925,31 @@ window.__ModuleLoader__.load({
       if (typeof P.Input === 'function') {
         return h(P.Input, { ...rest, className: `dshmn-inputWrap${className === undefined ? '' : ` ${className}`}` });
       }
-      return h('input', { ...rest, className: 'dshmn-textarea', style: { minHeight: 0, height: 32 } });
+      return h('input', { ...rest, className: 'dshmn-input', style: { minHeight: 0, height: 32 } });
+    }
+
+    /**
+     * 勾选框（多选清单用）。
+     *
+     * 事件开关为什么用勾选而不是开关：三列窄格里，拨动式开关没有"把手"，
+     * 一排放三个时分不清哪个属于哪个标题；勾选框贴着标题，读起来就是
+     * 「☑ 任务完成」这种清单句，选中与否一眼可读，也更贴合"我会收到哪些通知"。
+     * 总开关仍用拨动开关——它管的是整件事开不开，语义不同。
+     */
+    function Check(props) {
+      const { checked, disabled, label, onChange, ...rest } = props;
+      // 关键：**不能把 label 作为文本传给宿主原语**——宿主的 Checkbox 会把 label 渲染成
+      // 可见文字，于是标题出现两次（「☑ 任务完成 任务完成」），格子也被撑到换行。
+      // 名字只走 aria-label（读屏需要），可见文字由调用方自己排版。
+      const common = {
+        ...rest,
+        checked: checked === true,
+        disabled: disabled === true,
+        'aria-label': label,
+        onChange: () => onChange(checked !== true),
+      };
+      if (typeof P.Checkbox === 'function') return h(P.Checkbox, common);
+      return h('input', { type: 'checkbox', className: 'dshmn-check', ...common });
     }
 
     /**
@@ -5971,102 +5972,32 @@ 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);
-    }
+    // 全页零折叠：这一页没有折叠区、没有「▸ 更多」、也没有问号按钮——所有内容默认都在版面上。
 
     // ---------------------------------------------------------------------------
     // 页面
     // ---------------------------------------------------------------------------
 
     /**
-     * 一个分组：段头（名字 + 这一段的结论）+ 一条发丝线，内容靠行与行之间的分隔线组织。
+     * 一张卡片（宿主 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));
-    }
-
-    /**
-     * 一行：标题 + 说明在左，控件在右。
-     * @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 子行参数
-     * @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 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));
     }
 
     /**
@@ -6078,9 +6009,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 +6025,15 @@ 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 [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 [test, setTest] = React.useState({ phase: 'idle', ms: 0, error: '' });
 
       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 +6043,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 +6124,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 +6183,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);
+        }
+        for (const [ref, flag] of Object.entries(pwClear)) {
+          if (flag === true) 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]);
+        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]);
 
-      /** 恢复默认：清掉本命名空间在 settings.yaml 里的全部覆盖。 */
+      /** 只重试配置（授权码那一半已经写成功了）。 */
+      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]);
+
+      /**
+       * 放弃改动：草稿整体回滚到基线，授权码草稿一并清掉，读数回到「没有未保存的改动」。
+       * @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,74 +6393,87 @@ 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) });
-        }
-      }, [remotes, capability]);
-
-      // 离开页面时把还在防抖里的改动落盘，避免"改完就走"丢改动
-      React.useEffect(() => () => {
-        for (const [key, timer] of Object.entries(timers.current)) {
-          clearTimeout(timer);
-          void commit([key]);
+          setTest({ phase: 'fail', ms: 0, error: String(err?.message ?? err) });
         }
-      }, [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 savedEventsOn = OUTCOME_FIELDS.filter((item) => baseline[item.field] === true).length;
       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,
+        eventsOn: savedEventsOn,
+        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',
+        allOff: 'status.allOff',
         needRecipients: 'status.needRecipients',
         needHost: 'status.needHost',
         needUser: 'status.needUser',
         needCredential: 'status.needCredential',
         ready: 'status.ready',
-        lastFailed: 'status.lastFailed',
       };
       /** 判决句：**全页最大的字号**，也是这一页真正要回答的那句话。 */
       const statusTitle = statusKey === 'needCredential'
@@ -6481,36 +6481,106 @@ window.__ModuleLoader__.load({
         : t(STATUS_TITLE_KEY[statusKey] ?? 'status.ready');
       /** 判决下面那句人话：为什么是这个判决、下一步该动哪里。只说用户的事。 */
       const statusWhy = viewRef.current === null ? t('status.notServed') : t(`status.why.${statusKey}`);
-      const outcomesOn = ['notifyCompleted', 'notifyError', 'notifyBlocked', 'notifyApproval',
-        'notifyAbortedByUser', 'notifyInterrupted', 'notifyMaxTokens']
-        .filter((key) => draft[key] === true).length;
+      const outcomesOn = OUTCOME_FIELDS.filter((item) => draft[item.field] === 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) {
+          return [agoText(now - save.at, t)];
+        }
+        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 +6592,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,90 +6616,127 @@ 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'
+              : (statusKey === 'allOff' ? 'dshmn-master' : '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）
        * @param {string} hintKey 说明文案键
-       * @param {string} helpKey 帮助按钮文案键
+       * @param {string} helpKey 帮助链接文案键
        * @returns {object} React 元素
        */
       const credentialField = (fieldId, labelKey, ref, hintKey, helpKey) => {
         const confirmed = configured(ref);
-        const clear = pwClear[ref] === true;
-        const editing = confirmed !== true || clear;
-        const helpButton = h('button', {
-          type: 'button',
-          className: 'dshmn-link',
-          onClick: () => setHelpKind(true),
-        }, t(helpKey));
+        // 「更换」只是把输入框展开，不算一项改动；真正待清理的是 pwClear。
+        const editing = confirmed !== true || pwEdit[ref] === true;
+        const drafting = String(pwDraft[ref] ?? '').trim() !== '' || pwClear[ref] === true;
+        const showSaved = confirmed === true && drafting !== true;
         return h('div', { className: 'dshmn-item' },
           h('div', { className: 'dshmn-itemHead' },
-            h('label', { className: 'dshmn-label', htmlFor: fieldId }, t(labelKey)),
-            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'))),
+            h('span', { className: 'dshmn-labelRow' },
+              h('label', { className: 'dshmn-label', htmlFor: fieldId }, t(labelKey)),
+              h('button', {
+                type: 'button',
+                className: 'dshmn-link',
+                onClick: () => setHelpKind(true),
+              }, t(helpKey))),
+            h('span', { className: 'dshmn-credActions' },
+              h('span', { className: 'dshmn-credState', 'data-ok': showSaved ? 'true' : 'false' },
+                showSaved ? h('span', { 'aria-hidden': 'true' }, h(CheckedMark, null)) : null,
+                showSaved ? t('cred.saved') : (drafting ? t('cred.draft') : t('cred.notSaved'))),
+              confirmed
+                ? h('button', {
+                  type: 'button',
+                  className: 'dshmn-link',
+                  onClick: () => setPwEdit((prev) => ({ ...prev, [ref]: true })),
+                }, t('cred.replace'))
+                : null,
+              confirmed
+                ? h('button', {
+                  type: 'button',
+                  className: 'dshmn-link',
+                  onClick: () => {
+                    setPwDraft((prev) => ({ ...prev, [ref]: '' }));
+                    setPwClear((prev) => ({ ...prev, [ref]: true }));
+                  },
+                }, t('cred.clear'))
+                : null,
+              testButton({ variant: 'link' }))),
           editing
             ? h(TextInput, {
               id: fieldId,
@@ -6641,8 +6748,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 +6757,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,
@@ -6663,56 +6768,112 @@ window.__ModuleLoader__.load({
                 type: 'button',
                 className: 'dshmn-link',
                 onClick: () => void refreshCredentials([ref]),
-              }, `${t('save.credCheckFailed', { error: credError })}，${t('save.reload')}`)),
-          h('div', { className: 'dshmn-linkRow' },
-            confirmed
-              ? h('button', {
-                type: 'button',
-                className: 'dshmn-link',
-                onClick: () => setPwClear((prev) => ({ ...prev, [ref]: true })),
-              }, t('cred.replace'))
-              : null,
-            confirmed
-              ? h('button', {
-                type: 'button',
-                className: 'dshmn-link',
-                onClick: () => {
-                  setPwDraft((prev) => ({ ...prev, [ref]: '' }));
-                  setPwClear((prev) => ({ ...prev, [ref]: true }));
-                  void commitCredential(ref);
-                },
-              }, t('cred.clear'))
-              : null,
-            helpButton,
-            testButton({ variant: 'link' })));
+              }, `${t('save.credCheckFailed', { error: credError })}，${t('save.reload')}`)));
       };
 
-      /** 分组头右侧那一格：只说这一段的结论，不摆装饰。 */
+      /**
+       * 一个事件开关格子：标题 + 开关，说明常显在下面一行（12/18）。
+       *
+       * 全页零折叠：说明不再藏在问号后面，也没有"点一下才知道"的东西。
+       * 8 个格子排成三列网格（窄屏一列），**不分组**——分组标题把并列的开关伪装成
+       * 有层级，用户还得先学会"另外 3 个藏在哪"。
+       * @param {string} field 配置字段名
+       * @param {string} titleKey 标题文案键
+       * @param {string} hintKey 说明文案键
+       * @returns {object} React 元素
+       */
+      const eventCell = (field, titleKey, hintKey) => h('div', { className: 'dshmn-event', key: field },
+        h('label', { className: 'dshmn-eventHead' },
+          h(Check, {
+            checked: draft[field] === true,
+            disabled: draft.enabled === false,
+            label: t(titleKey),
+            'data-event': field,
+            onChange: (next) => setField(field, next),
+          }),
+          h('span', { className: 'dshmn-eventTitle' }, t(titleKey))),
+        h('p', { className: 'dshmn-eventNote' }, t(hintKey)));
+
+      /** 收件人那一组的读数：只说个数，落在段头的小字里（不再占一行正文）。 */
       const recipientsState = recipients.valid.length > 0
         ? t('recipients.ok', { n: recipients.valid.length })
         : t('recipients.none');
 
+      /**
+       * 「恢复全部默认」的入口：宿主给了 Modal 就弹确认框；没给就退回 window.confirm。
+       * 两条路都必须点得动——点了什么都不发生，是这一页最不该有的反应。
+       * @returns {void}
+       */
+      const askReset = () => {
+        if (typeof P.Modal === 'function') {
+          setConfirmReset(true);
+          return;
+        }
+        const accepted = typeof window !== 'undefined' && typeof window.confirm === 'function'
+          ? window.confirm(t('danger.body'))
+          : true;
+        if (accepted) void resetAll();
+      };
+
+      // ---- 判决条第三行的「人话摘要」：跟着草稿实时变（判决口径仍是已保存配置）----
+      /** 服务商：认得出来用预设名，认不出来就是「自定义」。 */
+      const summaryProvider = preset === null ? t('summary.custom') : preset.name;
+      const summaryHost = String(draft.smtpHost ?? '').trim() === ''
+        ? t('summary.noHost')
+        : String(draft.smtpHost).trim();
+      const summaryTo = recipients.valid.length === 0
+        ? t('summary.noRecipient')
+        : (recipients.valid.length === 1
+          ? recipients.valid[0]
+          : t('summary.recipients', { n: recipients.valid.length }));
+      const summaryEventNames = OUTCOME_FIELDS
+        .filter((item) => draft[item.field] === true)
+        .map((item) => t(item.short));
+      const summaryEvents = draft.enabled !== true || summaryEventNames.length === 0
+        ? t('summary.eventsOff')
+        : (summaryEventNames.length > 2
+          ? t('summary.eventsMore', { list: summaryEventNames.slice(0, 2).join('、'), n: summaryEventNames.length })
+          : t('summary.events', { list: summaryEventNames.join('、') }));
+      const summaryLine = t('summary.line', {
+        provider: summaryProvider,
+        host: summaryHost,
+        to: summaryTo,
+        events: summaryEvents,
+      });
+      /** 总开关关着时，8 个事件开关变灰禁用（但不隐藏）。 */
+      const eventsDisabled = draft.enabled === false;
+      /** 页头那组按钮与吸底条共用同一份可用条件（脏读数只在页头）。 */
+      const actionDisabled = dirtyCount === 0 || !bridgeReady || save.phase === 'saving';
+
       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'))))),
-
-        // ---- 判决条：全页唯一的填充面 ----
+        // ---- 页头（吸顶）：标题 + 一行说明；右侧脏读数 + 保存 + 放弃改动 ----
+        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: actionDisabled,
+              title: t('act.saveHint'),
+              onClick: () => void saveAll(),
+            }, t('act.save')),
+            h(Button, {
+              variant: 'outline',
+              size: 'sm',
+              disabled: actionDisabled,
+              onClick: () => discardAll(),
+            }, t('act.discard')))),
+
+        // ---- 判决条：全页唯一的状态色 hero；结论句 + 人话摘要 + 右下角主行动 ----
         h('section', {
           className: 'dshmn-verdict',
           'data-tone': tone,
@@ -6723,56 +6884,61 @@ 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)),
-
-        // ---- 收件人 ----
-        h(Group, { title: t('group.recipients'), state: recipientsState },
+        // 人话摘要：一眼看全「哪家邮箱 · 哪个服务器 → 发给谁 · 什么时候发」。
+        h('p', { className: 'dshmn-verdictSummary' }, summaryLine),
+        // 口径明写：这句判决算的是**已保存的配置**，屏幕上没保存的改动不算数。
+        dirtyCount > 0 ? h('p', { className: 'dshmn-hint' }, t('status.unsavedDraft')) : null,
+        testResult(),
+        h('div', { className: 'dshmn-verdictFoot' }, ...verdictActions())),
+
+        // ---- 卡片一：收件人 ----
+        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')),
-          h('textarea', {
+          // 单行输入：粘贴逗号 / 分号 / 换行分隔的多个地址照样一个不丢（解析函数没动）。
+          h(TextInput, {
             id: 'dshmn-recipients',
-            className: 'dshmn-textarea',
+            type: 'text',
             value: draft.recipients ?? '',
             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-smtpGrid' },
             h('div', { className: 'dshmn-field' },
               h('label', { className: 'dshmn-label', htmlFor: 'dshmn-smtp-host' }, t('smtp.host')),
               h(TextInput, {
@@ -6781,7 +6947,6 @@ 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')),
@@ -6792,8 +6957,14 @@ window.__ModuleLoader__.load({
                 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'),
+                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')),
@@ -6801,281 +6972,73 @@ window.__ModuleLoader__.load({
                 id: 'dshmn-smtp-secure',
                 className: 'dshmn-select',
                 value: draft.smtpSecure ?? 'auto',
-                onChange: (event) => setField('smtpSecure', event.target.value, { immediate: true }),
+                onChange: (event) => setField('smtpSecure', event.target.value),
               }, ...[['auto', 'auto'], ['tls', 'tls'], ['starttls', 'starttls'], ['plain', 'plain']]
-                .map(([value, text]) => h('option', { key: value, value }, text))))),
-
-          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, {
+                .map(([value, text]) => h('option', { key: value, value }, text)))),
+            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),
+              }),
+              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')),
+
+        // ---- 卡片三：通知时机（第一行总开关；下面 8 个事件三列网格，说明常显）----
+        h(Card, {
+          kind: 'outcomes',
           title: t('group.outcomes'),
           state: outcomesOn > 0 ? t('outcomes.countOn', { n: outcomesOn }) : t('outcomes.countOff'),
         },
-        // 时长下限是"任务完成"的子项（只对它生效），所以缩进成子行——因果关系看得见，
-        // 而不是隔着十行再补一句"只对完成生效"。
-        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 }),
-              }),
-            })))),
-
-        // ---- 可选设置（发件人、链接、排错）----
-        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')))))),
-          )),
-
-        // ---- 页脚：清空覆盖是破坏性操作，所以压到最下面、只用文字链接 ----
+        h('div', { className: 'dshmn-master' },
+          h('div', { className: 'dshmn-masterHead' },
+            h('span', { className: 'dshmn-label' }, t('notify.master')),
+            h(Switch, {
+              id: 'dshmn-master',
+              checked: draft.enabled === true,
+              label: t('notify.master'),
+              'data-master': 'true',
+              onChange: (next) => setField('enabled', next),
+            })),
+          h('p', { className: 'dshmn-hint' }, t('notify.masterHint'))),
+        h('div', { className: 'dshmn-events' },
+          ...OUTCOME_FIELDS.map((item) => eventCell(item.field, item.title, item.hint)))),
+
+        // ---- 页脚：清空覆盖是破坏性操作，压到页面最底部、只用一条文字链接 ----
         h('div', { className: 'dshmn-foot' },
           h('button', {
             type: 'button',
             className: 'dshmn-link',
             disabled: resetting,
-            onClick: () => setConfirmReset(true),
+            onClick: askReset,
           }, t('danger.reset'))),
 
+        // ---- 吸底条：常驻底部，只放两个动作（脏读数只在页头）----
+        h('div', { className: 'dshmn-savebar' },
+          h(Button, {
+            variant: 'outline',
+            size: 'sm',
+            disabled: actionDisabled,
+            onClick: () => discardAll(),
+          }, t('act.discard')),
+          h(Button, {
+            variant: 'primary',
+            size: 'sm',
+            disabled: actionDisabled,
+            title: t('act.saveHint'),
+            onClick: () => void saveAll(),
+          }, t('act.save'))),
+
         typeof P.Modal === 'function'
           ? h(P.Modal, {
             open: confirmReset,
@@ -7099,40 +7062,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 +7076,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 +7106,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 +7143,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 +7157,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 +7182,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, agoText, i18n },
     };
   },
 });