dsh-instruction-memory 1.2.0 → 1.3.1

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)
   })
 
   /**
@@ -3167,8 +3372,6 @@ export function apply(ctx) {
     const seenIds = new Set(existing.map((entry) => entry.setId + '\u0000' + entry.id))
     const seenBodies = new Set(existing.map((entry) => bodyKey(entry.setId, entry.title, entry.content)))
     const accepted = []
-    const cutFields = new Set()
-    let truncatedCount = 0
     let skipped = 0
     for (const candidate of (rawEntries || [])) {
       const entry = sanitizeEntry(candidate)
@@ -3185,17 +3388,12 @@ export function apply(ctx) {
         skipped += 1
         continue
       }
+      // Truncation travels per item and is only REPORTED for items that are
+      // actually staged: an item later skipped as a fallback duplicate must
+      // not inflate the truncation disclosure (or the inserted-count).
       const cut = truncatedFields(candidate)
-      if (cut.length > 0) {
-        // sanitizeEntry enforces the limits silently, which is fine for the
-        // editor (its inputs carry the same maxLength) but wrong here: an
-        // imported 7,000-character instruction would come back as 6,000 with
-        // nothing said about the loss.
-        truncatedCount += 1
-        for (const field of cut) cutFields.add(field)
-      }
       entry.updatedAt = Date.now()
-      accepted.push({ entry, wanted })
+      accepted.push({ entry, wanted, cut })
       seenIds.add(wanted + '\u0000' + entry.id)
       seenBodies.add(bodyKey(wanted, entry.title, entry.content))
     }
@@ -3206,8 +3404,6 @@ export function apply(ctx) {
     const seenProfileIds = new Set(existingProfiles.map((profile) => profile.setId + '\u0000' + profile.id))
     const seenProfileBodies = new Set(existingProfiles.map((profile) => profile.setId + '\u0000' + profile.name + '\u0000' + profile.content))
     const acceptedProfiles = []
-    const cutProfileFields = new Set()
-    let truncatedProfileCount = 0
     let skippedProfiles = 0
     for (const candidate of (rawProfiles || [])) {
       const profile = sanitizeProfile(candidate)
@@ -3226,25 +3422,11 @@ export function apply(ctx) {
         continue
       }
       const cut = truncatedProfileFields(candidate)
-      if (cut.length > 0) {
-        truncatedProfileCount += 1
-        for (const field of cut) cutProfileFields.add(field)
-      }
       profile.updatedAt = Date.now()
-      acceptedProfiles.push({ profile, wanted })
+      acceptedProfiles.push({ profile, wanted, cut })
       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 +3443,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) {
-        item.entry.setId = finalIdOf(item.wanted)
-        state.data.entries.push(item.entry)
+        finalSeenIds.add(item.wanted + '\u0000' + item.entry.id)
+        finalSeenBodies.add(bodyKey(item.wanted, item.entry.title, item.entry.content))
+      }
+      for (const item of accepted) {
+        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)
+      }
+      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)
       }
+    }
+    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 item of stagedEntries) state.data.entries.push(item.entry)
+      for (const item of stagedProfiles) state.data.profiles.push(item.profile)
     })
     const parts = []
     if (createdSets.length > 0) {
@@ -3284,19 +3535,41 @@ export function apply(ctx) {
     if (fellBack > 0) {
       parts.push('有 ' + fellBack + ' 项因原配置集不存在或已达 ' + MAX_SETS + ' 个上限，已归入当前配置集')
     }
-    if (accepted.length > 0) {
-      const truncated = truncatedCount > 0
-        ? '；其中 ' + truncatedCount + ' 条超过长度上限，' + [...cutFields].join('、') + '已被截断'
+    if (dedupedOnFallback > 0) {
+      parts.push('另有 ' + dedupedOnFallback + ' 项因回退到当前配置集后与已有内容重复被跳过')
+    }
+    if (stagedEntries.length > 0) {
+      // Counts quote what actually LANDED: staged ⊆ accepted, and the gap is
+      // the fallback duplicates already disclosed on their own line — an
+      // accepted-based count would claim inserts that were skipped.
+      const stagedCut = new Set()
+      let stagedTruncated = 0
+      for (const item of stagedEntries) {
+        if (item.cut.length > 0) {
+          stagedTruncated += 1
+          for (const field of item.cut) stagedCut.add(field)
+        }
+      }
+      const truncated = stagedTruncated > 0
+        ? '；其中 ' + stagedTruncated + ' 条超过长度上限，' + [...stagedCut].join('、') + '已被截断'
         : ''
-      parts.push('新增指令 ' + accepted.length + ' 条，跳过 ' + skipped + ' 条' + truncated)
+      parts.push('新增指令 ' + stagedEntries.length + ' 条，跳过 ' + skipped + ' 条' + truncated)
     } else if (skipped > 0) {
       parts.push('指令跳过 ' + skipped + ' 条（已存在或无效）')
     }
-    if (acceptedProfiles.length > 0) {
-      const truncated = truncatedProfileCount > 0
-        ? '；其中 ' + truncatedProfileCount + ' 个超过长度上限，' + [...cutProfileFields].join('、') + '已被截断'
+    if (stagedProfiles.length > 0) {
+      const stagedCut = new Set()
+      let stagedTruncated = 0
+      for (const item of stagedProfiles) {
+        if (item.cut.length > 0) {
+          stagedTruncated += 1
+          for (const field of item.cut) stagedCut.add(field)
+        }
+      }
+      const truncated = stagedTruncated > 0
+        ? '；其中 ' + stagedTruncated + ' 个超过长度上限，' + [...stagedCut].join('、') + '已被截断'
         : ''
-      parts.push('新增用户形象 ' + acceptedProfiles.length + ' 个，跳过 ' + skippedProfiles + ' 个' + truncated)
+      parts.push('新增用户形象 ' + stagedProfiles.length + ' 个，跳过 ' + skippedProfiles + ' 个' + truncated)
     } else if (skippedProfiles > 0) {
       parts.push('用户形象跳过 ' + skippedProfiles + ' 个（已存在或无效）')
     }
@@ -3395,11 +3668,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 +3844,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.1",
   "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",