memory-eternal 0.9.6 → 0.9.8

package/lib/node-bin.js

@@ -0,0 +1,99 @@
+// 记忆核心 · 子进程用的 node 可执行文件解析
+//
+// 背景（真实故障）：
+// 在 Electron 宿主里（例如 DSH Desktop），`process.execPath` 指向的是
+// Electron 主程序，而不是 node。此前 `ensureWebServer()` / watchdog / 插件的
+// 保活逻辑都用 `spawn(process.execPath, ['.../web.js', ...])` 拉起子进程，
+// 于是在 Electron 宿主下 spawn 出来的是「第二个 Electron 实例」：
+// 它不会执行 web.js，而是立刻退出（或被单实例锁挡掉），而调用方用的是
+// `stdio: 'ignore'` + `.catch(() => {})`，失败被彻底吞掉——表现就是侧边栏
+// 「记忆」弹窗里那个指向 127.0.0.1:7999 的 iframe 永远白屏。
+//
+// 本模块把「找出一个真正能跑 node 脚本的子进程入口」收敛到一处：
+//   1. MEMORY_ETERNAL_NODE 显式指定（逃生口，便于测试与非常规宿主）；
+//   2. 非 Electron 宿主：process.execPath 本身就是 node，直接用；
+//   3. Electron 宿主：优先从 PATH 找真正的 node；
+//   4. 都找不到时退回 process.execPath，并由 childEnv() 打开
+//      ELECTRON_RUN_AS_NODE，让 Electron 二进制以纯 node 模式运行。
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+let cachedBinary = null
+let cachedSource = null
+
+/** 在 PATH 中查找真正的 node 可执行文件；找不到返回 null。 */
+function findNodeOnPath() {
+  const names = process.platform === 'win32' ? ['node.exe', 'node.cmd', 'node'] : ['node', 'node.exe']
+  const dirs = String(process.env.PATH || '').split(path.delimiter)
+  for (const dir of dirs) {
+    if (!dir) continue
+    for (const name of names) {
+      const candidate = path.join(dir, name)
+      try {
+        if (fs.statSync(candidate).isFile()) return candidate
+      } catch {
+        // 目录不存在或无权访问：继续找下一个
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * 返回用于 spawn 子进程（跑 .js 脚本）的可执行文件路径。
+ * @returns {string}
+ */
+export function nodeBinary() {
+  if (cachedBinary) return cachedBinary
+
+  if (process.env.MEMORY_ETERNAL_NODE) {
+    cachedBinary = process.env.MEMORY_ETERNAL_NODE
+    cachedSource = 'env'
+    return cachedBinary
+  }
+
+  if (!process.versions.electron) {
+    cachedBinary = process.execPath
+    cachedSource = 'execPath'
+    return cachedBinary
+  }
+
+  const found = findNodeOnPath()
+  if (found) {
+    cachedBinary = found
+    cachedSource = 'path'
+    return cachedBinary
+  }
+
+  cachedBinary = process.execPath
+  cachedSource = 'electron-run-as-node'
+  return cachedBinary
+}
+
+/** 说明 nodeBinary() 最终选了哪条路径（诊断用，不参与逻辑）。 */
+export function nodeBinarySource() {
+  nodeBinary()
+  return cachedSource
+}
+
+/**
+ * 子进程环境：始终打开 ELECTRON_RUN_AS_NODE。
+ * 真正的 node 会忽略这个变量，所以无条件设置是安全的；而当 nodeBinary()
+ * 只能退回 Electron 二进制时，它就是让子进程以 node 模式运行的关键。
+ * @param {Record<string, string>} [extra]
+ */
+export function childEnv(extra) {
+  return { ...process.env, ...(extra || {}), ELECTRON_RUN_AS_NODE: '1' }
+}
+
+/** 是否只能依赖 Electron 二进制的 node 模式（PATH 上没有真 node）。 */
+export function usesElectronBinary() {
+  return nodeBinarySource() === 'electron-run-as-node'
+}
+
+/** 仅测试用：清掉进程内缓存。 */
+export function resetNodeBinaryCache() {
+  cachedBinary = null
+  cachedSource = null
+}

package/lib/stall.js

@@ -0,0 +1,30 @@
+// 记忆核心 · 「轮次收尾事件是否真的没来」判定
+//
+// 旧判据：turnsStarted > turnsStopped && claimIdleMs > 15min && idleMs > 15min。两个毛病：
+//   1) 两个计数**累积且永不归零**，而被取消/被拒的轮次不发 turn-stopping（子代理轮次同样不计）
+//      → 差额一旦出现就永久为真，判据退化成「只要空闲 15 分钟就报一次」（issue #4 的
+//      「已开始 16 / 已收尾 12，且 15 分钟无任何沉淀活动」就是这么来的）；
+//   2) 真故障的特征恰好相反：轮次**持续开始**、只是没有收尾 —— 此时 claimed 一直新鲜，
+//      claimIdleMs 条件不满足 → 真故障反而不报。
+//
+// 现在改成滑动窗口：只看「窗口内开始了几个、收尾了几个」。
+//   持续开始 + 零收尾 → 判停滞；用户离开（窗口内 0 开始）→ 不报。
+
+/**
+ * @param {object} input
+ * @param {number[]} input.claimedAt 轮次开始时间戳（ms）
+ * @param {number[]} input.stoppedAt 轮次收尾时间戳（ms）
+ * @param {number} [input.now] 当前时间
+ * @param {number} [input.windowMs] 观察窗口，默认 20 分钟
+ * @param {number} [input.minStarted] 窗口内至少开始几个轮次才判停滞，默认 3
+ * @returns {{alert:boolean, started:number, stopped:number, windowMs:number}}
+ */
+export function evaluateStall({ claimedAt = [], stoppedAt = [], now = Date.now(), windowMs = 20 * 60 * 1000, minStarted = 3 } = {}) {
+  const from = now - windowMs
+  const started = claimedAt.filter((t) => t >= from).length
+  const stopped = stoppedAt.filter((t) => t >= from).length
+  return { alert: started >= minStarted && stopped === 0, started, stopped, windowMs }
+}
+
+/** 时间戳数组的裁剪上限：只保留窗口相关的近邻，避免长跑无界增长。 */
+export const MAX_STAMPS = 200

package/lib/vault.js

@@ -561,26 +561,94 @@ export async function graph(root) {
     if (arr) arr.push(c.path)
     else tagIndex.set(t, [c.path])
   }
+  // 标签边：同标签「全连接」会爆炸 —— 593 卡时 2.4 万条边，占总 payload 的 99%，前端每帧都要遍历。
+  // 改为「按共享标签数取 Top-K」：语义仍是「靠共享标签相邻」，但边数降一个数量级。
+  // 对每张卡用标签倒排收集候选与其共享标签数，只保留权重最高的 K 个（双向去重后约 n*K/2 条）。
+  const TAG_TOPK = 6
+  const pairWeight = new Map() // `a\u0000b`（排序后）-> 已加边的共享标签数
   for (const card of cards) {
+    const weights = new Map()
     for (const tag of card.tags) {
       for (const other of tagIndex.get(tag) || []) {
-        if (other !== card.path) addEdge(card.path, other, `tag:${tag}`)
+        if (other === card.path) continue
+        weights.set(other, (weights.get(other) || 0) + 1)
       }
     }
+    // 候选不超过 K 时全连（小库/小标签簇），超过才截断 Top-K
+    const ranked = [...weights.entries()].sort((x, y) => y[1] - x[1])
+    const top = weights.size <= TAG_TOPK ? ranked : ranked.slice(0, TAG_TOPK)
+    for (const [other, w] of top) {
+      const [x, y] = [card.path, other].sort()
+      const key = `${x}\u0000${y}`
+      if ((pairWeight.get(key) || 0) >= w) continue // 已按更高权重加过这条边
+      pairWeight.set(key, w)
+      const xc = byPath.get(x)
+      const yc = byPath.get(y)
+      const shared = xc && yc ? xc.tags.find((t) => yc.tags.includes(t)) : ''
+      addEdge(x, y, shared ? `tag:${shared}` : 'tag')
+    }
   }
 
   // 相似度关联：bigram 集合只算一次（原先每对都重新分词两段正文＝指数级白烧），
   // 再用数学上界剪枝（J ≤ min/max）跳过长度比过小的配对。
   const SIM_THRESHOLD = 0.42
   const bigramsByPath = new Map()
-  for (const c of cards) bigramsByPath.set(c.path, bigramSet(bodyMap.get(c.path) || ''))
+  // df = 有多少张卡含这个 bigram。常见 bigram（df 很大）几乎均匀铺满全库，
+  // 撑不起 0.42 的 Jaccard；只用稀有 bigram 建倒排即可生成候选，避免 5.8 万对全量比对。
+  const DF_CAP = 24
+  const RARE_CAP = 120
+  const gramDf = new Map()
+  for (const c of cards) {
+    const s = bigramSet(bodyMap.get(c.path) || '')
+    bigramsByPath.set(c.path, s)
+    for (const g of s) gramDf.set(g, (gramDf.get(g) || 0) + 1)
+  }
+  const rareIndex = new Map()
+  const rareByPath = new Map()
+  for (const c of cards) {
+    const rare = []
+    for (const g of bigramsByPath.get(c.path)) if ((gramDf.get(g) || 0) <= DF_CAP) rare.push(g)
+    // 只取「最稀有」的 RARE_CAP 个参与候选生成：近重复卡一定共享大量稀有 gram，
+    // 而这一步是冷启动的真正热点（每张卡 × 每个稀有 gram 的倒排表）。
+    rare.sort((x, y) => (gramDf.get(x) || 0) - (gramDf.get(y) || 0))
+    rareByPath.set(c.path, rare.length <= RARE_CAP ? rare : rare.slice(0, RARE_CAP))
+    for (const g of rare) {
+      const arr = rareIndex.get(g)
+      if (arr) arr.push(c.path)
+      else rareIndex.set(g, [c.path])
+    }
+  }
   const similarCount = {}
-  for (let i = 0; i < cards.length; i++) for (let j = i + 1; j < cards.length; j++) {
-    const a = cards[i], b = cards[j]
-    if (a.kind !== b.kind && !a.tags.some((t) => b.tags.includes(t))) continue
-    if ((similarCount[a.path] || 0) >= 1 || (similarCount[b.path] || 0) >= 1) continue
-    const sim = jaccardSets(bigramsByPath.get(a.path), bigramsByPath.get(b.path), SIM_THRESHOLD)
-    if (sim >= SIM_THRESHOLD) { addEdge(a.path, b.path, 'similar'); addDegree(a.path); addDegree(b.path); similarCount[a.path] = (similarCount[a.path] || 0) + 1; similarCount[b.path] = (similarCount[b.path] || 0) + 1 }
+  // 标签集合预先建成 Set：原先每个配对都做 tags.some(includes) 是 O(标签数²)，配对 5.8 万次很可观。
+  const tagSetByPath = new Map(cards.map((c) => [c.path, new Set(c.tags)]))
+  // 候选生成：按共享稀有 bigram 数降序，只对候选做精确 Jaccard。
+  // 每张卡最多保留 1 条 similar 边（与旧行为一致）。
+  const sharedRare = new Map()
+  for (const card of cards) {
+    for (const gram of rareByPath.get(card.path)) {
+      for (const other of rareIndex.get(gram) || []) {
+        if (other !== card.path) sharedRare.set(other, (sharedRare.get(other) || 0) + 1)
+      }
+    }
+    if (!sharedRare.size) continue
+    // 候选上限：共享稀有 gram 最多的 40 张（近重复卡一定排在最前面，召回不受影响）
+    const ranked = [...sharedRare.entries()].sort((x, y) => y[1] - x[1])
+    const cands = ranked.length <= 40 ? ranked : ranked.slice(0, 40)
+    sharedRare.clear()
+    const A = bigramsByPath.get(card.path)
+    for (const [other, shared] of cands) {
+      if ((similarCount[card.path] || 0) >= 1) break
+      if ((similarCount[other] || 0) >= 1) continue
+      const b = byPath.get(other)
+      if (!b) continue
+      if (b.kind !== card.kind && !card.tags.some((t) => tagSetByPath.get(other).has(t))) continue
+      const B = bigramsByPath.get(other)
+      const lo = Math.min(A.size, B.size)
+      const hi = Math.max(A.size, B.size)
+      if (!hi || lo / hi < SIM_THRESHOLD) continue // 无损上界：J ≤ min/max
+      const sim = jaccardSets(A, B, SIM_THRESHOLD)
+      if (sim >= SIM_THRESHOLD) { addEdge(card.path, other, 'similar'); addDegree(card.path); addDegree(other); similarCount[card.path] = 1; similarCount[other] = 1; break }
+    }
   }
   const value = { nodes, edges }
   graphCache.set(root, { fp, value, at: Date.now() })

package/lib/watchdog.js

@@ -15,14 +15,64 @@
 
 import http from 'node:http'
 import net from 'node:net'
+import fs from 'node:fs'
+import os from 'node:os'
 import { spawn } from 'node:child_process'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import process from 'node:process'
+import { nodeBinary, childEnv } from './node-bin.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const WEB_JS = path.join(__dirname, 'web.js')
 const API_PREFIX = '/memory-eternal/api'
+// -- 单例锁 -------------------------------------------------------------------
+// 每个 DSH 启动都会 spawn 一个 detached watchdog，而旧代码没有任何存活检查 ——
+// 多次重启就堆积多个 watchdog 常驻轮询同一端口（dsh-memory-eternal#6）。
+// 这里用一个 pid 锁文件：同端口已有活着的 watchdog 就让它直接退出。
+const LOCK_NAME = 'memory-eternal-watchdog.json'
+
+/** 锁文件路径（$DSH_HOME 下，与共享配置同处）。 */
+export function watchdogLockPath(env = process.env) {
+  return path.join(env.DSH_HOME || path.join(os.homedir(), '.dsh'), LOCK_NAME)
+}
+
+/** 进程是否存活（Windows 下 process.kill(pid,0) 同样可用；EPERM 说明进程在但无权限）。 */
+export function isPidAlive(pid) {
+  const n = Number(pid)
+  if (!n || n <= 0) return false
+  if (n === process.pid) return true
+  try { process.kill(n, 0); return true } catch (error) { return error?.code === 'EPERM' }
+}
+
+/** 读取锁文件；损坏或不存在返回 null。 */
+export function readWatchdogLock(env = process.env) {
+  try { return JSON.parse(fs.readFileSync(watchdogLockPath(env), 'utf8')) } catch { return null }
+}
+
+/**
+ * 尝试取得看门狗锁。
+ * @returns {{acquired:boolean, file:string, previous:object|null}} acquired=false 表示「同端口已有活着的看门狗」，调用方应直接退出。
+ */
+export function acquireWatchdogLock({ env = process.env, port, vault = '', pid = process.pid } = {}) {
+  const file = watchdogLockPath(env)
+  const prev = readWatchdogLock(env)
+  const samePortOwnerAlive = prev && prev.pid !== pid && Number(prev.port) === Number(port) && isPidAlive(prev.pid)
+  if (samePortOwnerAlive) return { acquired: false, file, previous: prev }
+  const stale = prev && !isPidAlive(prev.pid) ? prev : null
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    fs.writeFileSync(file, JSON.stringify({ pid, port: Number(port), vault, startedAt: new Date().toISOString() }))
+  } catch { /* 写不了锁不阻塞保活 */ }
+  return { acquired: true, file, previous: stale }
+}
+
+/** 释放锁（只清自己的，避免误删别人刚写的）。 */
+export function releaseWatchdogLock({ env = process.env, pid = process.pid } = {}) {
+  const cur = readWatchdogLock(env)
+  if (!cur || cur.pid !== pid) return false
+  try { fs.unlinkSync(watchdogLockPath(env)); return true } catch { return false }
+}
 
 const ts = () => new Date().toISOString().slice(11, 19) // HH:MM:SS
 const log = (...args) => process.stderr.write(`[${ts()}] [watchdog] ${args.join(' ')}\n`)
@@ -93,13 +143,17 @@ export function startWatchdog({ port = 7999, vaultRoot, interval = 5000, maxRest
     const targetPort = await findFreePort(port)
     const args = [WEB_JS, '--port', String(targetPort)]
     if (vaultRoot) args.push('--vault', vaultRoot)
-    log(`spawn web: node ${args.join(' ')}`)
-    const c = spawn(process.execPath, args, {
+    log(`spawn web: ${nodeBinary()} ${args.join(' ')}`)
+    const c = spawn(nodeBinary(), args, {
       detached: true,
       stdio: 'ignore',
-      env: { ...process.env, MEMORY_VAULT_DIR: vaultRoot || process.env.MEMORY_VAULT_DIR || '' },
+      env: childEnv({ MEMORY_VAULT_DIR: vaultRoot || process.env.MEMORY_VAULT_DIR || '' }),
       windowsHide: true,
     })
+    // spawn 失败默认静默，显式记录（Electron 宿主下曾因此完全无迹可查）
+    c.on('error', (error) => {
+      log(`web spawn failed (${nodeBinary()}): ${error?.message || error}`)
+    })
     c.on('exit', (code, sig) => {
       spawned.delete(c)
       if (!stopped && code !== 0) log(`web exited code=${code} sig=${sig}`)
@@ -221,5 +275,13 @@ if (process.argv[1] && /[\\/]watchdog\.js$/.test(process.argv[1])) {
   const maxRestart = Number(argOf('--max-restart')) || 10
   const vaultRoot = argOf('--vault') || undefined
   const autoStart = !argv.includes('--no-restart')
+  const lock = acquireWatchdogLock({ port, vault: vaultRoot || '' })
+  if (!lock.acquired) {
+    log('同端口已有看门狗在跑（pid ' + (lock.previous && lock.previous.pid) + '，启动于 ' + (lock.previous && lock.previous.startedAt) + '）→ 本次启动退出，避免进程堆积')
+    process.exit(0)
+  }
+  if (lock.previous) log('清理陈旧看门狗记录（pid ' + lock.previous.pid + ' 已不存在）')
+  process.on('exit', () => releaseWatchdogLock())
   startWatchdog({ port, interval, maxRestart, vaultRoot, autoStart })
+  log('看门狗已启动（pid ' + process.pid + '，端口 ' + port + '）')
 }

package/lib/web.js

@@ -17,6 +17,7 @@ import { fileURLToPath } from 'node:url'
 import { createApi, API_PREFIX, encodeBody } from './api.js'
 import { defaultVaultDir, configFilePath } from './capture-run.js'
 import { readCaptureLog, deriveHealth } from './capture-log.js'
+import { nodeBinary, childEnv } from './node-bin.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const WEB_ROOT = path.join(__dirname, '..', 'web')
@@ -112,13 +113,19 @@ export async function ensureWebServer({ port = DEFAULT_WEB_PORT, vaultRoot = def
   }
   if (found) return found
 
-  // detached spawn：独立进程，父进程退出不影响（常驻）；stdio ignore 防阻塞
+  // detached spawn：独立进程，父进程退出不影响（常驻）；stdio ignore 防阻塞。
+  // 注意用 nodeBinary() 而不是 process.execPath：在 Electron 宿主里后者是
+  // Electron 主程序，spawn 出来不会执行 web.js（见 lib/node-bin.js）。
   const { spawn } = await import('node:child_process')
   const child = spawn(
-    process.execPath,
+    nodeBinary(),
     [path.join(__dirname, 'web.js'), '--port', String(target), '--vault', vaultRoot],
-    { detached: true, stdio: 'ignore', env: { ...process.env, ...spawnEnv, MEMORY_VAULT_DIR: vaultRoot }, windowsHide: true },
+    { detached: true, stdio: 'ignore', env: childEnv({ ...spawnEnv, MEMORY_VAULT_DIR: vaultRoot }), windowsHide: true },
   )
+  // spawn 失败（ENOENT/EACCES/...）默认是静默的，这里显式暴露出来
+  child.on('error', (error) => {
+    process.stderr.write(`[memory-eternal] web server spawn failed (${nodeBinary()}): ${error?.message || error}\n`)
+  })
   child.unref()
 
   const deadline = Date.now() + totalTimeoutMs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memory-eternal",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "description": "记忆核心（Memory Eternal）：自研的 DeepSeek Harness 记忆插件，不移植任何既有记忆框架——对话结束后自动沉淀知识卡到本地 Markdown Vault（自研去重、自研 CJK 检索、可 git 管理），设置页提供图形化知识库（统计 / 搜索 / 知识图谱 + 侧边栏一键弹窗），Agent 通过 memory_recall 工具按需召回历史上下文。零人工干预。",
   "license": "MIT",
   "repository": {
@@ -60,7 +60,7 @@
     "build": "node build.mjs",
     "build:client": "node build.mjs",
     "prepublishOnly": "node build.mjs",
-    "test": "node build.mjs && node tests/vault.test.mjs && node tests/capture.test.mjs && node tests/api.test.mjs && node tests/settings-compat.test.mjs && node tests/ssr.test.mjs"
+    "test": "node build.mjs && node tests/vault.test.mjs && node tests/capture.test.mjs && node tests/capture-route.test.mjs && node tests/stall.test.mjs && node tests/vault-path.test.mjs && node tests/api.test.mjs && node tests/graph-perf.test.mjs && node tests/settings-compat.test.mjs && node tests/node-bin.test.mjs && node tests/watchdog-lock.test.mjs && node tests/markdown.test.mjs && node tests/ssr.test.mjs"
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1"
@@ -89,7 +89,8 @@
     },
     "marketplace": {
       "profiles": [
-        "web"
+        "web",
+        "desktop"
       ],
       "requiresBuildApproval": false,
       "requiresRestart": true,
@@ -122,7 +123,8 @@
       },
       "node": ">=22",
       "profiles": [
-        "web"
+        "web",
+        "desktop"
       ]
     }
   }