memory-eternal 0.9.7 → 0.9.9

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,6 +15,8 @@
 
 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'
@@ -24,6 +26,53 @@ 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`)
@@ -226,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memory-eternal",
-  "version": "0.9.7",
+  "version": "0.9.9",
   "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/node-bin.test.mjs && node tests/markdown.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"