memory-eternal 0.15.0 → 0.16.0

package/dsh-tui-plugin/main.js

@@ -41,17 +41,72 @@ function openMemory() {
 }
 
 export function apply(ctx) {
-  const host = ctx.get('tuiPluginHost', false)
-  if (!host) return
+  // ── 为什么不能「拿不到 tuiPluginHost 就直接 return」────────────────────────
+  // tuiPluginHost / tuiScenes 都是**后挂载**的 TUI seam：cordis 只保证插件被拉起来，
+  // 不保证它激活时宿主 seam 已经就绪。旧实现 `const host = ctx.get('tuiPluginHost', false); if (!host) return`
+  // 一旦抢跑就永久放弃 —— 表现为命令面板里根本没有 /memory、/audit（issue #50 用户实测）。
+  // 参照 dsh-tui-find（同宿主同 API）：软探测 + 50ms 小步轮询，挂上再注册；10s 还没挂
+  // 就安静收手（确实没有 TUI 运行时的组合不该报错）。
+  const HOST_POLL_MS = 50
+  const HOST_MAX_ATTEMPTS = 200 // ≈10s
+  let disposed = false
+  let hostTimer = null
+  let hostAttempts = 0
+  let hostDisposer = null
 
-  // tuiScenes can mount after this activation on a cold boot. Soft-probe and
-  // retry briefly instead of silently leaving /audit dead for the session.
+  const probe = (name) => {
+    try { return ctx.get(name, false) } catch { return false }
+  }
+
+  const registerCommands = (host) => {
+    const disposers = []
+    disposers.push(host.registerCommand(ctx, COMMAND_ID, {
+      recordInput: false,
+      handler: () => {
+        openMemory()
+        return { kind: 'success', text: `Memory Atlas 已打开：${URL}` }
+      },
+    }))
+    disposers.push(host.registerCommand(ctx, AUDIT_COMMAND_ID, {
+      recordInput: false,
+      handler: () => {
+        const runtime = probe('tuiScenes')
+        if (!runtime) return { kind: 'error', text: '当前 dsh-tui 没有 scenes 运行时' }
+        if (runtime.active?.id === AUDIT_SCENE_ID) runtime.close()
+        const opened = runtime.open(AUDIT_SCENE_ID)
+        return opened
+          ? { kind: 'success', text: 'Memory Atlas / 待审 已打开' }
+          : { kind: 'error', text: '审核场景未注册' }
+      },
+    }))
+    return () => { for (const d of disposers) { try { if (typeof d === 'function') d() } catch { /* 卸载失败不影响其他 */ } } }
+  }
+
+  const tryRegisterCommands = () => {
+    hostTimer = null
+    if (disposed) return
+    const host = probe('tuiPluginHost')
+    if (!host) {
+      hostAttempts += 1
+      if (hostAttempts < HOST_MAX_ATTEMPTS) hostTimer = setTimeout(tryRegisterCommands, HOST_POLL_MS)
+      return
+    }
+    try {
+      hostDisposer = registerCommands(host)
+    } catch (error) {
+      console.warn('[memory-eternal-tui] command registration failed:', error)
+    }
+  }
+  tryRegisterCommands()
+
+  // tuiScenes 同样可能晚于本插件挂载：沿用原来的软探测 + 50ms 重试（最多 ~2s）。
   let sceneDisposer = null
   let sceneTimer = null
   let attempts = 0
   const registerScene = () => {
     sceneTimer = null
-    const scenes = ctx.get('tuiScenes', false)
+    if (disposed) return
+    const scenes = probe('tuiScenes')
     if (scenes && !sceneDisposer) {
       try {
         sceneDisposer = scenes.register({ id: AUDIT_SCENE_ID, title: 'Memory Atlas / 待审', component: AuditScene }, ctx)
@@ -65,33 +120,12 @@ export function apply(ctx) {
     }
   }
   registerScene()
-  ctx.effect(() => {
+
+  ctx.effect(() => () => {
+    disposed = true
+    if (hostTimer) clearTimeout(hostTimer)
     if (sceneTimer) clearTimeout(sceneTimer)
+    if (hostDisposer) hostDisposer()
     if (sceneDisposer) sceneDisposer()
   })
-
-  const dispose = host.registerCommand(ctx, COMMAND_ID, {
-    recordInput: false,
-    handler: () => {
-      openMemory()
-      return { kind: 'success', text: `Memory Atlas 已打开：${URL}` }
-    },
-  })
-  ctx.effect(() => dispose)
-
-  const disposeAudit = host.registerCommand(ctx, AUDIT_COMMAND_ID, {
-    recordInput: false,
-    handler: () => {
-      const runtime = ctx.get('tuiScenes', false)
-      if (!runtime) return { kind: 'error', text: '当前 dsh-tui 没有 scenes 运行时' }
-      if (runtime.active?.id === AUDIT_SCENE_ID) runtime.close()
-      const opened = runtime.open(AUDIT_SCENE_ID)
-      return opened
-        ? { kind: 'success', text: 'Memory Atlas / 待审 已打开' }
-        : { kind: 'error', text: '审核场景未注册' }
-    },
-  })
-  ctx.effect(() => disposeAudit)
 }
-
-export default { name, inject, apply }

package/dsh-tui-plugin/package.json

@@ -1,31 +1,51 @@
-{
-  "name": "memory-eternal-tui",
-  "version": "0.15.0",
-  "description": "Open Memory Atlas from dsh-TUI with /memory.",
-  "type": "module",
-  "main": "main.js",
-  "files": [
-    "main.js",
-    "scene.js",
-    "demo.mjs",
-    "dsh-plugin.json",
-    "cordis.patch.yml",
-    "README.md"
-  ],
-  "keywords": [
-    "dsh",
-    "dsh-tui",
-    "memory-eternal",
-    "memory",
-    "plugin"
-  ],
-  "license": "MIT",
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    }
-  },
-  "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1"
-  }
-}
+{
+  "name": "memory-eternal-tui",
+  "version": "0.16.0",
+  "description": "Memory Atlas for dsh-TUI: /audit scene with reason/severity, batch confirmation and reject reasons.",
+  "type": "module",
+  "main": "main.js",
+  "files": [
+    "main.js",
+    "scene.js",
+    "demo-audit.mjs",
+    "demo.mjs",
+    "dsh-plugin.json",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "keywords": [
+    "dsh",
+    "dsh-tui",
+    "dsh-tui-plugin",
+    "memory-eternal",
+    "memory",
+    "audit",
+    "plugin"
+  ],
+  "license": "MIT",
+  "author": "EternalNight996",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EternalNight996/memory-eternal.git",
+    "directory": "dsh-tui-plugin"
+  },
+  "homepage": "https://github.com/EternalNight996/memory-eternal/tree/main/dsh-tui-plugin",
+  "bugs": {
+    "url": "https://github.com/EternalNight996/memory-eternal/issues"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1"
+  }
+}

package/dsh-tui-plugin/scene.js

@@ -2,8 +2,15 @@
 //
 // 不复制 Web UI：只把「待审队列 + 全选 + 批准/驳回」做成 dsh-tui 原生场景。
 // 日常浏览/长文仍可回到 Web 或外部 TUI 客户端。
+//
+// issue #50：审核是**人**的动作，所以这里区分两件事——
+//   1) 进入确认态再提交（批量误触的代价太大）；
+//   2) 驳回可以顺手写理由（复用 API 的 reason 语义，落到 audit_log）。
+// 判词面板同时把卡片的 reason / severity 亮出来：自动沉淀里「蒸馏兜底原文卡」
+// 是最该优先复核的一类，以前在 TUI 里完全看不出来。
 
 const API = process.env.MEMORY_ETERNAL_API || 'http://127.0.0.1:7999/memory-eternal/api'
+const MAX_REASON = 120
 
 async function apiJson(path, options = {}) {
   const res = await fetch(API + path, { ...options, signal: AbortSignal.timeout(10000) })
@@ -17,6 +24,59 @@ function timeOf(value) {
   return Number.isNaN(d.getTime()) ? '' : d.toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit', hour12: false })
 }
 
+// ── 纯函数（导出给 tests/tui-audit-scene.test.mjs 真调用，不依赖 React 或宿主） ──
+
+/** 判词面板第一行：kind · 时间 · 来源 · 严重度（info 是默认值，不占位置）。 */
+export function cardMeta(card) {
+  const c = card || {}
+  const parts = [c.kind || 'knowledge', c.time || '', c.source || '']
+  const severity = String(c.severity || '').trim()
+  if (severity && severity !== 'info') parts.push('严重度 ' + severity)
+  return parts.filter(Boolean).join(' · ')
+}
+
+/**
+ * `依据：<reason>`。没有 reason 返回空串 —— 调用方据此**不占空行**。
+ * reason 来自卡片 DB（lib/vault.js rowToCard）：'AI 自动沉淀（蒸馏卡）'、
+ * 'AI 自动沉淀（原文卡）'、'手动创建'、'多卡合并' 等。
+ */
+export function reasonLine(card) {
+  const reason = String((card && card.reason) || '').trim()
+  if (!reason) return ''
+  return '依据：' + (reason.length > MAX_REASON ? reason.slice(0, MAX_REASON - 1) + '…' : reason)
+}
+
+/** 蒸馏兜底原文卡标记：没有 LLM 精炼的降级卡，最该先复核（没有就返回空串）。 */
+export function reasonFlag(card) {
+  const reason = String((card && card.reason) || '')
+  return /原文卡|raw/i.test(reason) ? '⚠ 蒸馏兜底原文卡（无 LLM 精炼，优先复核）' : ''
+}
+
+/** 列表标题位置文本 `起-止/总数`；空队列 `0/0`。start 是窗口首项下标（0 基）。 */
+export function positionLabel(start = 0, count = 0, total = 0) {
+  const t = Math.max(0, Number(total) || 0)
+  if (!t) return '0/0'
+  const s = Math.max(0, Math.min(Number(start) || 0, t - 1))
+  const c = Math.max(0, Number(count) || 0)
+  const first = s + 1
+  const last = Math.min(t, s + c)
+  if (last < first) return `0/${t}`
+  return `${first}-${last}/${t}`
+}
+
+/** 底栏确认文案：批准 = 二次确认；驳回 = 确认态同时收理由（可空）。 */
+export function confirmLabel(kind, count = 1, reason = '') {
+  const n = Math.max(0, Number(count) || 0)
+  if (kind === 'reject') return `驳回 ${n} 张 · 理由（可空）：${String(reason || '')}   Enter 确认 / Esc 取消`
+  return `确认批准 ${n} 张？Enter 确认 / Esc 取消`
+}
+
+/** 审核请求体：批准只带 path；驳回总是带 reason（空串也带，服务端按缺省 '' 记 audit_log）。 */
+export function auditPayload(action, path, reason = '') {
+  if (action === 'reject') return { path, reason: String(reason || '').trim() }
+  return { path }
+}
+
 export function AuditScene(props) {
   const { React, ui, close } = props
   const { Box, Text, useInput, useTerminalSize } = ui
@@ -30,10 +90,15 @@ export function AuditScene(props) {
   const [marked, setMarked] = useState(() => new Set())
   const [status, setStatus] = useState('读取待审队列…')
   const [loading, setLoading] = useState(true)
+  // 二次确认态（issue #50）：null = 列表；否则 { action:'approve'|'reject', count, paths }
+  const [confirm, setConfirm] = useState(null)
+  const [reason, setReason] = useState('')
 
   const load = async () => {
     setLoading(true)
     setStatus('读取待审队列…')
+    setConfirm(null)
+    setReason('')
     try {
       const data = await apiJson('/cards?status=pending&limit=300')
       setCards((data.cards || []).map((c) => ({
@@ -42,6 +107,8 @@ export function AuditScene(props) {
         title: c.title || '无标题',
         summary: String(c.summary || '').replace(/^#{1,6}\s*/gm, '').replace(/\s+/g, ' ').slice(0, 260),
         source: c.submittedBy || 'memory',
+        severity: c.severity || 'info',
+        reason: String(c.reason || '').trim(),
         time: timeOf(c.updated || c.created),
       })))
       setIndex(0)
@@ -59,30 +126,57 @@ export function AuditScene(props) {
   const current = cards[index]
   const visible = cards
   const selected = marked.size
-  const apply = async (decision) => {
+
+  // 目标在进入确认时就冻结：确认期间即使列表/选择变化，Enter 提交的也是用户看到的那批卡。
+  const beginConfirm = (action) => {
     const targets = selected ? visible.filter((c) => marked.has(c.path)) : (current ? [current] : [])
-    if (!targets.length) return
-    setStatus(decision === 'a' ? `批准 ${targets.length} 张…` : `驳回 ${targets.length} 张…`)
+    if (!targets.length) { setStatus('没有可操作的卡片'); return }
+    setConfirm({ action, count: targets.length, paths: targets.map((c) => c.path) })
+    setReason('')
+    setStatus('')
+  }
+
+  const runConfirm = async () => {
+    if (!confirm) return
+    const { action, paths, count } = confirm
+    setStatus(`${action === 'reject' ? '驳回' : '批准'} ${count} 张…`)
     try {
-      await Promise.all(targets.map((c) => apiJson('/audit/' + (decision === 'a' ? 'approve' : 'reject'), {
+      await Promise.all(paths.map((path) => apiJson('/audit/' + (action === 'reject' ? 'reject' : 'approve'), {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ path: c.path }),
+        body: JSON.stringify(auditPayload(action, path, reason)),
       })))
-      const ids = new Set(targets.map((c) => c.path))
+      const ids = new Set(paths)
       setCards((prev) => prev.filter((c) => !ids.has(c.path)))
       setIndex(0)
       setMarked(new Set())
-      setStatus(`✓ ${decision === 'a' ? '已批准' : '已驳回'} ${targets.length} 张`)
+      setConfirm(null)
+      setReason('')
+      setStatus(`✓ ${action === 'reject' ? '已驳回' : '已批准'} ${count} 张`)
     } catch (err) {
+      // 失败留在确认态：检查网络/权限后可直接 Enter 重试，Esc 才是放弃。
       setStatus('操作失败：' + err.message)
     }
   }
 
   useInput((input, key) => {
-    if (key.escape || input === 'q') { close(); return }
-    if (input === 'r' && !key.ctrl) { void apply('r'); return }
-    if (input === 'a' && !key.ctrl) { void apply('a'); return }
+    const esc = key.escape || input === '\u001b'
+    const enter = key.return || key.enter || input === '\r' || input === '\n'
+    if (confirm) {
+      if (esc) { setConfirm(null); setReason(''); setStatus(''); return }
+      if (enter) { void runConfirm(); return }
+      if (confirm.action === 'reject') {
+        if (key.backspace || key.delete || input === '\u007f' || input === '\b') { setReason((r) => r.slice(0, -1)); return }
+        // 只收可见字符；方向键/Tab/Ctrl 组合不进理由（理由可空，Enter 直接提交）。
+        if (input && !key.ctrl && !key.meta && !key.tab && !key.upArrow && !key.downArrow && !key.leftArrow && !key.rightArrow) {
+          setReason((r) => (r + input).slice(0, MAX_REASON))
+        }
+      }
+      return
+    }
+    if (esc || input === 'q') { close(); return }
+    if (input === 'a' && !key.ctrl) { beginConfirm('approve'); return }
+    if (input === 'r' && !key.ctrl) { beginConfirm('reject'); return }
     if (input === 's' || (key.ctrl && input === 'a')) {
       setMarked((prev) => {
         const all = visible.length > 0 && visible.every((c) => prev.has(c.path))
@@ -110,22 +204,38 @@ export function AuditScene(props) {
   const list = (visible || []).slice(start, start + listH)
   const previewLines = []
   if (current) {
-    previewLines.push(current.kind + ' · ' + current.time + ' · ' + current.source)
+    previewLines.push(cardMeta(current))
+    const why = reasonLine(current)
+    if (why) previewLines.push(why)
+    const flag = reasonFlag(current)
+    if (flag) previewLines.push(flag)
     previewLines.push('')
     previewLines.push(current.title)
     previewLines.push('')
-    for (let i = 0; i < current.summary.length; i += Math.max(16, previewW - 4)) {
-      previewLines.push(current.summary.slice(i, i + Math.max(16, previewW - 4)))
+    const wrapW = Math.max(16, previewW - 4)
+    for (let i = 0; i < current.summary.length; i += wrapW) {
+      previewLines.push(current.summary.slice(i, i + wrapW))
     }
   } else {
     previewLines.push(loading ? '读取中…' : '没有待审卡')
   }
 
+  const errored = status.startsWith('操作失败') || status.startsWith('读取失败')
+  const confirmText = confirm ? confirmLabel(confirm.action, confirm.count, reason) : ''
+  // 确认态里也要能看到「提交中… / 操作失败」（失败会留在确认态让用户重试）。
+  const footer = confirm
+    ? (errored || status.endsWith('…') ? status + '   ' + confirmText : confirmText)
+    : (status || '↑↓ 移动   Space 多选   s 全选   a 批准   r 驳回（可填理由）   Esc 退出')
+  const footerColor = confirm ? (errored ? 'error' : 'remember')
+    : status.startsWith('✓') ? 'success'
+      : errored ? 'error'
+        : undefined
+
   const h = React.createElement
   return h(Box, { flexDirection: 'column', width: columns, height: rows },
     h(Box, { flexShrink: 0 },
       h(Text, { color: 'remember', bold: true }, '● MEMORY ATLAS'),
-      h(Text, { dimColor: true }, `  / 待审   ${cards.length} 张` + (selected ? `   已选 ${selected}` : '')),
+      h(Text, { dimColor: true }, `  / 待审   ${cards.length} 张   ${positionLabel(start, list.length, cards.length)}` + (selected ? `   已选 ${selected}` : '')),
     ),
     h(Text, { dimColor: true }, '─'.repeat(Math.max(1, columns - 1))),
     h(Box, { flexDirection: 'row', flexGrow: 1, overflow: 'hidden' },
@@ -143,8 +253,7 @@ export function AuditScene(props) {
           h(Text, { key: i, wrap: 'truncate', color: i === 0 ? 'remember' : undefined }, ' ' + line)),
       ),
     ),
-    h(Text, { color: status.startsWith('✓') ? 'success' : status.startsWith('操作失败') || status.startsWith('读取失败') ? 'error' : undefined, dimColor: !status },
-      ' ' + (status || '↑↓ 移动   Space 多选   s 全选   a 批准   r 驳回   Esc 退出')),
+    h(Text, { color: footerColor, dimColor: !status && !confirm, wrap: 'truncate' }, ' ' + footer),
   )
 }
 

package/index.js

@@ -742,7 +742,9 @@ export function apply(ctx, config) {
         // issue #48：超时不再硬编码 45s（本地 30B 冷启动 40–60s 必超时），且超时后**同候选**用更长超时重试一次。
         const baseTimeout = Math.max(5000, Number(cfg.captureTimeoutMs) || 45000)
         const isTimeoutFailure = (x) => /ABORTED|TIMEOUT|ETIMEDOUT|aborted/i.test(String((x && (x.code + ' ' + x.message)) || ''))
-        const attempt = (budget, ms) => summarizeTurnDetailed(llm, route, text, { signal: AbortSignal.timeout(ms), existing: neighbors, maxTokens: budget })
+        // issue #51：把真实会话 id 透传给 LLM（opencode-go 网关靠它注入 x-opencode-session，
+        // 缺了首跳固定 400 MissingSessionID）。同一会话的蒸馏请求也因此能被网关按会话归并。
+        const attempt = (budget, ms) => summarizeTurnDetailed(llm, route, text, { signal: AbortSignal.timeout(ms), existing: neighbors, maxTokens: budget, sessionId })
         let detailed = await attempt(maxTokens, baseTimeout)
         if (detailed.failure && isTimeoutFailure(detailed.failure)) {
           const longer = Math.min(Math.max(Math.round(baseTimeout * 2.5), baseTimeout + 30000), 180000)

package/lib/api.js

@@ -31,6 +31,21 @@ export function broadcast(event, data) { return hub.broadcast(event, data) }
 
 export const API_PREFIX = '/memory-eternal/api'
 
+/** 用系统默认浏览器打开一个 URL（win: rundll32 / mac: open / linux: xdg-open）。 */
+function spawnOpener(href) {
+  try {
+    let child
+    if (process.platform === 'win32') child = spawn('rundll32', ['url.dll,FileProtocolHandler', href], { detached: true, stdio: 'ignore', windowsHide: true })
+    else if (process.platform === 'darwin') child = spawn('open', [href], { detached: true, stdio: 'ignore' })
+    else child = spawn('xdg-open', [href], { detached: true, stdio: 'ignore' })
+    child.on('error', () => {})
+    child.unref()
+    return { ok: true, url: href }
+  } catch (e) {
+    return { ok: false, error: String((e && e.message) || e) }
+  }
+}
+
 // 浏览器/Electron 里 target=_blank 可能被宿主拦截；由本机 Node 进程调用系统默认浏览器。
 // 只允许项目自己的 GitHub 地址，避免变成任意 URL 打开器。
 function openExternalUrl(raw) {
@@ -38,17 +53,44 @@ function openExternalUrl(raw) {
   try { u = new URL(String(raw || '')) } catch { return { ok: false, error: 'bad url' } }
   const allowed = u.protocol === 'https:' && u.hostname === 'github.com' && u.pathname.startsWith('/EternalNight996/memory-eternal')
   if (!allowed) return { ok: false, error: 'url not allowed' }
-  try {
-    let child
-    if (process.platform === 'win32') child = spawn('rundll32', ['url.dll,FileProtocolHandler', u.href], { detached: true, stdio: 'ignore', windowsHide: true })
-    else if (process.platform === 'darwin') child = spawn('open', [u.href], { detached: true, stdio: 'ignore' })
-    else child = spawn('xdg-open', [u.href], { detached: true, stdio: 'ignore' })
-    child.on('error', () => {})
-    child.unref()
-    return { ok: true, url: u.href }
-  } catch (e) {
-    return { ok: false, error: String((e && e.message) || e) }
+  return spawnOpener(u.href)
+}
+
+/**
+ * 「Web 版」入口只允许打开**本机**地址：127.0.0.1 / localhost / ::1 的 http(s)。
+ * 这个端点没有鉴权（只监听 127.0.0.1 也不该给任意网页当跳板），所以必须白名单校验，
+ * 绝不能退化成通用 URL 打开器。
+ */
+export function isLocalWebUrl(raw) {
+  let u
+  try { u = new URL(String(raw || '')) } catch { return false }
+  if (u.protocol !== 'http:' && u.protocol !== 'https:') return false
+  const host = String(u.hostname || '').toLowerCase().replace(/^\[|\]$/g, '')
+  return host === '127.0.0.1' || host === 'localhost' || host === '::1'
+}
+
+/**
+ * 独立 Web UI（浏览器版）的地址：优先取 watchdog 锁里记录的常驻端口，没有锁就退回 7999。
+ * 为什么不是写死 7999：端口会漂移（自愈/占用），锁文件才是「真正在服务的那个实例」。
+ */
+export function residentWebUrl(portHint) {
+  let port = Number(portHint) || 0
+  if (!port) {
+    try {
+      const lock = readWatchdogLock(process.env)
+      const list = lock && Array.isArray(lock.watchdogs) ? lock.watchdogs : []
+      const alive = list.find((w) => w && w.port && (!w.pid || isPidAlive(w.pid)))
+      port = Number((alive && alive.port) || (list[0] && list[0].port)) || 0
+    } catch { /* 锁坏了就退回默认端口 */ }
   }
+  return `http://127.0.0.1:${port || 7999}/`
+}
+
+/** 「Web 版」：用默认浏览器打开本机独立 Web UI（地址必须过本地白名单）。 */
+export function openLocalWeb(raw) {
+  const url = raw || residentWebUrl()
+  if (!isLocalWebUrl(url)) return { ok: false, error: 'url not allowed' }
+  return spawnOpener(url)
 }
 
 // npm 最新版本缓存（避免每次点「检查更新」都打 registry）
@@ -502,6 +544,16 @@ export function createApi(deps = {}) {
         if (req.method && req.method !== 'POST') return json(res, 405, { ok: false, error: 'method not allowed' })
         return json(res, 200, openExternalUrl(query.get('url')))
       }
+      case '/open-web': {
+        // 左侧栏「Web 版」：用系统默认浏览器打开本机独立 Web UI。
+        // 只允许 127.0.0.1/localhost/::1，避免这个无鉴权端点变成任意 URL 打开器。
+        if (req.method && req.method !== 'POST') return json(res, 405, { ok: false, error: 'method not allowed' })
+        return json(res, 200, openLocalWeb(query.get('url')))
+      }
+      case '/web-info': {
+        // 供前端/诊断查「浏览器版」地址（不打开浏览器）。旧版宿主没有这条路由 → 前端会回退。
+        return json(res, 200, { ok: true, url: residentWebUrl(query.get('port')), version: currentPkgVersion() })
+      }
       case '/diagnostics': {
         // 「反馈异常」用：返回一段可直接贴进 issue 的**已脱敏**诊断文本。
         // 宿主与独立 web 共用这个实现；home 目录、各类 key/token 全都会被替换掉。
@@ -586,11 +638,15 @@ export function createApi(deps = {}) {
         return
       }
       case '/audit/reject': {
-        // POST {path} 或 GET ?path= → status=rejected（标记驳回，不删除）
-        const rel = query.get('path') || (await readBody(req))?.path || ''
+        // POST {path, reason?} 或 GET ?path=&reason= → status=rejected（标记驳回，不删除）
+        // issue #50：驳回理由复用 --reason 语义 —— 传了就经 setCardStatus 写进 audit_log，
+        // 缺省仍是空串。审核是人的动作，所以 changed_by 记 'user'（原来是缺省的 'system'）。
+        const body = await readBody(req)
+        const rel = query.get('path') || body.path || ''
         if (!rel) return json(res, 400, { ok: false, error: '缺少 path' })
-        await setCardStatus(vaultRoot, rel, 'rejected')
-        json(res, 200, { ok: true, path: rel, status: 'rejected' })
+        const reason = String(query.get('reason') || body.reason || '').trim().slice(0, 300)
+        await setCardStatus(vaultRoot, rel, 'rejected', { changedBy: 'user', reason })
+        json(res, 200, { ok: true, path: rel, status: 'rejected', reason })
         return
       }
       case '/recycle/list': {
@@ -872,6 +928,16 @@ export function createApi(deps = {}) {
         if (dsh) {
           status.agents = [{ name: 'dsh', label: dsh.label || 'DSH (当前宿主)', installed: true, mcpConfigured: true, isDsh: true, recallTool: dsh.memoryRecallTool, autoCapture: dsh.autoCapture, autoRecall: dsh.autoRecall, vaultDir: dsh.vaultDir }, ...(status.agents || [])]
         }
+        // 汇总按「最终展示行」重算（DSH 宿主行也算一个已挂载 Agent）
+        const all = status.agents || []
+        const installed = all.filter((a) => a.installed)
+        const allServers = [...new Set(installed.flatMap((a) => (Array.isArray(a.servers) ? a.servers : [])))]
+        status.summary = {
+          detectedAgents: installed.length,
+          mountedAgents: all.filter((a) => a.mcpConfigured).length,
+          totalServers: allServers.length,
+          allServers,
+        }
         json(res, 200, status)
         return
       }

package/lib/capture.js

@@ -190,7 +190,7 @@ function cleanTitleLine(line) {
  * @param llm - dsh 的 llm 服务（ctx.get('llm')）
  * @param route - { provider, model } 解析结果
  * @param conversation - 本轮对话文本（用户+助手）
- * @param opts - { maxTokens, signal, existing }：existing 为 [{path,title,summary}]
+  * @param opts - { maxTokens, signal, existing, sessionId }：existing 为 [{path,title,summary}]；sessionId 透传给 LLM（issue #51）
  * @returns Promise<null | { save:boolean } | { save:true, title, kind, tags, body } | { append_to, update }>
  */
 export async function summarizeTurn(llm, route, conversation, opts = {}) {
@@ -225,6 +225,24 @@ export function isEffortUnsupported(provider, model) { return effortRejected.has
 /** 仅供测试：清空记忆。 */
 export function resetEffortUnsupported() { effortRejected.clear() }
 
+/**
+ * LLM 请求的会话标识（issue #51）。
+ *
+ * 为什么必须有：DSH 的 GenerateOptions 里有官方字段 `sessionId`，opencode-go 之类的网关
+ * **只在拿到它时**才注入 `x-opencode-session` 头；缺了这个头，网关一律 400
+ * `{"type":"MissingSessionID"}` —— 表现就是每一轮自动沉淀的首跳必然失败、白烧一次调用，
+ * 面板长期挂「⚠ 自动沉淀异常」（卡片其实靠换 provider 兜底建出来了）。
+ *
+ * 取值优先级：调用方透传的真实会话 id（同一会话的蒸馏可被网关按会话归并）→ 稳定常量
+ * （网关只要求"有值"，同值同样能复用路由；不要每次生成随机值，否则等于没有会话亲和）。
+ */
+const CAPTURE_LLM_SESSION_ID = 'memory-eternal-capture'
+const REFINE_LLM_SESSION_ID = 'memory-eternal-refine'
+export function resolveLlmSessionId(sessionId, fallback) {
+  const s = String(sessionId ?? '').trim()
+  return s || String(fallback || CAPTURE_LLM_SESSION_ID)
+}
+
 /**
  * 单次 JSON 调用（把「发请求 → 收 finish → 抽文本」这条链复用给非沉淀场景，如矛盾判别）。
  * 与 summarizeTurnDetailed 共享同一套兼容处理：失败经 finish 暴露（不静默成"无输出"）、
@@ -232,7 +250,7 @@ export function resetEffortUnsupported() { effortRejected.clear() }
  *
  * @returns {Promise<{text?:string, failure?:{code:string,message:string}}>}
  */
-export async function callLlmJson(llm, route, { system = '', user = '', maxTokens = 1500, purpose = 'memory-refine', signal } = {}) {
+export async function callLlmJson(llm, route, { system = '', user = '', maxTokens = 1500, purpose = 'memory-refine', signal, sessionId } = {}) {
   const { BlockAssembler, createUserMessage } = await importLlmHelpers()
   const messages = [createUserMessage({
     content: [{ type: 'text', text: String(user || '') }],
@@ -249,6 +267,8 @@ export async function callLlmJson(llm, route, { system = '', user = '', maxToken
     maxTokens,
     ...(effort ? { reasoningEffort: effort } : {}),
     purpose,
+    // issue #51：网关（opencode-go 等）靠它注入 x-opencode-session；缺了首跳必 400。
+    sessionId: resolveLlmSessionId(sessionId, REFINE_LLM_SESSION_ID),
     signal: signal ?? AbortSignal.timeout(60000),
   }
   const runOnce = async (o) => {
@@ -324,6 +344,9 @@ export async function summarizeTurnDetailed(llm, route, conversation, opts = {})
     maxTokens,
     ...(effort ? { reasoningEffort: effort } : {}),
     purpose: 'memory-capture',
+    // issue #51：透传真实会话 id（拿不到就退稳定常量）。缺这个字段时 opencode-go 的蒸馏
+    // 首跳会 400 MissingSessionID，每轮白烧一次调用 + 面板误报「自动沉淀异常」。
+    sessionId: resolveLlmSessionId(opts.sessionId, CAPTURE_LLM_SESSION_ID),
     signal: opts.signal ?? AbortSignal.timeout(45000),
   }
   const runOnce = async (streamOptions) => {