memory-eternal 0.10.28 → 0.10.31

package/lib/vault.js

@@ -184,7 +184,7 @@ function rowToCard(row) {
     path: row.path,
     kind: row.kind,
     title: row.title,
-    tags: JSON.parse(row.tags || '[]'),
+    tags: normalizeTags(row.tags),
     summary: row.summary || '',
     created: row.created_at,
     updated: row.updated_at,
@@ -199,7 +199,7 @@ function rowToCard(row) {
 
 /** 将 SQL 行还原为完整 Markdown 文本（frontmatter + body）。 */
 function rowToMarkdown(row) {
-  const tags = JSON.parse(row.tags || '[]')
+  const tags = normalizeTags(row.tags)
   const lines = [
     '---',
     `formatVersion: 1`,
@@ -558,9 +558,43 @@ export async function setCardStatus(root, rel, status, { changedBy = 'system', r
  * `dedupAgainst` 传入候选集合时，去重只跟**这些**卡比（导入备份用：基线取导入前的快照，
  * 让同一批里互相近似的卡不会互吞）。
  */
+/**
+ * 把各种形态的 tags 归一化成字符串数组（issue #41 的根因）。
+ *
+ * 现场：调用方通过 /write 传了**字符串**（`"[\"a\",\"b\"]"`），而 writeCard 直接 `JSON.stringify(tags)`
+ * → 落库变成「一个字符串的 JSON 表示」（双重编码）→ 读出来仍是字符串 → 前端 `tags.slice(...).map` 抛错
+ * → **整页黑屏**（React 根组件挂载失败）。自动沉淀路径本来就有 Array.isArray 检查，只有 /write 等直连入口漏了。
+ * 这里做成唯一入口：数组 / JSON 字符串 / 逗号串 / 双重编码的旧数据，全都收敛成数组。
+ */
+export function normalizeTags(tags) {
+  let v = tags
+  if (typeof v === 'string') {
+    const s = v.trim()
+    if (!s) return []
+    // 最多剥两层：正常 JSON（["a","b"]）+ 双重编码（"[\"a\",\"b\"]" —— #41 的现场，
+    // 它以引号开头，所以只判断 startsWith('[') 会漏掉）。剥不动就按逗号串处理。
+    let cur = s
+    for (let i = 0; i < 2; i++) {
+      if (typeof cur !== 'string') break
+      const t = cur.trim()
+      if (!(t.startsWith('[') || t.startsWith('"'))) break
+      try { cur = JSON.parse(t) } catch { break }
+    }
+    v = typeof cur === 'string' ? cur.split(',') : cur
+  }
+  if (!Array.isArray(v)) return []
+  return v
+    .map((t) => String(t == null ? '' : t).trim())
+    .filter(Boolean)
+    .map((t) => t.slice(0, 30))
+    .slice(0, 20)
+}
+
 export async function writeCard(root, { kind, title, tags = [], body, source = '', status = 'pending', submittedBy = '', severity = 'info', reason = '', deletedAt = '' }, { threshold = 0.62, dedup = true, dedupAgainst = null } = {}) {
   const db = getDb(root)
   const kindRoot = KIND_ROOTS[kind] || KIND_ROOTS.knowledge
+  // 唯一归一化入口：任何调用方（/write、MCP、脚本、自动沉淀）传字符串都不会再双重编码
+  tags = normalizeTags(tags)
 
   // 审核守卫：数据库层强制，调用方传的 status 仅作 fallback
   const enforcedStatus = enforceAudit(root, kind, submittedBy, status)
@@ -634,10 +668,10 @@ export async function mergeCards(root, paths) {
   if (rows.length < 2) return { ok: false, error: '读取失败' }
 
   const first = rows[0]
-  const tags = new Set(JSON.parse(first.tags || '[]'))
+  const tags = new Set(normalizeTags(first.tags))
   let combined = ''
   rows.forEach((row, i) => {
-    const rowTags = JSON.parse(row.tags || '[]')
+    const rowTags = normalizeTags(row.tags)
     rowTags.forEach((t) => tags.add(t))
     combined += (i ? '\n\n---\n\n' : '') + row.body.trim()
   })
@@ -784,7 +818,7 @@ export async function graph(root) {
   const bodyRows = db.prepare('SELECT path, body FROM cards').all()
   const bodyMap = new Map(bodyRows.map((r) => [r.path, r.body]))
   const cards = rows.map((r) => ({
-    path: r.path, kind: r.kind, title: r.title, tags: JSON.parse(r.tags || '[]'),
+    path: r.path, kind: r.kind, title: r.title, tags: normalizeTags(r.tags),
     summary: r.summary || '', updated: r.updated_at, mtime: new Date(r.updated_at).getTime(), status: r.status,
   }))
 
@@ -983,7 +1017,7 @@ export async function stats(root) {
   const weekRow = db.prepare('SELECT COUNT(*) as cnt FROM cards WHERE updated_at >= ?').get(weekAgo)
   const tagRows = db.prepare('SELECT tags FROM cards').all()
   const tagSet = new Set()
-  for (const r of tagRows) { for (const t of JSON.parse(r.tags || '[]')) tagSet.add(t) }
+  for (const r of tagRows) { for (const t of normalizeTags(r.tags)) tagSet.add(t) }
 
   const todayCardsRows = db.prepare('SELECT * FROM cards WHERE updated_at >= ? ORDER BY updated_at DESC LIMIT 30').all(dayAgo)
   const todayCards = todayCardsRows.map((row) => ({ path: row.path, title: row.title, kind: row.kind, updated: row.updated_at, summary: (row.summary || '').slice(0, 80) }))

package/lib/watchdog.js

@@ -108,18 +108,23 @@ export function probeLockWritable(env = process.env) {
  * 尝试取得看门狗锁（按端口分槽）。
  * @returns {{acquired:boolean, file:string, previous:object|null, reaped:number[]}} acquired=false 表示同端口已有活着的看门狗，调用方应直接退出。
  */
-export function acquireWatchdogLock({ env = process.env, port, vault = '', pid = process.pid, pkgVersion = currentPkgVersion() } = {}) {
+export function acquireWatchdogLock({ env = process.env, port, vault = '', pid = process.pid, pkgVersion = currentPkgVersion(), force = false } = {}) {
   const file = watchdogLockPath(env)
   const cur = readWatchdogLock(env)
   const samePort = cur.watchdogs.filter((w) => Number(w.port) === Number(port) && w.pid !== pid)
-  const alive = samePort.find((w) => isPidAlive(w.pid))
-  if (alive) return { acquired: false, file, previous: alive, reaped: [] }
+  // endedAt 的槽是「已结束」的记录（releaseWatchdogLock 留下的痕迹，见 #30）：**绝不能挡住新实例**
+  // —— pid 可能已被复用、那个进程还活着，但那条记录明确表示它已经交出这把锁。
+  const alive = samePort.find((w) => !w.endedAt && isPidAlive(w.pid))
+  // force：--replace 助手的语义就是「替换同端口那个」。不允许让位 —— 否则旧实例还活着时
+  // 新助手直接退出，而清场那一步可能根本没跑完（issue #30 实测：清场被十几秒的枚举拖住 →
+  // 助手退在写锁之前 → 锁永远为空 → verify 必然超时、restart 100% 失败）。
+  if (alive && !force) return { acquired: false, file, previous: alive, reaped: [] }
   // 清掉死掉的槽（含其它端口的陈旧记录），保留仍然存活的其它端口
   const reaped = []
   const kept = []
   for (const w of cur.watchdogs) {
     if (Number(w.port) === Number(port)) { reaped.push(w.pid); continue }
-    if (isPidAlive(w.pid)) kept.push(w)
+    if (!w.endedAt && isPidAlive(w.pid)) kept.push(w)
     else reaped.push(w.pid)
   }
   const previous = samePort[0] || (reaped.length ? { pid: reaped[0] } : null)
@@ -128,13 +133,38 @@ export function acquireWatchdogLock({ env = process.env, port, vault = '', pid =
   return { acquired: true, file, previous, reaped }
 }
 
-/** 释放锁（只清自己那一槽；没有其它槽就删文件）。 */
-export function releaseWatchdogLock({ env = process.env, pid = process.pid } = {}) {
+/**
+ * 释放锁（只清自己那一槽）。
+ *
+ * issue #30 实测：旧实现在「没有其它槽」时**直接删文件** —— 于是一次失败的重启/意外退出之后，
+ * 现场看起来像「从来没有过常驻实例」，而端口上那个 web 还在跑（孤儿）。现在**保留文件**并留一个
+ * `endedAt` 标记的槽：status 会显示「已退出（陈旧记录）」，下次 acquire 再正常回收它。
+ */
+export function releaseWatchdogLock({ env = process.env, pid = process.pid, keepEnded = true } = {}) {
   const cur = readWatchdogLock(env)
   const kept = cur.watchdogs.filter((w) => w.pid !== pid)
   if (kept.length === cur.watchdogs.length) return false
-  if (!kept.length) { try { fs.unlinkSync(watchdogLockPath(env)) } catch { /* 已不存在 */ } return true }
-  writeWatchdogLock(env, kept)
+  const ended = cur.watchdogs.filter((w) => w.pid === pid).map((w) => ({ ...w, endedAt: new Date().toISOString() }))
+  writeWatchdogLock(env, kept.length ? kept : (keepEnded ? ended.slice(-1) : []))
+  return true
+}
+
+/**
+ * 把「替换前的锁登记」写回去（issue #30：失败的 restart 不能把登记抹掉）。
+ * 只补本端口、且当前没有**活着的**同端口登记时才写，避免覆盖新实例的登记。
+ * @returns {boolean} 是否真的写回
+ */
+export function restoreWatchdogLock({ env = process.env, port, watchdogs = [] } = {}) {
+  const p = Number(port) || 0
+  const want = (Array.isArray(watchdogs) ? watchdogs : []).filter((w) => Number(w.port) === p)
+  if (!want.length) return false
+  const cur = readWatchdogLock(env)
+  // 必须排除 endedAt 槽（与 acquireWatchdogLock 同一口径）——报告者实测：PID 复用/正在退出时，
+  // 一条本端口的 endedAt 槽会让这里误判「已有活着的登记」而放弃写回。
+  const liveSame = cur.watchdogs.filter((w) => Number(w.port) === p && !w.endedAt && isPidAlive(w.pid))
+  if (liveSame.length) return false
+  const others = cur.watchdogs.filter((w) => Number(w.port) !== p && isPidAlive(w.pid))
+  writeWatchdogLock(env, [...others, ...want.map((w) => ({ ...w, restoredAt: new Date().toISOString() }))])
   return true
 }
 
@@ -225,7 +255,8 @@ export async function stopWatchdogs({ env = process.env, port, timeoutMs = 5000,
   const failed = []
   const skipped = []
   for (const w of slots) {
-    if (!alive(w.pid)) { skipped.push(Number(w.pid)); releaseWatchdogLock({ env, pid: w.pid }); continue }
+    // 显式清理路径：陈旧槽直接清掉（不留 endedAt 尾巴），与「看门狗自己退出」区分开
+    if (!alive(w.pid)) { skipped.push(Number(w.pid)); releaseWatchdogLock({ env, pid: w.pid, keepEnded: false }); continue }
     if (!killFn(w.pid)) { failed.push(Number(w.pid)); continue }
     stopped.push(Number(w.pid))
   }
@@ -251,7 +282,7 @@ export async function stopWatchdogs({ env = process.env, port, timeoutMs = 5000,
 
   for (const pid of [...stopped, ...failed, ...webStopped]) {
     if (alive(pid)) { if (pid !== 0) failed.push(pid); continue }
-    releaseWatchdogLock({ env, pid })
+    releaseWatchdogLock({ env, pid, keepEnded: false })
   }
 
   // 端口兜底（issue #23）：锁里登记的 webPid 可能压根没写、或者写了却枚举不到，
@@ -360,9 +391,10 @@ async function listWatchdogProcesses(exec, platform = process.platform, marker =
  * 两条对策：① `try/catch` 包住 spawn，失败就当「枚举不到」；② **用临时文件接 stdout**，完全不碰管道。
  */
 function defaultExec() {
-  return async (cmd, args) => {
+  return async (cmd, args, opts = {}) => {
     const { spawn } = await import('node:child_process')
     let outFile = ''
+    let timer = null
     try {
       const os = await import('node:os')
       const path = await import('node:path')
@@ -375,6 +407,10 @@ function defaultExec() {
       } finally {
         try { fs.closeSync(fd) } catch { /* 子进程已继承则关父进程副本 */ }
       }
+      // 超时必须能掐断子进程：issue #30 实测 Windows 上 Get-NetTCPConnection 无条件要 4–7.5 秒
+      // （一次 13.6 秒），而调用方（接管清场）的 8000ms 预算根本管不住它 —— 于是决策基于过期数据。
+      const tm = Number(opts && opts.timeoutMs) || 0
+      if (tm > 0) timer = setTimeout(() => { try { child.kill() } catch { /* 已经在退出 */ } }, tm)
       await new Promise((resolve) => {
         child.on('error', () => resolve(''))
         child.on('close', () => resolve(''))
@@ -383,6 +419,7 @@ function defaultExec() {
     } catch {
       return ''   // 受限环境：宁可「枚举不到」，也不能把调用方（如 --reap）崩掉
     } finally {
+      if (timer) clearTimeout(timer)
       if (outFile) { try { (await import('node:fs')).unlinkSync(outFile) } catch { /* 清理失败无妨 */ } }
     }
   }
@@ -718,6 +755,23 @@ export async function restartResident({
   const before = readWatchdogLock(env).watchdogs.filter((w) => Number(w.port) === p)
   // 替换**前**就存在的 pid（看门狗 + 它拉起的 web）：自检时用来区分「还是那个旧实例」与「新实例接管了」
   const beforePids = new Set(before.flatMap((w) => [Number(w.pid), Number(w.webPid) || 0]).filter((n) => n > 0))
+  // 替换前的登记快照：失败时写回去（issue #30 实测：失败的 restart 会把锁文件删掉，
+  // 现场从此看起来像「从来没有过常驻实例」，而端口上那个 web 还在跑）。
+  const lockSnapshot = before.slice()
+  // issue #30（受限环境现场）：锁文件写不进去时，接管**无法登记**新实例 —— 继续做只会留下
+  // 「有 web 在跑、却没有任何登记」的孤儿（机器上实测：锁目录 EPERM，重启后现场什么都没变、
+  // 用户却以为已经替换过）。这里前置拒绝，并说清两种出路。
+  if (!deps.skipLockPreflight) {
+    const probeLock = deps.probeLockWritable || probeLockWritable
+    let lockOk = true
+    try { lockOk = Boolean(probeLock(env).writable) } catch { lockOk = true }
+    if (!lockOk) {
+      return {
+        ok: false, stage: 'lock-unwritable', expect, served: '', waitedMs: 0, helperPid: 0, before, lockRestored: false, occupant: null,
+        error: '看门狗锁文件写不进去（' + (() => { try { return probeLock(env).path || '' } catch { return '' } })() + '）→ 接管无法登记，已拒绝执行（避免留下"有 web 在跑、却没登记"的孤儿）。请先修复该目录权限，或前台观察：dsh-memory watchdog --port ' + p,
+      }
+    }
+  }
   let helperPid = 0
   try {
     const child = (deps.spawnHelper || spawnReplaceHelper)({ port: p, vaultRoot, interval, maxRestart })
@@ -735,6 +789,21 @@ export async function restartResident({
       readLock: deps.readLock,
     })
   } catch { check = { ok: false, version: '', waitedMs: 0 } }
+  // 失败善后：把替换前的登记写回去 + 报告端口上现在是谁（免得用户面对「锁没了、web 还在」的孤儿现场）
+  let lockRestored = false
+  let occupant = null
+  if (!check.ok) {
+    try { lockRestored = restoreWatchdogLock({ env, port: p, watchdogs: lockSnapshot }) } catch { lockRestored = false }
+    try { occupant = await (deps.findListener || findPortListener)(p) } catch { occupant = null }
+  }
+  const who = occupant && occupant.pid ? occupant.pid + '（' + (occupant.command || '命令行未知') + '）' : ''
+  const occupantText = who ? '；端口上现在是 pid ' + who : ''
+  const lockText = (!check.ok && lockSnapshot.length)
+    ? (lockRestored ? '；已把替换前的锁登记写回（不再出现「锁没了、web 还在」）' : '；锁登记未能写回（受限环境禁止写锁文件）')
+    : ''
+  const failMsg = (check.version === expect && !check.tookOver)
+    ? '端口 ' + p + ' 服务着 v' + check.version + '，但没有新看门狗接管它（端口上可能仍是替换前的旧实例或孤儿）'
+    : '端口 ' + p + ' 上服务的版本是 ' + (check.version || '（无响应）') + '，本机是 ' + (expect || '?')
   return {
     ok: Boolean(check.ok),
     stage: check.ok ? 'done' : 'verify',
@@ -743,11 +812,11 @@ export async function restartResident({
     waitedMs: Number(check.waitedMs) || 0,
     helperPid,
     before,
-    // 失败原因要分清两种：版本不对（旧实例还在服务）与**没人接管**（端口服务着期望版本，
-    // 但锁里没有新的活看门狗 —— 端口上那只是旧实例/孤儿）
-    error: check.ok ? undefined : (check.version === expect && !check.tookOver
-      ? `端口 ${p} 服务着 v${check.version}，但没有新看门狗接管它（端口上可能仍是替换前的旧实例或孤儿）`
-      : `端口 ${p} 上服务的版本是 ${check.version || '（无响应）'}，本机是 ${expect || '?'}`),
+    lockRestored,
+    occupant,
+    // 失败原因：版本不对（旧实例还在服务）vs 没人接管（端口服务着期望版本却没有新看门狗）；
+    // 并补上「端口上现在是谁」与「锁有没有写回」—— #30 现场最缺的就是这两句。
+    error: check.ok ? undefined : (failMsg + occupantText + lockText),
     tookOver: Boolean(check.tookOver),
   }
 }
@@ -762,6 +831,8 @@ export async function restartResident({
 export async function clearResidentForTakeover({ port = 7999, env = process.env, timeoutMs = 8000, deps = {} } = {}) {
   const p = Number(port) || 7999
   const findListener = deps.findListener || findPortListener
+  // 枚举本身要能被时间预算约束（否则 8s 预算被一次 13.6s 的 PowerShell 查询吃光，决策基于过期数据）
+  const listenerOpts = { timeoutMs: Math.max(500, Math.min(2500, Number(timeoutMs) || 8000)) }
   const out = { stopped: [], webStopped: [], portStopped: [], warnings: [], failed: [], portFree: false }
   const rawKill = deps.kill || ((pid) => { try { process.kill(pid, 'SIGTERM'); return true } catch { return false } })
   // 记下「已经判定收不掉」的 pid：立刻再来一次只会同样失败，白折腾还可能误导用户以为是权限抖动
@@ -783,17 +854,32 @@ export async function clearResidentForTakeover({ port = 7999, env = process.env,
   }
   const wait = deps.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)))
   let left = null
-  try { left = await findListener(p) } catch { left = null }
+  try { left = await findListener(p, listenerOpts) } catch { left = null }
   const deadline = Date.now() + Math.max(0, Number(timeoutMs) || 0)
   // 只对「确认是本插件的 web」下手：别人的进程占着端口时只如实报告，不误杀（同 issue #23 的口径）。
   // 已经判定收不掉的 pid 不再重试 —— 立刻再来一次只会同样失败。
   while (left && left.pid && looksLikeOurWeb(left.command) && !failedKills.has(Number(left.pid)) && Date.now() < deadline) {
     if (!killFn(left.pid)) break
     await wait(200)
-    try { left = await findListener(p) } catch { left = null }
+    try { left = await findListener(p, listenerOpts) } catch { left = null }
+  }
+  if (left && left.pid) {
+    out.portFree = false
+    out.warnings.push(`端口 ${p} 仍被 pid ${left.pid} 占用（${left.command || '命令行未知'}）`)
+  } else {
+    // 枚举不到 ≠ 端口是空的（issue #30 现场）：受限环境/被拒的进程查询会让 findListener 返回 null，
+    // 旧实现据此认为"端口已空出" → 新 web 绑不上 7999 → 退让或失败 → 自检「（无响应）」+ 锁被清空。
+    // 这里用**不依赖枚举**的 TCP 探测复核：还在监听就坚决不算空。
+    const probe = deps.probeTcp || probeTcp
+    let listening = false
+    try { listening = Boolean(await probe(p)) } catch { listening = false }
+    if (listening) {
+      out.portFree = false
+      out.warnings.push(`端口 ${p} 仍在监听，但占用者无法识别（进程枚举被拒/不可用）—— 已中止接管，且未改动任何锁登记`)
+    } else {
+      out.portFree = true
+    }
   }
-  out.portFree = !(left && left.pid)
-  if (!out.portFree) out.warnings.push(`端口 ${p} 仍被 pid ${left.pid} 占用（${left.command || '命令行未知'}）`)
   return out
 }
 
@@ -831,19 +917,20 @@ export function parseLsofFields(text) {
  * @param {{exec?: (cmd:string,args:string[])=>Promise<string>}} [opts]
  * @returns {Promise<{pid:number, command:string}|null>}
  */
-export async function findPortListener(port, { exec, platform = process.platform } = {}) {
+export async function findPortListener(port, { exec, platform = process.platform, timeoutMs = 4000 } = {}) {
   const p = Number(port)
   if (!Number.isFinite(p) || p <= 0) return null
   const runExec = exec || defaultExec()
+  const execOpts = { timeoutMs: Math.max(200, Number(timeoutMs) || 4000) }
   try {
     if (platform === 'win32') {
-      const out = await runExec('powershell', ['-NoProfile', '-Command', `Get-NetTCPConnection -LocalPort ${p} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess`])
+      const out = await runExec('powershell', ['-NoProfile', '-Command', `Get-NetTCPConnection -LocalPort ${p} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess`], execOpts)
       const pid = Number(String(out || '').split(/\r?\n/).map((s) => s.trim()).find((s) => /^\d+$/.test(s))) || 0
       if (!pid) return null
-      const cmd = await runExec('powershell', ['-NoProfile', '-Command', `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}" | Select-Object -ExpandProperty CommandLine)`])
+      const cmd = await runExec('powershell', ['-NoProfile', '-Command', `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}" | Select-Object -ExpandProperty CommandLine)`], execOpts)
       return { pid, command: String(cmd || '').trim() }
     }
-    const fields = await runExec('lsof', ['-nP', `-iTCP:${p}`, '-sTCP:LISTEN', '-Fpcn'])
+    const fields = await runExec('lsof', ['-nP', `-iTCP:${p}`, '-sTCP:LISTEN', '-Fpcn'], execOpts)
     const list = parseLsofFields(fields)
     if (!list.length) return null
     const pid = list[0].pid
@@ -1214,6 +1301,12 @@ if (process.argv[1] && /[\\/]watchdog\.js$/.test(process.argv[1])) {
     log(summary)
     if (cleared.failed.length) log('⚠ 未能停止：pid ' + cleared.failed.join(', '))
     if (!cleared.portFree) {
+      // issue #30：**清场失败也必须留下登记**。老实现直接 exit(1)，于是锁里什么都没有 ——
+      // 而 restartResident 的自检要求「锁里出现新看门狗」，必然超时，用户看到的永远是「（无响应）」。
+      // 登记一条（pid 已退出时会自动落成 endedAt 记录，不挡后续），现场从此可复盘。
+      const claim = acquireWatchdogLock({ port, vault: vaultRoot || '', pkgVersion: currentPkgVersion(), force: true })
+      if (claim.acquired) log('已登记本次替换尝试（端口仍被占用，看门狗未启动）：pid ' + process.pid)
+      else log('⚠ 未能登记本次替换（锁不可写？）：' + (claim.file || ''))
       const why = `${summary} —— 端口没空出来，已中止接管（不退让到 port+1，避免又留一个孤儿 web）`
       await noteReplace('fail', why)
       process.exit(1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memory-eternal",
-  "version": "0.10.28",
+  "version": "0.10.31",
   "description": "记忆核心（Memory Eternal）：自研的 DeepSeek Harness 记忆插件，不移植任何既有记忆框架——对话结束后自动沉淀知识卡到本地 Markdown Vault（自研去重、自研 CJK 检索、可 git 管理），设置页提供图形化知识库（统计 / 搜索 / 知识图谱 + 侧边栏一键弹窗），Agent 通过 memory_recall 工具按需召回历史上下文。零人工干预。",
   "license": "MIT",
   "repository": {
@@ -64,7 +64,7 @@
     "prepublishOnly": "node build.mjs",
     "release": "node scripts/release.mjs",
     "release:dry": "node scripts/release.mjs --dry-run",
-    "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/vault-resolve.test.mjs && node tests/minhash.test.mjs && node tests/settings-save.test.mjs && node tests/config-coverage.test.mjs && node tests/config-sync.test.mjs && node tests/config-merge.test.mjs && node tests/sse.test.mjs && node tests/api.test.mjs && node tests/import-roundtrip.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/feedback.test.mjs && node tests/graph-lod.test.mjs && node tests/ssr.test.mjs && node tests/web-assets.test.mjs && node tests/manifests.test.mjs && node tests/two-store.test.mjs && node tests/noise-gate.test.mjs && node tests/e2e-recall.test.mjs && node tests/issue-fixes.test.mjs && node tests/issue-fixes-2.test.mjs && node tests/issue-fixes-3.test.mjs && node tests/watchdog-orphans.test.mjs && node tests/watchdog-restart.test.mjs && node tests/readme-i18n.test.mjs && node tests/issue-fixes-4.test.mjs && node tests/host-drain.test.mjs && node tests/e2e-host-drain.mjs && node tests/issue-fixes-5.test.mjs && node tests/issue-fixes-6.test.mjs && node tests/capture-json-repair.test.mjs && node tests/csrf-origin.test.mjs && node tests/watchdog-orphan-web.test.mjs && node tests/config-validate.test.mjs && node tests/issue-fixes-8.test.mjs && node tests/issue-fixes-9.test.mjs && node tests/release-verify.test.mjs && node tests/refine.test.mjs && node tests/db-restore.test.mjs && node tests/align.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/vault-resolve.test.mjs && node tests/minhash.test.mjs && node tests/settings-save.test.mjs && node tests/config-coverage.test.mjs && node tests/config-sync.test.mjs && node tests/config-merge.test.mjs && node tests/sse.test.mjs && node tests/api.test.mjs && node tests/import-roundtrip.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/feedback.test.mjs && node tests/graph-lod.test.mjs && node tests/ssr.test.mjs && node tests/web-assets.test.mjs && node tests/manifests.test.mjs && node tests/two-store.test.mjs && node tests/noise-gate.test.mjs && node tests/e2e-recall.test.mjs && node tests/issue-fixes.test.mjs && node tests/issue-fixes-2.test.mjs && node tests/issue-fixes-3.test.mjs && node tests/watchdog-orphans.test.mjs && node tests/watchdog-restart.test.mjs && node tests/readme-i18n.test.mjs && node tests/issue-fixes-4.test.mjs && node tests/host-drain.test.mjs && node tests/e2e-host-drain.mjs && node tests/issue-fixes-5.test.mjs && node tests/issue-fixes-6.test.mjs && node tests/capture-json-repair.test.mjs && node tests/csrf-origin.test.mjs && node tests/watchdog-orphan-web.test.mjs && node tests/config-validate.test.mjs && node tests/issue-fixes-8.test.mjs && node tests/issue-fixes-9.test.mjs && node tests/release-verify.test.mjs && node tests/refine.test.mjs && node tests/db-restore.test.mjs && node tests/align.test.mjs && node tests/tags-normalize.test.mjs"
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1"