dsh-fish-memory 1.5.5 → 1.5.6

package/lib/index.js

@@ -11,6 +11,7 @@
 //   3. 注   —— 注入到它自己的系统提示词里，**每条都带时间**
 
 import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, copyFileSync, rmSync, statSync, renameSync, constants } from 'node:fs'
+import { 建准入, 包准入 } from './准入.mjs'
 import { homedir } from 'node:os'
 import { join, basename, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -33,7 +34,9 @@ try { for (const n of (hostDeps.notes || [])) diag('hostdeps: ' + n) } catch (e)
 import * as 生成档案 from './生成档案.js'
 
 export const name = 'memory'
-export const inject = ['systemPrompt', 'agents', 'timer', 'tools', 'webServer', 'sessions', 'sessionTitle', 'llm']
+// webServer 不放进 inject：放进去就是硬依赖，没有网页服务的 profile（比如只跑 QQ 机器人的无界面部署）
+// 整个插件会一直 pending、记忆完全不工作。设置页的路由在下面用 ctx.inject(['webServer']) 按需挂。
+export const inject = ['systemPrompt', 'agents', 'timer', 'tools', 'sessions', 'sessionTitle', 'llm']
 
 const CFG_DIR = process.env.DSH_HOME || join(homedir(), '.dsh')
 const STORE_DIR = join(CFG_DIR, 'fish-memory')
@@ -1748,6 +1751,19 @@ function 解析扩词(文本, 条数) {
  *   · 模型没回可用的词（思考吃光预算那种）就安静退出，下次再说。
  * 返回补了几条（调试用）。
  */
+// 同一个库的后台扩词排成一队，一个跑完再跑下一个：
+//   「记完顺手扩」和「搜空补一条」可能同时起跑，都是「等模型 → 重读 → 改几条 → 写回」，
+//   两份都挑中同一批没扩过的条目时，白花一次模型调用，后写的还会按时间盖掉先写的结果。
+const 后台队 = new Map() // sid -> 队尾 promise
+function 后台排队(sid, 活) {
+  const 尾 = (后台队.get(sid) || Promise.resolve())
+    .then(活)
+    .catch((error) => diag('后台整理失败（已忽略）：' + ((error && error.message) || error)))
+  后台队.set(sid, 尾)
+  尾.then(() => { if (后台队.get(sid) === 尾) 后台队.delete(sid) })
+  return 尾
+}
+
 async function 自动扩词(ctx, sid, 上限 = 2) {
   try {
     if (!sid) return 0
@@ -3322,6 +3338,50 @@ function 按键收敛(data, 被谁) {
 //   （2026-09-23 尺子换成按词比，这个数跟着重量过，0.80 仍然合适）
 const 召回重复门槛 = 0.8
 
+// 常驻层：长期事实每轮固定带 factsMax 条（按重要度、再按时间）。scored 里有的沿用它的分数行。
+// 抽成函数是因为问句门挡下的那条早退路径也要用（见 recall 里的说明）。
+function 选常驻事实(memories, scored, policy) {
+  const 事实上限 =
+    typeof policy.factsMax === 'number' && policy.factsMax >= 0 ? Math.floor(policy.factsMax) : 2
+  const 常驻事实 = []
+  if (事实上限 > 0) {
+    const 候选 = memories
+      .filter((m) => m && m.category === 'stable_profile')
+      .slice()
+      .sort(
+        (a, b) =>
+          (Number(b.importance) || 0) - (Number(a.importance) || 0) ||
+          (Date.parse(b.createdAt || b.at || 0) || 0) - (Date.parse(a.createdAt || a.at || 0) || 0),
+      )
+    const 行表 = new Map()
+    for (const row of scored) if (row && row.m) 行表.set(String(row.m.id), row)
+    for (const m of 候选.slice(0, 事实上限)) {
+      const row = 行表.get(String(m.id)) || { m, s: { P: 1, C: 1, timeHit: 1 } }
+      row.omission = null // 常驻的不算「被筛掉」
+      row.常驻 = true
+      常驻事实.push(row)
+    }
+  }
+  return 常驻事实
+}
+
+// 按「注入字数上限」收：第一条总能进，后面的超了就这趟先不进
+function 按字数收(rows, policy) {
+  const 上限 = typeof policy.maxChars === 'number' && policy.maxChars > 0 ? policy.maxChars : 800
+  const selected = []
+  let 字数 = 0
+  for (const row of rows) {
+    const n = String(row.m.text || '').length
+    if (selected.length > 0 && 字数 + n > 上限) {
+      row.omission = 'budget'
+      continue
+    }
+    selected.push(row)
+    字数 += n
+  }
+  return { selected, 字数 }
+}
+
 function recall(data, query, now, sid) {
   const policy = data.policy
   // ⭐ 2026-09-21（E）：**提炼判成「跳过」的，不再参与召回** ✓
@@ -3357,7 +3417,11 @@ function recall(data, query, now, sid) {
     const v = 问句信息量(sid, query, df)
     if (v < 门槛) {
       // 这道门挡下来的时候**不做 851 次打分**，省一趟；理由照样记进 trace 给她看 ✓
-      return { selected: [], scored: [], 字数: 0, gate: { 信息量: Number(v.toFixed(2)), 门槛 } }
+      // ⚠ 但**常驻层照带**：常驻的意义就是不看这句话问了什么（issue #14）。
+      //   以前这里直接返回空 —— 「在吗」「我是谁」这种短句一被挡，长期事实也跟着没了 ✗
+      const 常驻 = 选常驻事实(memories, [], policy)
+      const 带上 = 按字数收(常驻, policy)
+      return { selected: 带上.selected, scored: 常驻, 字数: 带上.字数, gate: { 信息量: Number(v.toFixed(2)), 门槛, 挡了: true } }
     }
     gate = { 信息量: Number(v.toFixed(2)), 门槛 }
   }
@@ -3513,27 +3577,7 @@ function recall(data, query, now, sid) {
   //
   //   ⚠ 只改「谁进来、名额怎么分」，不改打分和门槛 —— 事件该不该进还是那套尺子说了算。
   //   ⚠ 事实按「重要度 → 时间」取，不按分数：常驻层的意义就是不依赖这句话。
-  const 事实上限 =
-    typeof policy.factsMax === 'number' && policy.factsMax >= 0 ? Math.floor(policy.factsMax) : 2
-  const 常驻事实 = []
-  if (事实上限 > 0) {
-    const 候选 = memories
-      .filter((m) => m && m.category === 'stable_profile')
-      .slice()
-      .sort(
-        (a, b) =>
-          (Number(b.importance) || 0) - (Number(a.importance) || 0) ||
-          (Date.parse(b.createdAt || b.at || 0) || 0) - (Date.parse(a.createdAt || a.at || 0) || 0),
-      )
-    const 行表 = new Map()
-    for (const row of scored) if (row && row.m) 行表.set(String(row.m.id), row)
-    for (const m of 候选.slice(0, 事实上限)) {
-      const row = 行表.get(String(m.id)) || { m, s: { P: 1, C: 1, timeHit: 1 } }
-      row.omission = null // 常驻的不算「被筛掉」
-      row.常驻 = true
-      常驻事实.push(row)
-    }
-  }
+  const 常驻事实 = 选常驻事实(memories, scored, policy)
   // 普通事件：从去重后的候选里按分数拿，受 maxItems 和「这趟上限」两条约束
   const 事件们 = 去重后.map((x) => x.row).filter((row) => !row.m || row.m.category !== 'stable_profile')
   const 最高事件分 = 事件们.length && 事件们[0].s ? 事件们[0].s.C : 0
@@ -3544,18 +3588,7 @@ function recall(data, query, now, sid) {
     if (!row.omission) row.omission = 'weak' // 设置页上会写「这趟给的条数到顶了」
   }
 
-  const 上限 = typeof policy.maxChars === 'number' && policy.maxChars > 0 ? policy.maxChars : 800
-  const selected = []
-  let 已用 = 0
-  for (const row of 条数内) {
-    const n = String(row.m.text || '').length
-    if (selected.length > 0 && 已用 + n > 上限) {
-      row.omission = 'budget'
-      continue
-    }
-    selected.push(row)
-    已用 += n
-  }
+  const { selected, 字数: 已用 } = 按字数收(条数内, policy)
   const ids = new Set(selected.map((r) => r.m.id))
   for (const row of picked) {
     if (row.omission) continue // 别把 budget 覆盖成 limit
@@ -3651,7 +3684,7 @@ function makeRememberTool(ctx) {
       importance: {
         type: 'number',
         description:
-          '**要不要每轮都挂在她眼前**（不是「重不重要」）：1 = 不主动提就会出事的（称呼忌讳、约定承诺、' +
+          '**要不要每轮都挂在她眼前**（不是「重不重要」）：1 = 不主动提就会出事的（' + userPronoun() + '的名字和你该怎么称呼' + userPronoun() + '、称呼忌讳、约定承诺、' +
           '身体禁忌、生日纪念日）；0.5 = 其余全部（性格、喜好、书单、游戏、发生过的事）。拿不准写 0.5。',
       },
       tags: {
@@ -3861,9 +3894,7 @@ function makeRememberTool(ctx) {
       //    ⚠️ 不 await（模型调用要几秒，不能卡住记账）；但**必须 .catch** ——
       //      裸的 rejected promise 会被 Node 当致命错误，整个宿主退出（今天早上刚踩过）
       try {
-        Promise.resolve()
-          .then(() => 自动扩词(ctx, sid, 2))
-          .catch((error) => diag('自动扩词失败：' + ((error && error.message) || error)))
+        后台排队(sid, () => 自动扩词(ctx, sid, 2))
       } catch (error) {}
       if (作废的.length) diag('remember：顺手把 ' + 作废的.length + ' 条旧的标成「已被取代」：' + 作废的.join(','))
       return {
@@ -4460,14 +4491,15 @@ export function apply(ctx) {
           //   所以只有原词能命中、分数卡在门槛下。搜空的时候顺手补一条 —— 下次它就有词可命中了。
           //   节流 60 秒、一次只补一条，免得一搜不到就一连串模型调用。
           try {
-            if (!selected.length && !gate) {
+            // ⚠ 原来写的是 `!gate` —— 可门放行时 gate 也是个对象（记着信息量），
+            //   所以说过 20 句以后这里就再没进来过。要判的是「是不是被门挡了」。
+            //   常驻层那几条每轮都在，不算「挑中了」—— 看的是事件有没有挑中。
+            if (!selected.some((r) => !r.常驻) && !(gate && gate.挡了)) {
               const 现 = Date.now()
               const 待补 = scored.find((r) => r.omission === 'below_threshold')
               if (待补 && 现 - 上次补词 > 60000) {
                 上次补词 = 现
-                Promise.resolve()
-                  .then(() => 自动扩词(ctx, sid, 1))
-                  .catch(() => {})
+                后台排队(sid, () => 自动扩词(ctx, sid, 1))
               }
             }
           } catch (error) {}
@@ -4650,6 +4682,100 @@ export function apply(ctx) {
     } catch (error) {}
   }
 
+  // ⭐ 1.6.5（issue #27）：把一个 agent 挂上记忆 —— 抽出来，tick 和 agent/created 都走这里。
+  //   起因：有的机器上 `ctx.agents.list()` 一直是空的，光靠 tick 轮询什么都挂不上；
+  //   而 `agent/created` 事件本身带着 agent，不依赖那个列表。
+  function 挂一个(agent) {
+    try {
+      const 归档的 = 归档名单(ctx)
+      const sid = sessionIdOf(agent.session)
+      if (!sid) { diag('  跳过：拿不到会话 id'); return }
+      // 归档了就不再注入，而且把它卸下来 —— 归档=藏起来，不该还占她的上下文 ✓
+      if (归档的.has(sid)) {
+        const v = mounted.get(sid)
+        if (v) {
+          卸掉挂载(v)
+          mounted.delete(sid)
+          diag('  归档了，卸下 ' + sid)
+        }
+        return
+      }
+      // 子代理（派出去干活的）不挂记忆：它只做一件事，给它建一份库既没用又白写文件
+      if (是子代理(agent)) {
+        const v = mounted.get(sid)
+        if (v) {
+          卸掉挂载(v)
+          mounted.delete(sid)
+          diag('  子代理，卸下 ' + sid)
+        }
+        return
+      }
+      // 分支出来的会话：先把来处的记忆继承过来（每个会话只查一次）
+      if (!查过分支.has(sid)) {
+        查过分支.add(sid)
+        try {
+          继承分支记忆(agent, sid)
+        } catch (error) {
+          diag('  分支继承失败：' + (error && error.message))
+        }
+      }
+      // ⭐ 2026-09-21 修：**关掉了就要卸下来**
+      //
+      // 原来这两句的顺序是反的：
+      //     if (mounted.has(sid)) continue     ← 挂着就直接跳过
+      //     if (!isEnabled(sid)) continue      ← 关着的只是「不挂新的」
+      // 所以**把开关从开改成关，它不会卸** —— 已经挂上的注入和工具会一直留着，
+      // 只有「归档」那条路才会卸。「插件关了怎么还在写」
+      // 就是这个：关掉之后工具还在她的工具列表里 ✗
+      if (!isEnabled(sid)) {
+        const v = mounted.get(sid)
+        if (v) {
+          卸掉挂载(v)
+          mounted.delete(sid)
+          diag('  关了，卸下 ' + sid)
+        }
+        return
+      }
+      // ⭐⭐ 2026-10-24 修（用户报：「已经有消息的会话，开记忆拿不到 remember 工具」）：
+      //   原来这里只按**会话 id** 记账（`mounted.has(sid)`）——只要挂过一次，
+      //   以后这个会话就再也不挂。可 **agent 实例是会被换掉的**
+      //   （会话重开、插件重载、宿主重建 agent 都会换一个新对象），
+      //   旧注册跟着旧 ctx 一起没了，而我们这边的账还写着「已挂上」⇒ 永远不重挂 ✗
+      //   症状正好是：空会话开记忆→当场挂在活着的那个 agent 上→能用；
+      //   有消息的会话→早就被换过实例→记账说挂上了、实际那个实例上没有工具。
+      //   → 现在连**实例**一起记：实例变了就卸旧的、重新挂。
+      const 已挂 = mounted.get(sid)
+      if (已挂 && 已挂.agent === agent) return // 还是同一个 agent，不用重挂
+      if (已挂) {
+        卸掉挂载(已挂)
+        mounted.delete(sid)
+        diag('  agent 实例换过了，重挂 ' + sid)
+      }
+      diag('  试挂 ' + sid)
+      try {
+        const off = mountFor(agent, sid)
+        // ⭐ 1.3.9（issue #15）：**模型侧也要看得见 remember**。
+        //   只在插件层全局注册时，新会话组装出来的工具表里没有它（旧会话因为重建过才碰巧有），
+        //   模型直接 unknown tool。这里再按 agent 注册一份 —— 同名会盖住全局那份，不会变成两个。
+        let 工具off2 = null
+        try {
+          const at = agent && agent.ctx && agent.ctx.tools
+          if (at && typeof at.register === 'function' && globalOn()) {
+            工具off2 = at.register(makeRememberTool(ctx))
+          }
+        } catch (error) {
+          diag('  按 agent 注册 remember 失败：' + (error && error.message))
+        }
+        mounted.set(sid, { sid, agent, off, 工具off: 工具off2 })
+        diag('  ✓ 挂上 ' + sid + '（' + loadStore(sid).memories.length + ' 条）')
+      } catch (error) {
+        diag('  ✗ 挂 ' + sid + ' 失败：' + (error && error.message))
+      }
+    } catch (error) {
+      diag('  挂一个出错：' + (error && error.message))
+    }
+  }
+
   // 给每个活着的 agent 挂它自己的那段记忆
   let 上次心跳 = ''        // 只用来判断「agents 数变了没」，不再每 3 秒写一行日志
   function tick() {
@@ -4661,91 +4787,12 @@ export function apply(ctx) {
       // 2026-10-25（issue #2）：这行以前每 3 秒无条件写，占整个日志的 97%；
       // 心跳没什么诊断价值 —— 只在「agent 数变了」时记一条。
       const 心跳 = 'agents=' + list.length
-      if (心跳 !== 上次心跳) { 上次心跳 = 心跳; diag('tick：' + 心跳) }
+      if (心跳 !== 上次心跳) {
+        上次心跳 = 心跳
+        diag('tick：' + 心跳 + (list.length ? '' : '（一个 agent 都没拿到 —— 靠 agent/created 那条兜底挂）'))
+      }
       for (const agent of list) {
-        const sid = sessionIdOf(agent.session)
-        if (!sid) { diag('  跳过：拿不到会话 id'); continue }
-        // 归档了就不再注入，而且把它卸下来 —— 归档=藏起来，不该还占她的上下文 ✓
-        if (归档的.has(sid)) {
-          const v = mounted.get(sid)
-          if (v) {
-            卸掉挂载(v)
-            mounted.delete(sid)
-            diag('  归档了，卸下 ' + sid)
-          }
-          continue
-        }
-        // 子代理（派出去干活的）不挂记忆：它只做一件事，给它建一份库既没用又白写文件
-        if (是子代理(agent)) {
-          const v = mounted.get(sid)
-          if (v) {
-            卸掉挂载(v)
-            mounted.delete(sid)
-            diag('  子代理，卸下 ' + sid)
-          }
-          continue
-        }
-        // 分支出来的会话：先把来处的记忆继承过来（每个会话只查一次）
-        if (!查过分支.has(sid)) {
-          查过分支.add(sid)
-          try {
-            继承分支记忆(agent, sid)
-          } catch (error) {
-            diag('  分支继承失败：' + (error && error.message))
-          }
-        }
-        // ⭐ 2026-09-21 修：**关掉了就要卸下来**
-        //
-        // 原来这两句的顺序是反的：
-        //     if (mounted.has(sid)) continue     ← 挂着就直接跳过
-        //     if (!isEnabled(sid)) continue      ← 关着的只是「不挂新的」
-        // 所以**把开关从开改成关，它不会卸** —— 已经挂上的注入和工具会一直留着，
-        // 只有「归档」那条路才会卸。「插件关了怎么还在写」
-        // 就是这个：关掉之后工具还在她的工具列表里 ✗
-        if (!isEnabled(sid)) {
-          const v = mounted.get(sid)
-          if (v) {
-            卸掉挂载(v)
-            mounted.delete(sid)
-            diag('  关了，卸下 ' + sid)
-          }
-          continue
-        }
-        // ⭐⭐ 2026-10-24 修（用户报：「已经有消息的会话，开记忆拿不到 remember 工具」）：
-        //   原来这里只按**会话 id** 记账（`mounted.has(sid)`）——只要挂过一次，
-        //   以后这个会话就再也不挂。可 **agent 实例是会被换掉的**
-        //   （会话重开、插件重载、宿主重建 agent 都会换一个新对象），
-        //   旧注册跟着旧 ctx 一起没了，而我们这边的账还写着「已挂上」⇒ 永远不重挂 ✗
-        //   症状正好是：空会话开记忆→当场挂在活着的那个 agent 上→能用；
-        //   有消息的会话→早就被换过实例→记账说挂上了、实际那个实例上没有工具。
-        //   → 现在连**实例**一起记：实例变了就卸旧的、重新挂。
-        const 已挂 = mounted.get(sid)
-        if (已挂 && 已挂.agent === agent) continue // 还是同一个 agent，不用重挂
-        if (已挂) {
-          卸掉挂载(已挂)
-          mounted.delete(sid)
-          diag('  agent 实例换过了，重挂 ' + sid)
-        }
-        diag('  试挂 ' + sid)
-        try {
-          const off = mountFor(agent, sid)
-          // ⭐ 1.3.9（issue #15）：**模型侧也要看得见 remember**。
-          //   只在插件层全局注册时，新会话组装出来的工具表里没有它（旧会话因为重建过才碰巧有），
-          //   模型直接 unknown tool。这里再按 agent 注册一份 —— 同名会盖住全局那份，不会变成两个。
-          let 工具off2 = null
-          try {
-            const at = agent && agent.ctx && agent.ctx.tools
-            if (at && typeof at.register === 'function' && globalOn()) {
-              工具off2 = at.register(makeRememberTool(ctx))
-            }
-          } catch (error) {
-            diag('  按 agent 注册 remember 失败：' + (error && error.message))
-          }
-          mounted.set(sid, { sid, agent, off, 工具off: 工具off2 })
-          diag('  ✓ 挂上 ' + sid + '（' + loadStore(sid).memories.length + ' 条）')
-        } catch (error) {
-          diag('  ✗ 挂 ' + sid + ' 失败：' + (error && error.message))
-        }
+        挂一个(agent)
       }
     } catch (error) {}
   }
@@ -4762,6 +4809,18 @@ export function apply(ctx) {
   } catch (error) {
     console.error('[记忆] 定时器不可用（不影响对话）：' + (error && error.message))
   }
+
+  // ⭐ 1.6.5（issue #27）：光靠轮询不够 —— 事件来了就当场挂，不看 list()
+  try {
+    ctx.on('agent/created', (payload) => {
+      try {
+        const a = payload && payload.agent
+        if (a) 挂一个(a)
+      } catch (error) {}
+    })
+  } catch (error) {
+    diag('agent/created 挂不上（不影响对话）：' + (error && error.message))
+  }
   ctx.effect(() => () => {
     for (const v of mounted.values()) 卸掉挂载(v)
     mounted.clear()
@@ -4806,25 +4865,20 @@ export function apply(ctx) {
      *   宁可这一版防不住，也不能因为宿主换个版本就把设置页锁死。
      *   真正拒绝只有一种情况：宿主**明确**说这个请求不合法（401 / 403）。
      */
-    const 只认本人 = (handler) => async (req, res) => {
-      try {
-        const 连接 = ctx.get('connection')
-        const 拒 = 连接 && typeof 连接.requestRejection === 'function' ? 连接.requestRejection(req) : undefined
-        if (拒 === 401 || 拒 === 403) {
-          diag('管理接口拒了一次外来请求（' + 拒 + '）：' + String((req && req.url) || ''))
-          try {
-            res.writeHead(拒, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
-            res.end(JSON.stringify({ ok: false, error: 拒 === 401 ? 'authentication_required' : 'management_forbidden' }))
-          } catch (e2) {}
-          return
-        }
-      } catch (error) {
-        // 鉴权这条路自己坏了 → 放行，绝不让设置页打不开
-      }
-      return handler(req, res)
-    }
-
+    // ⭐ 1.5.7（issue #35）：准入改成**失败即拒绝**。
+    //   以前这里在拿不到 connection、或者 requestRejection 自己抛错时放行 ——
+    //   于是本机任意网页都能打到管理接口（包括一键安装）。现在判不了就拒。
+    const 准入 = 建准入(ctx, diag)
+    const 只认本人 = (handler) => 包准入(准入, handler, diag)
+
+    // ⭐ 网页服务是可选的：有 webServer 才挂设置页（跟 DSH 自己的写法一样，ctx.inject 按服务在不在挂/卸）。
+    //   没有网页服务时（无界面 profile）记忆照常记、照常想起来，只是没有设置页 —— 而不是整个插件起不来。
+    //   宿主没有 ctx.inject（老宿主 / 测试替身）就照旧直接挂。
     const mroute = (path, handler) =>
+      typeof ctx.inject === 'function'
+        ? ctx.inject(['webServer'], (c) => 挂路由(c, path, handler))
+        : 挂路由(ctx, path, handler)
+    const 挂路由 = (ctx, path, handler) =>
       ctx.effect(() =>
         ctx.webServer.register({
           kind: 'exact',
@@ -4847,12 +4901,11 @@ export function apply(ctx) {
       packageRoot: join(dirname(fileURLToPath(import.meta.url)), '..'),
       diag,
     })
-    mroute('/dsh-fish-memory/update', async (req, res) => {
-      const u = new URL(req.url, 'http://127.0.0.1')
-      const r = await 自查更新.check(u.searchParams.get('refresh') === '1')
-      res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
-      res.end(JSON.stringify({ ok: true, ...r }))
-    })
+    // ⭐ 1.5.7（issue #35）：
+    //   ① `/install`（一键更新）以前**根本没注册** —— 设置页那个按钮点了只会 404；
+    //   ② 而 `selfupdate.register()` 里的两个路由又不带准入。
+    //   现在统一走它，并且把准入一起传进去：两个路由都受管，按钮也真的能用。
+    自查更新.register(ctx, '/dsh-fish-memory', 准入)
 
     mroute('/dsh-fish-memory/page', (req, res) => {
       res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' })
@@ -7231,6 +7284,8 @@ export {
  *   ⚠ 只给测试用，不要在生产代码里调；里面都是纯函数或内部状态读取。
  */
 export const __测试 = {
+  选常驻事实,
+  后台排队,
   工作区目录名,
   扫会话目录,
   会话的工作区,

package/lib/selfupdate.mjs

@@ -186,16 +186,32 @@ export function createSelfUpdate({ packageRoot, diag }) {
     }
   }
 
-  function register(ctx, route) {
+  function register(ctx, route, 准入) {
     const send = (res, code, obj) => {
       res.writeHead(code, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
       res.end(JSON.stringify(obj))
     }
+    // ⭐ 1.5.7（issue #35）：这两个路由以前**没有准入** —— 本机任意网页都能触发安装。
+    //   现在一律先过准入（失败即拒绝）。
+    const 过 = (handler) => async (req, res) => {
+      if (typeof 准入 === 'function') {
+        const 结果 = 准入(req)
+        if (结果) {
+          try { log('管理接口拒了一次（' + 结果.码 + '，' + 结果.说 + '）：' + String((req && req.url) || '')) } catch (e) {}
+          return send(res, 结果.码, {
+            ok: false,
+            error: 结果.码 === 401 ? 'authentication_required'
+              : 结果.码 === 503 ? 'management_unavailable' : 'management_forbidden',
+          })
+        }
+      }
+      return handler(req, res)
+    }
     try {
       ctx.effect(() => ctx.webServer.register({
         kind: 'exact',
         path: route + '/update',
-        handler: async (req, res) => {
+        handler: 过(async (req, res) => {
           try {
             const url = new URL(req.url, 'http://127.0.0.1')
             const force = url.searchParams.get('refresh') === '1'
@@ -204,13 +220,13 @@ export function createSelfUpdate({ packageRoot, diag }) {
             log('查更新路由失败：' + (e && e.message))
             send(res, 200, { ok: false, current, latest: null, error: String((e && e.message) || e) })
           }
-        },
+        }),
       }))
       // ⭐ 一键更新：POST。装完的结果原样带回去（可能要重启才生效）
       ctx.effect(() => ctx.webServer.register({
         kind: 'exact',
         path: route + '/install',
-        handler: async (req, res) => {
+        handler: 过(async (req, res) => {
           if (req.method !== 'POST') { send(res, 405, { ok: false, error: '只接受 POST' }); return }
           try {
             const r = await install(ctx)
@@ -219,7 +235,7 @@ export function createSelfUpdate({ packageRoot, diag }) {
             log('一键更新路由失败：' + (e && e.message))
             send(res, 200, { ok: false, error: String((e && e.message) || e) })
           }
-        },
+        }),
       }))
     } catch (e) {
       log('查更新路由注册失败：' + (e && e.message))

package/lib//345/207/206/345/205/245.mjs

@@ -0,0 +1,63 @@
+/**
+ * 管理接口的准入 —— 失败即拒绝（issue #35）。
+ *
+ * 以前 `只认本人` 在拿不到 connection、或者 requestRejection 自己抛错时**放行**，
+ * 于是本机任意网页都能打到 `/dsh-fish-memory/install`（一键安装包）。
+ * 现在反过来：**判不了就拒**，宁可设置页多试一次，也不让别人的网页能装东西。
+ */
+
+const 本地来源 = /^(?:dsh-app:|https?:\/\/(?:127\.0\.0\.1|localhost|\[::1\])(?::\d+)?\/?$)/i
+
+/**
+ * 建一个准入函数。返回 null = 放行；返回 { 码, 说 } = 拒绝。
+ */
+export function 建准入(ctx, 记账 = () => {}) {
+  return function 准入(req) {
+    let 拒
+    try {
+      const 连接 = ctx.get('connection')
+      if (!连接 || typeof 连接.requestRejection !== 'function') {
+        // ⚠ 失败即拒绝：拿不到宿主的准入服务，就当这个请求不可信
+        return { 码: 503, 说: '拿不到宿主的 connection 服务' }
+      }
+      拒 = 连接.requestRejection(req)
+    } catch (error) {
+      return { 码: 503, 说: '准入服务自己抛错：' + ((error && error.message) || error) }
+    }
+    if (拒 === 401 || 拒 === 403) return { 码: 拒, 说: '宿主判了外来请求' }
+
+    // 再兜一层：浏览器带的「跨站」标记 / 不是本机来的 Origin
+    const 头 = (req && req.headers) || {}
+    if (String(头['sec-fetch-site'] || '').toLowerCase() === 'cross-site') {
+      return { 码: 403, 说: '跨站请求' }
+    }
+    const 源 = String(头.origin || '')
+    if (源 && !本地来源.test(源)) return { 码: 403, 说: '来源不是本机：' + 源.slice(0, 80) }
+    return null
+  }
+}
+
+/**
+ * 包一个路由处理器：先过准入，拒了就回 JSON。
+ */
+export function 包准入(准入, handler, 记账 = () => {}) {
+  return async function 带准入的(req, res) {
+    const 结果 = 准入(req)
+    if (结果) {
+      try {
+        记账('管理接口拒了一次（' + 结果.码 + '，' + 结果.说 + '）：' + String((req && req.url) || ''))
+      } catch (error) {}
+      try {
+        res.writeHead(结果.码, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
+        res.end(JSON.stringify({
+          ok: false,
+          error: 结果.码 === 401 ? 'authentication_required'
+            : 结果.码 === 503 ? 'management_unavailable' : 'management_forbidden',
+          说: 结果.说,
+        }))
+      } catch (error) {}
+      return
+    }
+    return handler(req, res)
+  }
+}

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "dsh-fish-memory",
-  "version": "1.5.5",
-  "description": "给 DSH 里的会话一份会淡忘的长期记忆，每条都带时间。",
-  "license": "SEE LICENSE IN LICENSE",
-  "type": "module",
-  "engines": {
-    "node": ">=22",
-    "dsh": ">=0.2.1-rc.2"
-  },
-  "keywords": [
-    "deepseek-harness",
-    "dsh-plugin",
-    "memory",
-    "long-term-memory",
-    "ai-companion"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Yuuyuko-uu/dsh-fish-memory.git"
-  },
-  "main": "lib/index.js",
-  "exports": {
-    ".": "./lib/index.js",
-    "./client": "./lib/client.js",
-    "./cordis.patch.yml": "./cordis.patch.yml",
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "lib",
-    "cordis.patch.yml",
-    "README.md"
-  ],
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "platform": "web",
-      "inject": [
-        "slots"
-      ],
-      "external": [
-        "react"
-      ]
-    }
-  },
-  "peerDependencies": {
-    "@deepseek-ai/dsh-tools": "*",
-    "@deepseek-ai/dsh-llm": "*"
-  },
-  "peerDependenciesMeta": {
-    "@deepseek-ai/dsh-tools": {
-      "optional": true
-    },
-    "@deepseek-ai/dsh-llm": {
-      "optional": true
-    }
-  }
-}
+{
+  "name": "dsh-fish-memory",
+  "version": "1.5.6",
+  "description": "给 DSH 里的会话一份会淡忘的长期记忆，每条都带时间。",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "engines": {
+    "node": ">=22",
+    "dsh": ">=0.2.1-rc.2"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh-plugin",
+    "memory",
+    "long-term-memory",
+    "ai-companion"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Yuuyuko-uu/dsh-fish-memory.git"
+  },
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "slots"
+      ],
+      "external": [
+        "react"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-tools": "*",
+    "@deepseek-ai/dsh-llm": "*"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-tools": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    }
+  }
+}