dsh-instruction-memory 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -7,6 +7,67 @@
 > 1.0.13 起由 CI 经 OIDC Trusted Publishing 发布（首个带 provenance 的版本）。
 > 这些历史 tag **不应回填**——npm 上的版本号已被占用。
 
+## [1.3.0] — 2026-10-15
+
+两个审查修复与两项体验增强（F12 / F7）。
+
+### 修复
+
+- **切换配置集时关闭打开中的编辑草稿**：切换成功后同时关闭指令编辑器与用户形象编辑器
+  （并退出批量选择模式）。此前留在屏幕上的表单仍显示旧集合的内容，保存时会落进新集合
+  （服务端跨集合保护保证不覆盖、不丢数据，但表单本身就是误导）。若切换时确有草稿被关闭，
+  会在提示里说明。ui-test 新增回归：打开形象编辑器 → 切换集合 → 断言编辑器消失且有披露；
+  并钉住「条目编辑器为整页接管，打开时切换按钮不可达」这一结构事实。
+- **导入回退到激活集合时按目标集合重新去重**：导入条目声明的集合不存在（或已达 20 个上限
+  无法创建）时会归入当前激活集合，但去重仍按**声明的集合**计算，可能把与激活集合已有条目
+  title+content 完全相同的内容再插一份。现在在提交阶段先确定每项的真实归属，再对回退项
+  按目标集合补一次查重（含同批其他回退项与正常落集项之间的互查）：重复的不再插入并单独
+  计数披露（「另有 N 项因回退到当前配置集后与已有内容重复被跳过」）；全部被跳过时保持
+  no-op 不写盘。回退目标中 id 已被占用而正文是新内容时改发新 id，不再把重复 id 写进同一
+  集合。正常路径（集合存在/成功创建）的幂等性不变——重新导入同一导出文件仍是 no-op。
+
+### 新增
+
+- **诊断与安全状态集中面板（F12）**：设置页新增可折叠「诊断信息」卡片（默认收起、纯展示、
+  无写路由），集中展示存储（路径/在盘/载入来源/最近保存/rev）、注入（注册状态、`pulls`
+  自启动计数、字符数/上限）、备份与历史（位置、`.bak`、历史目录与快照数、Schema 文件）与
+  全部错误/警告；「复制诊断信息」生成含 `navigator.userAgent` 的纯文本（**不含任何用户文本**，
+  剪贴板不可用时降级为手动全选文本框；序列化为导出纯函数 `__diagnosticsText` 并被
+  `verify.mjs` 锁定）。快照新增 `security`（`hostGuarded`/`boundHost`，与路由 Host 校验同源）与
+  `diagnostics`（`loadedFrom`/`rev`）：绑定在非回环地址时页面顶部显示醒目橙色安全警告，
+  补上对外发布场景缺失的信号。`docs/demo.html` 桩同步补齐。
+- **临时静音（F7）**：总开关旁「暂停注入…」——30 分钟 / 1 小时 / 到今天结束（本地时区
+  24:00），暂停期间指令与形象都不注入（系统提示词与未安装插件逐字节一致），到期由宿主侧
+  定时器自动恢复，**无需操作、不写盘（rev 不变）**；状态存于新增的**可选**顶层字段
+  `disabledUntil`（epoch 毫秒；0/缺失 = 未暂停；格式版本仍为 2，无迁移；跨重启保留）。
+  `set-options` 接受该字段：0 = 立即恢复，过去时间视为 0，超过 7 天上限钳到 now+7d 并披露；
+  手动切换总开关清零它（显式开关优先于定时）。注入渲染引入**可注入时钟**：`isMuted(data, now)`、
+  `planInjection(data, now = Date.now())`、`buildBlock(data, now = Date.now())`（默认参数仍是
+  当前时间，纯函数允许固定 now，字节结果可复现）；到期决策 `muteExpired(data, now)` 由
+  `syncSection` 末尾的单一定时器消费（每次状态变化先清旧定时器，插件卸载时清理，`unref`
+  不阻退出）。客户端提供暂停菜单、剩余时间倒计时（1s interval，随暂停状态自动建立/清理）
+  与「立即恢复」；`memory.schema.json`、README、demo 桩同步更新。
+
+### 测试
+
+- contract-test：导入回退去重六组回归（激活集合重复 / 20 集上限 / 批内互查 / 形象重复 /
+  id 重发 / 跨集同文不误伤）；先红后绿验证（回退修复后新用例失败）。
+- ui-test：切换集合关闭草稿回归；同以 stash 验证测试有效性。
+- smoke-test：isMuted 真值表与 muteExpired 到期决策；planInjection/buildBlock 注入时钟在
+  暂停前/后的字节一致性（暂停中 ≡ enabled:false；到期后 ≡ 未暂停）；形象随暂停一起置空；
+  时钟参数可省（arity = 1）。
+- contract-test（F7/F12）：set-options disabledUntil 写入/披露/过去归零/7 天钳制/随总开关
+  清零/非法拒绝；暂停中快照 injection.muted=true、registered=false、preview 为空；存储文件/
+  导出/restore 往返/源码模式携带该字段；手改非法值载入时重置并披露；F12 security/diagnostics
+  字段存在且 hostGuarded 随绑定地址变化（回环 vs 0.0.0.0）。
+- verify.mjs：__diagnosticsText 输出含关键字段、含环境信息、不含条目/形象/预演文本；
+  schema 记录 disabledUntil（integer ≥ 0）；F12/F7 双语键组检查。
+- ui-test（F12/F7）：诊断卡片展开/收起与复制降级路径（无剪贴板 → 可手动全选的转储，断言
+  不含用户文本）；非回环绑定警告出现/消失（第二宿主实例真实切换绑定）；暂停菜单三档 →
+  状态条倒计时 → 立即恢复；50ms 真实定时器到期自动恢复（文件字节不变的到期语义）。
+  ui-test 垫片补上 React 的 effect cleanup 语义（重跑前先清理），倒计时 interval 不再泄漏到
+  后续断言。
+
 ## [1.2.0] — 2026-10-15
 
 P2 进阶增强：多情境配置集、版本历史与回滚、手改友好化（JSON Schema）、源码模式、

package/README.md

@@ -80,6 +80,17 @@ dsh plugin --profile web remove dsh-instruction-memory
 总开关关闭时，该提示词段落（指令与用户形象）**整个注销**，系统提示词与未安装本插件时逐字节一致；
 总开关开启但没有任何生效指令、也没有启用形象时，段落同样不出现。
 
+### 临时静音（暂停注入一段时间，F7）
+
+总开关旁提供「暂停注入…」：**30 分钟 / 1 小时 / 到今天结束**（本地时区 24:00）。暂停期间
+指令与用户形象**都不注入**，系统提示词与「未安装本插件」**逐字节一致**；到期由插件内的
+宿主侧定时器**自动恢复**——无需用户操作，也不产生写盘（存储文件与修订号不变）。暂停
+状态保存在存储文件的 `disabledUntil` 字段里（仍是格式版本 2 的可选字段，缺失即未暂停），
+因此**跨重启保留**。手动切换总开关会立即清除暂停（显式开关优先于定时）。设置页在暂停中
+显示剩余时间倒计时，并可随时「立即恢复」；倒计时只是展示，权威判定始终在宿主快照
+（`injection.muted`）里。到期判定与注入渲染都是**可注入时钟**的纯函数（`isMuted`、
+`planInjection(data, now)`），相同输入永远得到相同字节。
+
 ## 存储
 
 记忆保存在 **DSH 数据根目录**下（设置页会显示完整绝对路径）：
@@ -350,6 +361,26 @@ DSH 就会得到第二份空记忆，看起来像"记忆消失"。
 **逐字节相同**（`verify.mjs` 有断言锁定这一点）。`debug` 级别由宿主日志级别过滤；
 没有 logger 服务的环境下需要 `DSH_INSTRUCTION_MEMORY_DEBUG=1` 才会输出到标准错误。
 
+### 诊断与安全状态面板（F12）
+
+设置页的「诊断信息」卡片把散在快照里的排障信息集中展示（默认收起，纯展示、无写路由）：
+
+- **存储**：路径、是否已在磁盘、载入来源（`loadedFrom`：首次创建 / 采用现有文件 / `.bak`
+  恢复 / 旧版迁移等）、最近保存时间、修订号（rev）；
+- **注入**：是否已注册、`pulls` 拉取计数（**自本次插件启动**，含义见上文）、当前字符数 / 上限；
+- **备份与历史**：备份位置、是否默认、`.bak` 覆盖副本路径、版本历史目录与快照数、Schema 文件位置；
+- **错误与警告**：存储错误 / 存储警告 / 历史错误 / 注入错误原样显示。
+
+「复制诊断信息」把以上内容序列化成纯文本（附 `navigator.userAgent`、语言与当前时间，
+便于提 issue）。它**绝不包含条目正文、形象内容等用户文本**；剪贴板 API 不可用时降级为
+`execCommand` 复制，再不可用则把文本放进可手动全选的文本框（序列化逻辑是导出的纯函数
+`__diagnosticsText`，`verify.mjs` 断言其输出含关键字段且不含任何用户文本）。
+
+卡片同时补上了此前缺失的唯一安全信号：**`security.hostGuarded`**。设置路由绑定在**非回环
+地址**（主动对外发布）时，页面顶部会出现醒目橙色警告：同一网络内的设备可无鉴权访问此页面、
+请勿在不可信网络暴露，并指向下节「经反向代理对外发布」。该判定与路由实际执行的 Host 校验
+是**同一个开关**；快照同时携带 `boundHost`（路由注册时捕获的绑定地址），警告会点名具体地址。
+
 ## 请求来源防护（Host / Origin）
 
 设置页路由之所以要求 `content-type: application/json`，是因为 HTML 表单无法伪造 JSON body，
@@ -579,6 +610,7 @@ Package → Settings → Trusted publishing → Add trusted publisher
   "version": 2,
   "rev": 3,
   "enabled": true,
+  "disabledUntil": 0,
   "budgetChars": 4000,
   "backupDir": "",
   "activeSetId": "st-default",
@@ -626,6 +658,11 @@ Package → Settings → Trusted publishing → Add trusted publisher
 `backupDir` 为**本机**的自定义备份位置（留空 = 与存储文件同目录，最多 512 字符）；它不是
 可移植内容，从备份恢复时不会被改写。
 
+`disabledUntil` 为**临时静音**（F7）的到期时刻（epoch 毫秒）：`0` 或缺失 = 未暂停；未来值 =
+暂停中，到期由插件自动恢复（无需操作、不写盘、rev 不变），跨重启保留。手动切换总开关会
+清零它（显式开关优先于定时）。这是格式版本 2 的**可选**字段：旧文件缺失即未暂停，不触发
+迁移；手改成非法值（非数字/负数）会被重置为 0 并在设置页披露。
+
 `profiles` 为可选的**用户形象**数组（缺失按空数组处理）：`name` 单行不超过 40 字符，
 `content` 不超过 4000 字符，最多 50 个；`enabled` 控制是否使用该形象。名称与内容同时为空的形象会在
 载入时剔除并明确披露；名称为空时自动取内容前 20 字符。

package/lib/client.js

@@ -153,6 +153,26 @@ window.__ModuleLoader__.load({
 .im-backup { display:flex; flex-direction:column; gap:8px; }
 .im-backup-row { display:flex; align-items:center; gap:8px; flex-wrap:wrap; }
 .im-backup-row .im-input { flex:1; min-width:200px; }
+/* ---- F12 诊断与安全状态 ---- */
+.im-hostwarn { display:flex; gap:8px; align-items:flex-start; padding:9px 12px; border-radius:8px; font-size:12px;
+  color:var(--dsw-alias-state-warn-primary,#d97706); border:1px solid var(--dsw-alias-state-warn-primary,#d97706);
+  background:var(--dsw-alias-state-warn-bg,rgba(217,119,6,.12)); font-weight:500; }
+.im-diag { display:flex; flex-direction:column; gap:8px; }
+.im-diag-group { display:flex; flex-direction:column; gap:3px; padding:8px 10px; border-radius:8px;
+  border:1px solid var(--dsw-alias-border-l1,rgba(0,0,0,.1)); background:var(--dsw-alias-bg-base,#fff); }
+.im-diag-sub { color:var(--dsw-alias-label-secondary,#8a9099); font-size:11.5px; }
+.im-diag-fallback { display:flex; flex-direction:column; gap:5px; }
+.im-diag-fallback .im-textarea { min-height:170px; font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace; font-size:11px; }
+/* ---- F7 临时静音 ---- */
+.im-master-col { display:flex; flex-direction:column; align-items:flex-end; gap:6px; }
+.im-pause-row { display:flex; align-items:center; gap:8px; flex-wrap:wrap; justify-content:flex-end; }
+.im-pause-menu { display:flex; flex-direction:column; gap:4px; padding:8px 10px; border-radius:8px;
+  border:1px solid var(--dsw-alias-border-l2,rgba(0,0,0,.18)); background:var(--dsw-alias-bg-base,#fff);
+  box-shadow:0 4px 14px rgba(0,0,0,.1); }
+.im-pause-bar { display:flex; align-items:center; gap:8px; flex-wrap:wrap; justify-content:flex-end;
+  padding:6px 10px; border-radius:8px; font-size:12px;
+  border:1px solid var(--dsw-alias-state-warn-primary,#d97706);
+  background:var(--dsw-alias-state-warn-bg,rgba(217,119,6,.12)); color:var(--dsw-alias-state-warn-primary,#d97706); }
 @media (max-width:640px) { .im-grid2 { grid-template-columns:1fr; } }
 `
 
@@ -315,6 +335,50 @@ window.__ModuleLoader__.load({
         'sets.copySuffix': ' 副本',
         'sets.deleteConfirm': '确定删除配置集「{name}」？其中的 {entries} 条指令与 {profiles} 个用户形象会一并删除，且无法撤销。',
         'sets.deleteActive': '当前激活的配置集不能删除；请先切换到其他配置集。',
+        'sets.draftsClosed': '已关闭切换前打开的编辑草稿',
+        // ---- F12 诊断与安全状态 ----
+        'diag.section': '诊断信息',
+        'diag.show': '展开诊断',
+        'diag.hide': '收起诊断',
+        'diag.copy': '复制诊断信息',
+        'diag.copied': '诊断信息已复制到剪贴板',
+        'diag.copyManual': '自动复制不可用；请手动全选复制下方文本。',
+        'diag.hostWarn': '安全提示：设置路由当前绑定在非回环地址（{host}），同一网络内的设备可以无鉴权访问此页面，请勿在不可信网络暴露；如需对外发布，请阅读 README 的「经反向代理对外发布」。',
+        'diag.groupStorage': '存储',
+        'diag.groupInjection': '注入',
+        'diag.groupBackup': '备份与历史',
+        'diag.groupIssues': '错误与警告',
+        'diag.none': '（无）',
+        'diag.storagePath': '存储文件',
+        'diag.onDisk': '存储文件已在磁盘',
+        'diag.loadedFrom': '载入来源',
+        'diag.savedAt': '最近保存',
+        'diag.rev': '修订号（rev）',
+        'diag.registered': '注入已注册',
+        'diag.yes': '是',
+        'diag.no': '否',
+        'diag.pulls': '注入拉取次数（自本次插件启动计数）',
+        'diag.chars': '当前注入字符数 / 上限',
+        'diag.backupDir': '备份位置',
+        'diag.backupDefault': '默认（与存储文件同目录）',
+        'diag.backupPath': '覆盖副本（.bak）',
+        'diag.historyDir': '版本历史目录',
+        'diag.historyCount': '历史快照数',
+        'diag.schemaFile': 'Schema 文件',
+        'diag.issueStorage': '存储错误',
+        'diag.issueWarning': '存储警告',
+        'diag.issueHistory': '历史错误',
+        'diag.issueSection': '注入错误',
+        // ---- F7 临时静音 ----
+        'mute.menu': '暂停注入…',
+        'mute.30m': '30 分钟',
+        'mute.1h': '1 小时',
+        'mute.today': '到今天结束',
+        'mute.resume': '立即恢复',
+        'mute.active': '注入已暂停，剩余 {remaining}',
+        'mute.hint': '暂停期间不注入任何指令或用户形象，到期后自动恢复；此状态跨重启保留。',
+        'mute.remainingMs': '{m} 分 {s} 秒',
+        'mute.remainingH': '{h} 小时 {m} 分',
         // ---- F14 版本历史 ----
         'history.section': '版本历史',
         'history.subtitle': '每次保存都会留一份带时间戳的快照（每台设备最多保留 {max} 份，逐出最旧的）。可在此查看并一键回滚。',
@@ -522,6 +586,50 @@ window.__ModuleLoader__.load({
         'sets.copySuffix': ' copy',
         'sets.deleteConfirm': 'Delete the set “{name}”? Its {entries} instructions and {profiles} personas are deleted with it. This cannot be undone.',
         'sets.deleteActive': 'The active set cannot be deleted; switch to another set first.',
+        'sets.draftsClosed': 'The editor draft open before the switch was closed',
+        // ---- F12 diagnostics & security panel ----
+        'diag.section': 'Diagnostics',
+        'diag.show': 'Show diagnostics',
+        'diag.hide': 'Hide diagnostics',
+        'diag.copy': 'Copy diagnostics',
+        'diag.copied': 'Diagnostics copied to the clipboard',
+        'diag.copyManual': 'Automatic copy is unavailable; select and copy the text below manually.',
+        'diag.hostWarn': 'Security notice: the settings route is bound to a non-loopback address ({host}); other devices on the same network can reach this page without authentication. Do not expose it on an untrusted network — for public deployments read “Publishing behind a reverse proxy” in the README.',
+        'diag.groupStorage': 'Storage',
+        'diag.groupInjection': 'Injection',
+        'diag.groupBackup': 'Backup & history',
+        'diag.groupIssues': 'Errors & warnings',
+        'diag.none': '(none)',
+        'diag.storagePath': 'Store file',
+        'diag.onDisk': 'Store file on disk',
+        'diag.loadedFrom': 'Loaded from',
+        'diag.savedAt': 'Last saved',
+        'diag.rev': 'Revision (rev)',
+        'diag.registered': 'Section registered',
+        'diag.yes': 'yes',
+        'diag.no': 'no',
+        'diag.pulls': 'Prompt pulls (counted since this plugin started)',
+        'diag.chars': 'Injected chars / budget',
+        'diag.backupDir': 'Backup location',
+        'diag.backupDefault': 'default (next to the store file)',
+        'diag.backupPath': 'Rolling copy (.bak)',
+        'diag.historyDir': 'History directory',
+        'diag.historyCount': 'History snapshots',
+        'diag.schemaFile': 'Schema file',
+        'diag.issueStorage': 'Storage error',
+        'diag.issueWarning': 'Storage warning',
+        'diag.issueHistory': 'History error',
+        'diag.issueSection': 'Injection error',
+        // ---- F7 temporary mute ----
+        'mute.menu': 'Pause injection…',
+        'mute.30m': '30 minutes',
+        'mute.1h': '1 hour',
+        'mute.today': 'Until the end of today',
+        'mute.resume': 'Resume now',
+        'mute.active': 'Injection paused — {remaining} left',
+        'mute.hint': 'While paused, neither instructions nor personas are injected. It resumes automatically and survives a restart.',
+        'mute.remainingMs': '{m}m {s}s',
+        'mute.remainingH': '{h}h {m}m',
         // ---- F14 version history ----
         'history.section': 'Version history',
         'history.subtitle': 'Every save leaves a timestamped snapshot ({max} kept per device, oldest evicted first). Review them here and roll back with one click.',
@@ -924,6 +1032,71 @@ window.__ModuleLoader__.load({
       return { budget, used, omitted, truncated, percent, tokens }
     }
 
+    /**
+     * F12: serialize a diagnostic snapshot into plain text for an issue report.
+     * Pinned as a pure export so verify.mjs can hold the contract: the dump
+     * carries the operational fields (store shape, storage, injection,
+     * security, load origin) plus the reporter's environment, and NEVER
+     * carries user text — no entry titles, no entry or persona bodies. Paths
+     * (including the absolute backup directory) are machine-local but are the
+     * whole point of a support dump, so they stay.
+     */
+    function diagnosticsText(view, env) {
+      const sec = (root, name) => (root !== null && typeof root === 'object'
+        && root[name] !== null && typeof root[name] === 'object' ? root[name] : {})
+      const data = sec(view, 'data')
+      const storage = sec(view, 'storage')
+      const injection = sec(view, 'injection')
+      const security = sec(view, 'security')
+      const diagnostics = sec(view, 'diagnostics')
+      const environment = env !== null && typeof env === 'object' ? env : {}
+      const v = (value) => (value === null || value === undefined ? '' : String(value))
+      const count = (value) => (Array.isArray(value) ? String(value.length) : '0')
+      return [
+        'dsh-instruction-memory diagnostics',
+        '--- store ---',
+        'version: ' + v(data.version),
+        'rev: ' + v(data.rev),
+        'enabled: ' + v(data.enabled),
+        'budgetChars: ' + v(data.budgetChars),
+        'disabledUntil: ' + v(data.disabledUntil),
+        'sets: ' + count(data.sets),
+        'entries(active set): ' + count(data.entries),
+        'profiles(active set): ' + count(data.profiles),
+        '--- storage ---',
+        'path: ' + v(storage.path),
+        'onDisk: ' + v(storage.onDisk),
+        'loadedFrom: ' + v(diagnostics.loadedFrom),
+        'rev: ' + v(diagnostics.rev),
+        'savedAt: ' + (typeof storage.savedAt === 'number' && storage.savedAt > 0 ? new Date(storage.savedAt).toISOString() : ''),
+        'migratedFrom: ' + v(storage.migratedFrom),
+        'backupDir: ' + v(storage.backupDir),
+        'isDefaultBackupDir: ' + v(storage.isDefaultBackupDir),
+        'backupPath: ' + v(storage.backupPath),
+        'historyDir: ' + v(storage.historyDir),
+        'historyCount: ' + v(storage.historyCount),
+        'schemaFile: ' + v(storage.schemaFile),
+        '--- injection ---',
+        'registered: ' + v(injection.registered),
+        'muted: ' + v(injection.muted),
+        'error: ' + v(injection.error),
+        'chars: ' + v(injection.chars),
+        'budget: ' + v(injection.budget),
+        'pulls(since boot): ' + v(injection.pulls),
+        '--- security ---',
+        'hostGuarded: ' + v(security.hostGuarded),
+        'boundHost: ' + v(security.boundHost),
+        '--- errors/warnings ---',
+        'storage.error: ' + v(storage.error),
+        'storage.warning: ' + v(storage.warning),
+        'historyError: ' + v(storage.historyError),
+        '--- environment ---',
+        'userAgent: ' + v(environment.userAgent),
+        'language: ' + v(environment.language),
+        'time: ' + v(environment.now),
+      ].join('\n')
+    }
+
     /* ---------------- F17: local relevance preview ---------------- */
 
     /** The most terms one query may be split into; keeps matching cheap. */
@@ -1318,6 +1491,16 @@ window.__ModuleLoader__.load({
       // draft: editing an instruction never closes an open persona and vice
       // versa is handled by closing one when opening the other (see handlers).
       const [profileDraft, setProfileDraft] = React.useState(null)
+      // Latest live values of the two editor drafts. switchSet's success
+      // callback is a closure created at click time; between the click and the
+      // response landing, a draft can still be opened (the busy flag only
+      // re-renders on the next pass), so the callback must read the drafts
+      // through refs to see what is REALLY open when the switch lands — a
+      // stale `draft === null` would leave the old set's form on screen.
+      const draftRef = React.useRef(null)
+      draftRef.current = draft
+      const profileDraftRef = React.useRef(null)
+      profileDraftRef.current = profileDraft
       const [budgetText, setBudgetText] = React.useState('')
       // Latest live value of the draft, because the SSE onmessage closure below
       // is created once and must not read a stale first-render budgetText.
@@ -1354,6 +1537,17 @@ window.__ModuleLoader__.load({
       const [historyOpen, setHistoryOpen] = React.useState(false)
       const [history, setHistory] = React.useState(null)
       const [historyBusy, setHistoryBusy] = React.useState(false)
+      // F12: the diagnostics card is collapsed by default; a failed automatic
+      // copy parks the dump here so it can be selected manually instead of
+      // pretending the copy happened.
+      const [diagOpen, setDiagOpen] = React.useState(false)
+      const [diagFallback, setDiagFallback] = React.useState(null)
+      // F7: the pause menu (null-state boolean) and a 1s clock tick that exists
+      // ONLY while a pause is live (its effect cleans up after itself). The
+      // tick drives nothing but the remaining-time text; authority stays with
+      // the host snapshot (injection.muted / data.disabledUntil).
+      const [pauseMenuOpen, setPauseMenuOpen] = React.useState(false)
+      const [nowTick, setNowTick] = React.useState(Date.now())
       // F18: the backup-location draft (focused-input protection like budget).
       const [backupText, setBackupText] = React.useState('')
       const backupTextRef = React.useRef('')
@@ -1396,6 +1590,20 @@ window.__ModuleLoader__.load({
         return () => clearTimeout(timer)
       }, [undo])
 
+      // F7: tick once per second while a pause is live so the remaining-time
+      // text counts down. The interval exists only while muted — the cleanup
+      // clears it the moment the snapshot says otherwise. This effect sits
+      // BEFORE the early returns (a hook skipped by a conditional return would
+      // desync the hook order); it reads the snapshot through `view` because
+      // the derived `injection` does not exist yet up here.
+      const mutedNow = view !== null && view.injection !== null && typeof view.injection === 'object'
+        && view.injection.muted === true
+      React.useEffect(() => {
+        if (!mutedNow) return undefined
+        const tick = setInterval(() => setNowTick(Date.now()), 1000)
+        return () => clearInterval(tick)
+      }, [mutedNow])
+
       /**
        * F16 live validation, debounced: parsing on every keystroke would stall
        * the panel on a multi-megabyte paste, and 250 ms is below the threshold
@@ -1566,6 +1774,22 @@ window.__ModuleLoader__.load({
           if (result !== null && result.ok === true) {
             setSelected([])
             setUndo(null)
+            // Batch mode exists to act on listed ids; after a switch it would
+            // act on ids from the wrong set, so it leaves with the selection.
+            setBatchMode(false)
+            // An editor left open across a switch is a form full of the OLD
+            // set's content that would save into the NEW set. The server-side
+            // cross-set guard means no data is lost, but the form itself is a
+            // lie — so it closes with the switch, and the user is told. The
+            // refs (not the closure state) say whether anything was open.
+            setDraft(null)
+            setProfileDraft(null)
+            if (draftRef.current !== null || profileDraftRef.current !== null) {
+              const base = typeof result.message === 'string' && result.message !== ''
+                ? result.message + '；'
+                : ''
+              setNotice(base + t('sets.draftsClosed'))
+            }
           }
         })
       }
@@ -1729,6 +1953,49 @@ window.__ModuleLoader__.load({
         }
       }
 
+      // ---- F12 diagnostics copy ----
+
+      function copyDiagnostics() {
+        if (view === null) return
+        const text = diagnosticsText(view, {
+          userAgent: typeof navigator !== 'undefined' && navigator.userAgent !== undefined ? String(navigator.userAgent) : '',
+          language: typeof navigator !== 'undefined' && navigator.language !== undefined ? String(navigator.language) : '',
+          now: new Date().toISOString(),
+        })
+        const clipboard = typeof navigator !== 'undefined' && navigator.clipboard
+          && typeof navigator.clipboard.writeText === 'function' ? navigator.clipboard : null
+        if (clipboard !== null) {
+          clipboard.writeText(text).then(() => setNotice(t('diag.copied')), () => fallbackCopyDiagnostics(text))
+          return
+        }
+        fallbackCopyDiagnostics(text)
+      }
+
+      /**
+       * The webview may ship neither the async clipboard API nor
+       * document.execCommand; then the only honest move is to surface the dump
+       * in a selectable textarea instead of pretending the copy happened.
+       */
+      function fallbackCopyDiagnostics(text) {
+        try {
+          const area = document.createElement('textarea')
+          area.value = text
+          area.setAttribute('readonly', '')
+          const host = document.body || document.head
+          if (host && typeof host.appendChild === 'function') host.appendChild(area)
+          if (typeof area.select === 'function') area.select()
+          const ok = typeof document.execCommand === 'function' && document.execCommand('copy') === true
+          if (host && typeof host.removeChild === 'function' && area.parentNode === host) host.removeChild(area)
+          if (ok) {
+            setNotice(t('diag.copied'))
+            return
+          }
+          throw new Error('copy rejected')
+        } catch {
+          setDiagFallback(text)
+        }
+      }
+
       async function doExport() {
         try {
           const result = await callHost('export-data', null)
@@ -1854,6 +2121,11 @@ window.__ModuleLoader__.load({
       // it here keeps the effect's dependency list down to the text itself.
       sourceCeilingRef.current = typeof limits.maxBodyChars === 'number' ? limits.maxBodyChars : 0
       const injection = view.injection || { registered: false, chars: 0, error: null }
+      // F12: the security block is optional (older Host) and then means "no
+      // known problem" — an absent field must not manufacture a warning.
+      const security = view.security !== null && typeof view.security === 'object'
+        ? view.security
+        : { hostGuarded: true, boundHost: '' }
       // List order is display-only and never changes what the Host injects
       // (the injection order is decided host-side). The default mirrors the
       // previous fixed order; updated-time and title are the other sorts.
@@ -1972,20 +2244,90 @@ window.__ModuleLoader__.load({
         : (injection.registered
           ? t('status.mounted', { chars: injection.chars })
           : (activeCount === 0 ? t('status.notMountedEmpty') : t('status.notMounted')))
+      // F12: display-only rows. Every value comes straight from the snapshot;
+      // a missing field (older Host) degrades to （无） instead of throwing
+      // mid-render.
+      const diagValue = (value) => (value === null || value === undefined || value === '' ? t('diag.none') : String(value))
+      const diagYesNo = (value) => (value === true ? t('diag.yes') : t('diag.no'))
+      const diagRow = (label, value) => h('div', { className: 'im-meta' }, label + '：' + value)
+      const diagLoadedFrom = view.diagnostics !== null && typeof view.diagnostics === 'object'
+        ? view.diagnostics.loadedFrom
+        : null
+      const diagRev = view.diagnostics !== null && typeof view.diagnostics === 'object'
+        && typeof view.diagnostics.rev === 'number'
+        ? view.diagnostics.rev
+        : (data.rev || 0)
+      // F7: the pause decision itself belongs to the host (injection.muted);
+      // the countdown below is display-only. At zero the bar yields back to
+      // the normal control (the host's own timer is delivering a fresh
+      // snapshot at that moment in any case).
+      const muted = injection.muted === true
+      const disabledUntil = typeof data.disabledUntil === 'number' && Number.isFinite(data.disabledUntil)
+        ? data.disabledUntil
+        : 0
+      const muteRemainingMs = muted ? Math.max(0, disabledUntil - nowTick) : 0
+      const muteRemainingText = (ms) => {
+        const totalSec = Math.max(0, Math.round(ms / 1000))
+        const hh = Math.floor(totalSec / 3600)
+        const mm = Math.floor((totalSec % 3600) / 60)
+        const ss = totalSec % 60
+        return hh > 0 ? t('mute.remainingH', { h: hh, m: mm }) : t('mute.remainingMs', { m: mm, s: ss })
+      }
+      const endOfToday = () => {
+        const d = new Date()
+        d.setHours(24, 0, 0, 0)
+        return d.getTime()
+      }
+      function pauseFor(ms) {
+        if (busy || typeof ms !== 'number' || !(ms > 0)) return
+        setPauseMenuOpen(false)
+        void send('set-options', { disabledUntil: Date.now() + ms, baseRev: revOf() })
+      }
+      function resumePause() {
+        if (busy) return
+        setPauseMenuOpen(false)
+        void send('set-options', { disabledUntil: 0, baseRev: revOf() })
+      }
 
       const header = h('div', { className: 'im-card', key: 'head' },
+        // F12: the non-loopback warning sits at the TOP of the panel — not
+        // inside the collapsible diagnostics card — so it cannot be missed.
+        security.hostGuarded === false
+          ? h('div', { className: 'im-hostwarn', key: 'hostwarn' },
+            t('diag.hostWarn', { host: security.boundHost !== '' ? security.boundHost : '?' }))
+          : null,
         h('div', { className: 'im-row' },
           h('div', null,
             h('h3', { className: 'im-h' }, t('panel.title')),
             h('p', { className: 'im-sub' }, t('panel.subtitle'))),
-          h('label', { className: 'im-switch' },
-            h('input', {
-              type: 'checkbox',
-              checked: data.enabled === true,
-              disabled: busy,
-              onChange: () => send('set-options', { enabled: !data.enabled, baseRev: revOf() }),
-            }),
-            t('panel.masterSwitch'))),
+          h('div', { className: 'im-master-col' },
+            h('label', { className: 'im-switch' },
+              h('input', {
+                type: 'checkbox',
+                checked: data.enabled === true,
+                disabled: busy,
+                onChange: () => send('set-options', { enabled: !data.enabled, baseRev: revOf() }),
+              }),
+              t('panel.masterSwitch')),
+            // F7 临时静音：暂停期间提示词与「未安装插件」逐字节一致；到期由宿主定时器
+            // 自动恢复，无需用户操作、不写盘。倒计时只是展示，权威在快照。
+            muted && muteRemainingMs > 0
+              ? h('div', { className: 'im-pause-bar' },
+                h('span', null, t('mute.active', { remaining: muteRemainingText(muteRemainingMs) })),
+                h('button', { className: 'im-btn', disabled: busy, onClick: resumePause }, t('mute.resume')))
+              : h('div', { className: 'im-pause-row' },
+                h('button', {
+                  className: 'im-btn',
+                  disabled: busy,
+                  onClick: () => setPauseMenuOpen(!pauseMenuOpen),
+                }, t('mute.menu')),
+                pauseMenuOpen
+                  ? h('div', { className: 'im-pause-menu' },
+                    h('button', { className: 'im-btn', disabled: busy, onClick: () => pauseFor(30 * 60000) }, t('mute.30m')),
+                    h('button', { className: 'im-btn', disabled: busy, onClick: () => pauseFor(60 * 60000) }, t('mute.1h')),
+                    h('button', { className: 'im-btn', disabled: busy, onClick: () => pauseFor(endOfToday() - Date.now()) }, t('mute.today')),
+                    h('div', { className: 'im-meta' }, t('mute.hint')))
+                  : null))),
         h('div', { className: 'im-status' },
           h('span', { className: dotClass }),
           h('span', { className: injection.error ? 'im-err' : 'im-meta' }, dotText)),
@@ -2410,6 +2752,58 @@ window.__ModuleLoader__.load({
           history !== null && history.dir !== ''
             ? h('div', { className: 'im-meta' }, t('history.dir', { dir: history.dir }))
             : null),
+        // ---- F12 诊断与安全状态（默认收起；纯展示，无写路由） ----
+        h('div', { key: 'diag', className: 'im-diag' },
+          h('div', { className: 'im-profiles-head' },
+            h('span', { className: 'im-section-title' }, t('diag.section')),
+            h('span', { className: 'im-spacer' }),
+            h('button', { className: 'im-btn', disabled: busy, onClick: () => setDiagOpen(!diagOpen) },
+              diagOpen ? t('diag.hide') : t('diag.show')),
+            h('button', { className: 'im-btn', disabled: busy, onClick: copyDiagnostics }, t('diag.copy'))),
+          diagOpen
+            ? h('div', null,
+              h('div', { className: 'im-diag-group' },
+                h('span', { className: 'im-section-title im-diag-sub' }, t('diag.groupStorage')),
+                diagRow(t('diag.storagePath'), diagValue(storage.path)),
+                diagRow(t('diag.onDisk'), diagYesNo(storage.onDisk === true)),
+                diagRow(t('diag.loadedFrom'), diagValue(diagLoadedFrom)),
+                diagRow(t('diag.savedAt'), typeof storage.savedAt === 'number' && storage.savedAt > 0
+                  ? new Date(storage.savedAt).toLocaleString()
+                  : t('diag.none')),
+                diagRow(t('diag.rev'), String(diagRev))),
+              h('div', { className: 'im-diag-group' },
+                h('span', { className: 'im-section-title im-diag-sub' }, t('diag.groupInjection')),
+                diagRow(t('diag.registered'), diagYesNo(injection.registered === true)),
+                diagRow(t('diag.pulls'), String(typeof injection.pulls === 'number' ? injection.pulls : 0)),
+                diagRow(t('diag.chars'),
+                  String(typeof injection.chars === 'number' ? injection.chars : 0) + ' / '
+                  + String(typeof injection.budget === 'number' ? injection.budget : data.budgetChars))),
+              h('div', { className: 'im-diag-group' },
+                h('span', { className: 'im-section-title im-diag-sub' }, t('diag.groupBackup')),
+                diagRow(t('diag.backupDir'), typeof storage.backupDir === 'string' && storage.backupDir !== ''
+                  ? storage.backupDir
+                  : t('diag.backupDefault')),
+                diagRow(t('diag.backupPath'), diagValue(storage.backupPath)),
+                diagRow(t('diag.historyDir'), diagValue(storage.historyDir)),
+                diagRow(t('diag.historyCount'), String(typeof storage.historyCount === 'number' ? storage.historyCount : 0)),
+                diagRow(t('diag.schemaFile'), diagValue(storage.schemaFile))),
+              h('div', { className: 'im-diag-group' },
+                h('span', { className: 'im-section-title im-diag-sub' }, t('diag.groupIssues')),
+                diagRow(t('diag.issueStorage'), diagValue(storage.error)),
+                diagRow(t('diag.issueWarning'), diagValue(storage.warning)),
+                diagRow(t('diag.issueHistory'), diagValue(storage.historyError)),
+                diagRow(t('diag.issueSection'), diagValue(injection.error))),
+              diagFallback !== null
+                ? h('div', { className: 'im-diag-fallback' },
+                  h('div', { className: 'im-meta' }, t('diag.copyManual')),
+                  h('textarea', {
+                    className: 'im-textarea',
+                    readOnly: true,
+                    value: diagFallback,
+                    onFocus: (ev) => { if (typeof ev.target.select === 'function') ev.target.select() },
+                  }))
+                : null)
+            : null),
         error !== '' ? h('div', { className: 'im-err' }, error) : null,
         error === '' && notice !== '' ? h('div', { className: 'im-ok' }, notice) : null,
         error === '' && notice === '' && storage.error ? h('div', { className: 'im-err' }, storage.error) : null,
@@ -2717,6 +3111,7 @@ window.__ModuleLoader__.load({
     exports.__relevanceTerms = relevanceTerms
     exports.__relevancePreview = relevancePreview
     exports.__sourceParseVerdict = sourceParseVerdict
+    exports.__diagnosticsText = diagnosticsText
     exports.__strings = STRINGS
     exports.__ns = NS
     exports.__dictionaryT = dictionaryT

package/lib/index.js

@@ -84,6 +84,12 @@ const MAX_SETS = 20
 const MAX_SET_NAME = 30
 /** Rolling history snapshots (F14): how many are kept PER writing device. */
 const MAX_HISTORY = 20
+/**
+ * F7: the longest single pause. Doubles as the setTimeout guard — 7 days is
+ * far below the 2^31-1 ms (≈24.8 days) timer ceiling, so the delay never
+ * overflows Node's timer range.
+ */
+const MAX_MUTE_MS = 7 * 24 * 60 * 60 * 1000
 const HISTORY_DIR_NAME = 'history'
 /** Name of the JSON Schema shipped with the package and copied next to the store. */
 const SCHEMA_FILE_NAME = 'memory.schema.json'
@@ -552,6 +558,7 @@ function normalizeData(raw) {
     version: FORMAT_VERSION,
     rev: 0,
     enabled: true,
+    disabledUntil: 0,
     budgetChars: DEFAULT_BUDGET,
     backupDir: '',
     activeSetId: DEFAULT_SET_ID,
@@ -599,6 +606,18 @@ function normalizeData(raw) {
   } else if ('backupDir' in raw && raw.backupDir !== null && raw.backupDir !== '') {
     optionFixes.push('backupDir ' + describeValue(raw.backupDir) + ' → ""（需要字符串路径）')
   }
+  // F7 temporary mute. The field is OPTIONAL (the format stays v2): missing
+  // means "not paused" and is adopted silently, exactly like a v1 file without
+  // sets. Present but not a usable instant is reset to 0 with a disclosure,
+  // like every other hand-edited option.
+  if ('disabledUntil' in raw) {
+    const muteValue = raw.disabledUntil
+    if (typeof muteValue === 'number' && Number.isFinite(muteValue) && muteValue >= 0) {
+      data.disabledUntil = Math.round(muteValue)
+    } else {
+      optionFixes.push('disabledUntil ' + describeValue(muteValue) + ' → 0（需要 ≥ 0 的 epoch 毫秒数，0 表示未暂停）')
+    }
+  }
 
   // Instruction sets (F13). A missing/blank list means a v1 file (or a hand
   // edit that removed it): synthesise the single 默认 set and record the fact,
@@ -705,6 +724,9 @@ function cloneData(data) {
     version: FORMAT_VERSION,
     rev: data.rev || 0,
     enabled: data.enabled === true,
+    disabledUntil: typeof data.disabledUntil === 'number' && Number.isFinite(data.disabledUntil) && data.disabledUntil > 0
+      ? data.disabledUntil
+      : 0,
     budgetChars: data.budgetChars,
     backupDir: typeof data.backupDir === 'string' ? data.backupDir : '',
     activeSetId: data.activeSetId,
@@ -1145,13 +1167,44 @@ function planEntries(data, budget) {
  *  - a profile-only store (no instructions) still injects, and the master
  *    `enabled` switch suppresses both halves as before.
  */
-export function planInjection(data) {
+/**
+ * F7 temporary mute: a store-level pause with an expiry. `disabledUntil` is an
+ * epoch-ms instant; while it lies in the future (and the master switch is on)
+ * the store is muted. The wall clock is only the DEFAULT: both this and the
+ * render entry points take `now`, so a fixed clock reproduces the same bytes
+ * and tests pin the behaviour without waiting.
+ */
+export function isMuted(data, now = Date.now()) {
+  return data !== null && typeof data === 'object' && data.enabled === true
+    && typeof data.disabledUntil === 'number' && Number.isFinite(data.disabledUntil)
+    && data.disabledUntil > now
+}
+
+/**
+ * The lapsed-mute decision the host timer acts on: a mute whose instant has
+ * passed needs the section re-registered (and a snapshot pushed), but writes
+ * NOTHING — expiry is a state change, not a save; the store file and its rev
+ * stay untouched, and the stale value is simply ignored until the next real
+ * write rewrites the file without it.
+ */
+export function muteExpired(data, now = Date.now()) {
+  return data !== null && typeof data === 'object' && data.enabled === true
+    && typeof data.disabledUntil === 'number' && Number.isFinite(data.disabledUntil)
+    && data.disabledUntil > 0 && data.disabledUntil <= now
+}
+
+export function planInjection(data, now = Date.now()) {
   const budget = clampBudget(data !== null && typeof data === 'object' ? data.budgetChars : undefined)
   const blank = () => ({
     text: '', budget, activeCount: 0, included: [], omitted: [],
     profiles: [], profileChars: 0, entryChars: 0,
   })
   if (data === null || typeof data !== 'object' || data.enabled !== true) return blank()
+  // F7 temporary mute: while the pause is live the plan is EXACTLY the
+  // enabled:false plan — same fields, same empty text — so the prompt section
+  // disappears and the prompt is byte-identical to a deployment without this
+  // plugin.
+  if (isMuted(data, now)) return blank()
   /**
    * The set filter (F13) is applied HERE, at the one place both the rendered
    * text and the budget decision are produced, so no caller can inject an
@@ -1186,8 +1239,8 @@ export function planInjection(data) {
  * decision process lives in one place, and callers that only need the text
  * (the prompt section) keep this byte-stable entry point.
  */
-export function buildBlock(data) {
-  return planInjection(data).text
+export function buildBlock(data, now = Date.now()) {
+  return planInjection(data, now).text
 }
 
 /* ------------------------------------------------------------------ *
@@ -1238,8 +1291,28 @@ export function apply(ctx) {
     storeExists: false,
     /** How many history snapshots the current directory holds (diagnostics). */
     historyCount: 0,
+    /**
+     * The address the settings route is actually bound to (F12 security panel).
+     * `''` until a web server publishes; the panel turns it into a warning when
+     * the bind is not loopback.
+     */
+    boundHost: '',
   }
   let sectionDispose = null
+  /**
+   * Which Host values this route accepts. Set when the route is registered,
+   * from the address the web server is actually bound to (see the long note on
+   * requestOriginVerdict). Until then the route does not exist at all, so the
+   * default only matters if something registers it out of band. Declared next
+   * to `state` so the snapshot can publish it at any time without a
+   * temporal-dead-zone hazard (F12 publishes it as `security.hostGuarded`).
+   */
+  let guardHost = true
+  /**
+   * F7: the pending mute-expiry timer, or null. Re-armed by scheduleMuteTimer
+   * (from syncSection) and cleared in the effect cleanup.
+   */
+  let muteTimer = null
 
   /**
    * A first run deliberately writes NOTHING (see readFromDisk step 3). This flag
@@ -1320,7 +1393,7 @@ export function apply(ctx) {
 
   const sectionText = () => {
     try {
-      return buildBlock(state.data)
+      return buildBlock(state.data, Date.now())
     } catch (err) {
       console.error('[instruction-memory] render failed:', err)
       return ''
@@ -1336,7 +1409,7 @@ export function apply(ctx) {
    */
   const sectionPlan = () => {
     try {
-      return planInjection(state.data)
+      return planInjection(state.data, Date.now())
     } catch (err) {
       console.error('[instruction-memory] render failed:', err)
       return {
@@ -1361,6 +1434,37 @@ export function apply(ctx) {
     return sectionText()
   }
 
+  /**
+   * F7: keep one host-side timer pointed at the mute's expiry. Expiry must be
+   * automatic — no user action, no write: when the instant passes, the section
+   * re-registers (or stays dropped) and open panels get a fresh snapshot,
+   * while the store file and its rev stay untouched. syncSection re-arms it
+   * on every state change (boot, commit, external reload), and re-arming
+   * clears the previous timer first, so there is never more than one.
+   */
+  const scheduleMuteTimer = () => {
+    if (muteTimer !== null) {
+      clearTimeout(muteTimer)
+      muteTimer = null
+    }
+    if (!isMuted(state.data)) return
+    const delay = Math.min(state.data.disabledUntil - Date.now(), MAX_MUTE_MS)
+    muteTimer = setTimeout(() => {
+      muteTimer = null
+      // Clock skew or an early fire: if the mute is still live, re-arm instead
+      // of acting; the sync below happens only on a real expiry.
+      if (isMuted(state.data)) {
+        scheduleMuteTimer()
+        return
+      }
+      syncSection()
+      pushSnapshot()
+      logDebug('mute expired: section re-synced without a write')
+    }, Math.max(1, delay))
+    // A 7-day timer must not hold a shutting-down process open.
+    if (typeof muteTimer.unref === 'function') muteTimer.unref()
+  }
+
   /**
    * Keep the registered section exactly in step with the stored data: present
    * when something must be injected, absent otherwise. An empty memory must
@@ -1380,9 +1484,7 @@ export function apply(ctx) {
         state.sectionError = '注入注册失败：' + describeError(err)
         console.error('[instruction-memory] section registration failed:', err)
       }
-      return
-    }
-    if (!wanted) {
+    } else if (!wanted) {
       if (sectionDispose !== null) {
         const dispose = sectionDispose
         sectionDispose = null
@@ -1396,6 +1498,9 @@ export function apply(ctx) {
       state.sectionRegistered = false
       state.sectionError = null
     }
+    // F7: whatever this sync just published, the mute timer must point at
+    // exactly this state (and re-arming clears the previous timer first).
+    scheduleMuteTimer()
   }
 
   ctx.effect(() => () => {
@@ -1408,6 +1513,10 @@ export function apply(ctx) {
         console.error('[instruction-memory] cleanup failed:', err)
       }
     }
+    if (muteTimer !== null) {
+      clearTimeout(muteTimer)
+      muteTimer = null
+    }
     stopWatching()
     disposeStreams()
   })
@@ -1540,6 +1649,9 @@ export function apply(ctx) {
     version: FORMAT_VERSION,
     rev: state.data.rev || 0,
     enabled: state.data.enabled === true,
+    disabledUntil: typeof state.data.disabledUntil === 'number' && Number.isFinite(state.data.disabledUntil) && state.data.disabledUntil > 0
+      ? state.data.disabledUntil
+      : 0,
     budgetChars: clampBudget(state.data.budgetChars),
     backupDir: typeof state.data.backupDir === 'string' ? state.data.backupDir : '',
     activeSetId: state.data.activeSetId,
@@ -2070,14 +2182,29 @@ export function apply(ctx) {
     if (!needsMaterialize) return false
     /**
      * A store may have APPEARED since boot — a hand-copied memory.json, a
-     * backup restored by another tool, a second process. Materialising the
-     * empty in-memory store over it would destroy exactly what the user just
-     * put there, so the disk is re-checked first and an existing file is
-     * adopted instead. (The gap is wide enough to matter: the panel's first
-     * `state` call can come minutes after boot.)
+     * backup restored by another tool, a second process. Three cases, and the
+     * difference between the last two is the whole point:
+     *   - nothing there: materialise the empty store (the documented first run);
+     *   - READABLE: adopt it instead of overwriting whatever the user just put
+     *     there (the gap is wide — the panel's first `state` call can come
+     *     minutes after boot);
+     *   - present but UNREADABLE: write nothing at all and let the loader's own
+     *     disclosure say why. Overwriting would destroy the very file a user
+     *     could still repair by hand, and it would report `ok:true` while doing
+     *     it — the silent data loss this plugin must never commit.
      */
-    const appeared = await readStoreFile(storePath).catch(() => null)
-    if (appeared !== null) {
+    let appeared = null
+    let unreadable = false
+    try {
+      appeared = await readStoreFile(storePath)
+    } catch (err) {
+      // ENOENT is the FIRST RUN itself — nothing to adopt, so materialise.
+      // Anything else (EACCES, EISDIR, a parse failure …) means a file IS
+      // there and could not be adopted; readFromDisk() below reports exactly
+      // what it was, and nothing is written.
+      unreadable = !(err !== null && typeof err === 'object' && err.code === 'ENOENT')
+    }
+    if (unreadable || appeared !== null) {
       const wrote = await readFromDisk()
       syncSection()
       return wrote
@@ -2170,6 +2297,9 @@ export function apply(ctx) {
         version: FORMAT_VERSION,
         rev: state.data.rev || 0,
         enabled: state.data.enabled === true,
+        disabledUntil: typeof state.data.disabledUntil === 'number' && Number.isFinite(state.data.disabledUntil) && state.data.disabledUntil > 0
+          ? state.data.disabledUntil
+          : 0,
         budgetChars: clampBudget(state.data.budgetChars),
         backupDir: typeof state.data.backupDir === 'string' ? state.data.backupDir : '',
         activeSetId: state.data.activeSetId,
@@ -2195,6 +2325,28 @@ export function apply(ctx) {
           profiles: state.data.profiles.filter((profile) => belongsTo(profile, set.id)).length,
         })),
       },
+      /**
+       * F12: the one security signal the panel was missing. `hostGuarded` is
+       * the SAME flag the route enforces on every request — false means the
+       * Host allowlist is OFF because the server is bound beyond loopback,
+       * i.e. the page is reachable without authentication from the local
+       * network. `boundHost` says which address produced that decision so the
+       * warning can name it instead of guessing.
+       */
+      security: {
+        hostGuarded: guardHost === true,
+        boundHost: state.boundHost,
+      },
+      /**
+       * F12: load-side diagnostics that used to be log-only. `loadedFrom` says
+       * which branch of the boot load produced the current data (fresh store,
+       * adopted file, recovered .bak, …); `rev` mirrors data.rev so a support
+       * dump pairs it with the storage fields without another round trip.
+       */
+      diagnostics: {
+        loadedFrom: state.loadedFrom,
+        rev: state.data.rev || 0,
+      },
       storage: {
         path: state.storageDisplay !== null ? state.storageDisplay : state.storagePath,
         error: state.storageError,
@@ -2218,6 +2370,12 @@ export function apply(ctx) {
         registered: state.sectionRegistered,
         available: true,
         error: state.sectionError,
+        /**
+         * F7: the pause is decided by the HOST clock (isMuted on the live
+         * store) and published as a derived flag; the client only renders a
+         * countdown from data.disabledUntil and never decides by itself.
+         */
+        muted: isMuted(state.data, Date.now()),
         chars: preview.length,
         /**
          * The budget decision behind `preview`, for the settings page's
@@ -2505,25 +2663,72 @@ export function apply(ctx) {
         }
       }
     }
+    // F7 temporary mute: validated BEFORE the transaction so a bad value is
+    // refused with a reason instead of being silently normalized. 0 means
+    // "resume now"; a past instant means the same thing; anything beyond the
+    // 7-day ceiling is clamped (and disclosed) rather than refused — a pause
+    // is a de-escalation, refusing it would be user-hostile.
+    let muteTarget = null
+    let muteClamped = false
+    if (patch !== null && typeof patch === 'object' && 'disabledUntil' in patch) {
+      const rawMute = patch.disabledUntil
+      if (typeof rawMute !== 'number' || !Number.isFinite(rawMute) || rawMute < 0) {
+        return {
+          ok: false,
+          saved: false,
+          message: 'disabledUntil 需要 0（立即恢复）或未来的 epoch 毫秒数',
+          snapshot: snapshot(),
+        }
+      }
+      let wanted = Math.round(rawMute)
+      if (wanted <= Date.now()) {
+        wanted = 0
+      } else if (wanted > Date.now() + MAX_MUTE_MS) {
+        wanted = Date.now() + MAX_MUTE_MS
+        muteClamped = true
+      }
+      muteTarget = wanted
+    }
+    const muteWasActive = isMuted(state.data)
     const saved = await commit(() => {
       if (patch !== null && typeof patch === 'object') {
-        if (typeof patch.enabled === 'boolean') state.data.enabled = patch.enabled
+        if (typeof patch.enabled === 'boolean') {
+          state.data.enabled = patch.enabled
+          // An explicit switch outranks the timer: flipping the master switch
+          // ends any pause immediately.
+          state.data.disabledUntil = 0
+        }
         if (typeof patch.budgetChars === 'number' && Number.isFinite(patch.budgetChars)) {
           state.data.budgetChars = clampBudget(patch.budgetChars)
         }
         if (typeof patch.backupDir === 'string') state.data.backupDir = patch.backupDir.trim()
+        if (muteTarget !== null && typeof patch.enabled !== 'boolean') {
+          state.data.disabledUntil = muteTarget
+        }
       }
     })
     // A changed backup location moves where history snapshots and manual
     // exports go, so it is reported rather than left to be discovered.
-    let note = null
+    const notes = []
     if (patch !== null && typeof patch === 'object' && typeof patch.backupDir === 'string') {
       const wanted = patch.backupDir.trim()
-      note = wanted === ''
+      notes.push(wanted === ''
         ? '已恢复默认备份位置（版本历史与导出与存储文件同目录）'
-        : '备份位置已更新：' + wanted + '（版本历史与「导出到备份目录」随之改变；存储文件本身不移动）'
+        : '备份位置已更新：' + wanted + '（版本历史与「导出到备份目录」随之改变；存储文件本身不移动）')
+    }
+    if (muteTarget !== null && !(patch !== null && typeof patch === 'object' && typeof patch.enabled === 'boolean')) {
+      if (muteTarget === 0) {
+        if (muteWasActive) notes.push('已恢复注入。')
+      } else {
+        notes.push('已暂停注入至 ' + new Date(muteTarget).toLocaleString()
+          + '（到期自动恢复；暂停期间不注入任何指令或用户形象）'
+          + (muteClamped ? '；暂停时长上限为 7 天，已按上限记录' : ''))
+      }
     }
-    return settle(note, saved)
+    if (patch !== null && typeof patch === 'object' && typeof patch.enabled === 'boolean' && muteWasActive) {
+      notes.push('总开关已切换，暂停注入状态已一并清除')
+    }
+    return settle(notes.length > 0 ? notes.join('；') : null, saved)
   })
 
   /**
@@ -3235,16 +3440,6 @@ export function apply(ctx) {
       seenProfileIds.add(wanted + '\u0000' + profile.id)
       seenProfileBodies.add(wanted + '\u0000' + profile.name + '\u0000' + profile.content)
     }
-    if (accepted.length === 0 && acceptedProfiles.length === 0) {
-      // Nothing was written to disk, so claiming saved:true would be a lie the
-      // panel cannot distinguish from a real save.
-      return {
-        ok: true,
-        saved: false,
-        message: '没有新增内容：' + skipped + ' 条条目、' + skippedProfiles + ' 个用户形象已存在或无效',
-        snapshot: snapshot(),
-      }
-    }
     // Create only the declared sets that the accepted items actually reference,
     // in declaration order, while there is room.
     const wantedIds = []
@@ -3261,21 +3456,90 @@ export function apply(ctx) {
       createdIds.add(declared.id)
     }
     let fellBack = 0
-    const finalIdOf = (wanted) => {
-      if (localSetIds.has(wanted) || createdIds.has(wanted)) return wanted
-      fellBack += 1
-      return activeId
-    }
-    const saved = await commit(() => {
-      state.data.sets.push(...createdSets)
+    const finalIdOf = (wanted) => (localSetIds.has(wanted) || createdIds.has(wanted) ? wanted : activeId)
+    /**
+     * Fallback de-duplication (review fix). The plan phase de-duplicated
+     * against the set each item DECLARED, but finalIdOf() may retarget an item
+     * into the active set (its set is unknown here, or the MAX_SETS cap blocked
+     * creating it). Every retargeted item is therefore re-checked against the
+     * set it REALLY lands in — pre-existing content, same-batch items already
+     * staged there, and same-batch items that reached it through the normal
+     * path — before anything is appended. The normal path (set exists or was
+     * created) keeps the plan-phase decision untouched, which is what keeps
+     * re-importing the same export file a no-op.
+     */
+    const stagedEntries = []
+    const stagedProfiles = []
+    let dedupedOnFallback = 0
+    {
+      const finalSeenIds = new Set(existing.map((entry) => entry.setId + '\u0000' + entry.id))
+      const finalSeenBodies = new Set(existing.map((entry) => bodyKey(entry.setId, entry.title, entry.content)))
+      // Items the plan phase accepted under their declared set occupy that
+      // set's id/body space even when the item itself later falls back (a
+      // fallback item's declared set is neither local nor created, so the keys
+      // never collide with these — they only guard the normal path).
+      for (const item of accepted) {
+        finalSeenIds.add(item.wanted + '\u0000' + item.entry.id)
+        finalSeenBodies.add(bodyKey(item.wanted, item.entry.title, item.entry.content))
+      }
       for (const item of accepted) {
-        item.entry.setId = finalIdOf(item.wanted)
-        state.data.entries.push(item.entry)
+        const finalId = finalIdOf(item.wanted)
+        if (finalId !== item.wanted) {
+          if (finalSeenBodies.has(bodyKey(finalId, item.entry.title, item.entry.content))) {
+            dedupedOnFallback += 1
+            continue
+          }
+          if (finalSeenIds.has(finalId + '\u0000' + item.entry.id)) {
+            // The body is new to the fallback target but the id is taken
+            // there: re-mint instead of writing a duplicate id into one set.
+            item.entry.id = makeId()
+          }
+          fellBack += 1
+          finalSeenIds.add(finalId + '\u0000' + item.entry.id)
+          finalSeenBodies.add(bodyKey(finalId, item.entry.title, item.entry.content))
+        }
+        item.entry.setId = finalId
+        stagedEntries.push(item.entry)
+      }
+      const finalSeenProfileIds = new Set(existingProfiles.map((profile) => profile.setId + '\u0000' + profile.id))
+      const finalSeenProfileBodies = new Set(existingProfiles.map((profile) => profile.setId + '\u0000' + profile.name + '\u0000' + profile.content))
+      for (const item of acceptedProfiles) {
+        finalSeenProfileIds.add(item.wanted + '\u0000' + item.profile.id)
+        finalSeenProfileBodies.add(item.wanted + '\u0000' + item.profile.name + '\u0000' + item.profile.content)
       }
       for (const item of acceptedProfiles) {
-        item.profile.setId = finalIdOf(item.wanted)
-        state.data.profiles.push(item.profile)
+        const finalId = finalIdOf(item.wanted)
+        if (finalId !== item.wanted) {
+          if (finalSeenProfileBodies.has(finalId + '\u0000' + item.profile.name + '\u0000' + item.profile.content)) {
+            dedupedOnFallback += 1
+            continue
+          }
+          if (finalSeenProfileIds.has(finalId + '\u0000' + item.profile.id)) {
+            item.profile.id = makeId()
+          }
+          fellBack += 1
+          finalSeenProfileIds.add(finalId + '\u0000' + item.profile.id)
+          finalSeenProfileBodies.add(finalId + '\u0000' + item.profile.name + '\u0000' + item.profile.content)
+        }
+        item.profile.setId = finalId
+        stagedProfiles.push(item.profile)
+      }
+    }
+    if (stagedEntries.length === 0 && stagedProfiles.length === 0) {
+      // Nothing was written to disk, so claiming saved:true would be a lie the
+      // panel cannot distinguish from a real save.
+      return {
+        ok: true,
+        saved: false,
+        message: '没有新增内容：' + skipped + ' 条条目、' + skippedProfiles + ' 个用户形象已存在或无效'
+          + (dedupedOnFallback > 0 ? '；另有 ' + dedupedOnFallback + ' 项因回退到当前配置集后与已有内容重复被跳过' : ''),
+        snapshot: snapshot(),
       }
+    }
+    const saved = await commit(() => {
+      state.data.sets.push(...createdSets)
+      for (const entry of stagedEntries) state.data.entries.push(entry)
+      for (const profile of stagedProfiles) state.data.profiles.push(profile)
     })
     const parts = []
     if (createdSets.length > 0) {
@@ -3284,6 +3548,9 @@ export function apply(ctx) {
     if (fellBack > 0) {
       parts.push('有 ' + fellBack + ' 项因原配置集不存在或已达 ' + MAX_SETS + ' 个上限，已归入当前配置集')
     }
+    if (dedupedOnFallback > 0) {
+      parts.push('另有 ' + dedupedOnFallback + ' 项因回退到当前配置集后与已有内容重复被跳过')
+    }
     if (accepted.length > 0) {
       const truncated = truncatedCount > 0
         ? '；其中 ' + truncatedCount + ' 条超过长度上限，' + [...cutFields].join('、') + '已被截断'
@@ -3395,11 +3662,8 @@ export function apply(ctx) {
 
   /* ---------------- same-origin JSON route for the Client half ---------------- */
 
-  // Which Host values this route accepts. Set when the route is registered,
-  // from the address the web server is actually bound to (see the long note on
-  // requestOriginVerdict). Until then the route does not exist at all, so the
-  // default only matters if something registers it out of band.
-  let guardHost = true
+  // `guardHost` is declared next to `state` (F12 publishes it as
+  // `security.hostGuarded`); only `routeDispose` lives here.
 
   let routeDispose = null
 
@@ -3574,6 +3838,9 @@ export function apply(ctx) {
     // the README.
     const boundHost = typeof webServer.host === 'string' ? webServer.host.trim().toLowerCase() : ''
     guardHost = boundHost === '' || isLoopbackName(boundHost)
+    // F12: the settings page can only warn about a non-loopback bind if the
+    // snapshot carries what the route actually saw at registration time.
+    state.boundHost = boundHost
     try {
       routeDispose = webServer.register({ kind: 'prefix', path: API_PREFIX, handler })
       logDebug('settings route registered at ' + API_PREFIX + ' (boundHost=' + boundHost + ', hostGuard=' + guardHost + ')')

package/memory.schema.json

@@ -27,6 +27,12 @@
       "description": "总开关。为 false 时指令与用户形象都不注入。",
       "default": true
     },
+    "disabledUntil": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "临时静音（F7）：暂停注入的到期时刻（epoch 毫秒）。0 或缺失 = 未暂停；未来值 = 暂停中，到期后由插件自动恢复注入（无需用户操作，也不产生写盘，rev 不变）。它与总开关相互独立：手动切换 enabled 会把它清零（显式开关优先于定时）。字段缺失时按未暂停处理，不触发任何迁移。",
+      "default": 0
+    },
     "budgetChars": {
       "type": "integer",
       "minimum": 800,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-instruction-memory",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "User-only instruction memory for DSH: long-term instructions maintained in the settings UI and auto-injected into every conversation — the model has no write access. 指令记忆：只由用户在设置页维护的长期指令，自动注入此后每轮对话；模型没有任何写入口。",
   "license": "MIT",
   "type": "module",