memory-eternal 0.10.20 → 0.10.22

package/lib/db.js

@@ -10,6 +10,75 @@ import { parseCard, KIND_ROOTS } from './vault.js'
 
 const DB_FILE = 'memory-eternal.db'
 
+/**
+ * 每个库的「打开时健康检查」结果（issue #33）。
+ *
+ * 为什么需要：老实现打开后只执行 `PRAGMA journal_mode=WAL` 就往下走 —— 而这条 PRAGMA
+ * **失败时不抛错**（只是把实际模式当一行返回），文件/目录不可写时也不会当场抱怨；于是插件
+ * 会以「写不进去」的状态一路静默运行：探针仍报健康、看门狗仍在保活、面板只是统计空掉，
+ * 用户看到的是一句没有上下文的 `attempt to write a readonly database`（有时还伴随看门狗误判）。
+ * 现在打开时**读回真实 journal 模式 + 真写一次探针**，把结论记在这里，由 /overview 与
+ * `dsh-memory doctor` 如实报出来。
+ */
+const healthByRoot = new Map()
+
+const CORRUPT_RE = /malformed|not a database|corrupt|disk image/i
+
+/** 真的写一次主库（建探针表→删掉）：验证「这个库现在能不能写」。temp 库不算，必须是主库。 */
+function probeWrite(db) {
+  try {
+    db.exec('CREATE TABLE IF NOT EXISTS _me_write_probe(x INTEGER)')
+    db.exec('DROP TABLE IF EXISTS _me_write_probe')
+    return { writable: true, error: '' }
+  } catch (e) {
+    return { writable: false, error: String((e && e.message) || e) }
+  }
+}
+
+/**
+ * 打开后的健康检查：真实的 journal 模式 + 写探针（+ 损坏判定）。
+ * @returns {{journalMode:string, writable:boolean, error:string, corrupt:boolean, checkedAt:number}}
+ */
+export function checkDbHealth(db) {
+  const out = { journalMode: '', writable: false, error: '', corrupt: false, checkedAt: Date.now() }
+  try {
+    out.journalMode = String(db.prepare('PRAGMA journal_mode').get().journal_mode || '')
+  } catch (e) {
+    out.error = String((e && e.message) || e)
+  }
+  const w = probeWrite(db)
+  out.writable = w.writable
+  if (!w.writable) out.error = out.error || w.error
+  out.corrupt = CORRUPT_RE.test(out.error || '')
+  return out
+}
+
+/** 某个库最近一次打开时的健康结论（没打开过返回 null）。 */
+export function dbStatus(root) {
+  return healthByRoot.get(path.resolve(root)) || null
+}
+
+/** 损坏 / 不可写时给人看的下一步（引导，不自动动数据）。 */
+export function rebuildGuidance(root, status) {
+  const dir = path.resolve(root)
+  const lines = []
+  if (status && status.corrupt) {
+    lines.push('数据库文件疑似损坏：' + status.error)
+    lines.push('修复方式（不会自动删你的数据）：')
+    lines.push('1) 先停下会写它的进程（退出 DSH / `dsh-memory stop --port 7999`），免得边恢复边写；')
+    lines.push('2) 备份现场：把 ' + path.join(dir, DB_FILE) + '（连同 -wal / -shm）复制到别处留证；')
+    lines.push('3) 查看可用备份：`dsh-memory doctor --vault "' + dir + '"`；')
+    lines.push('4) 用备份替换（备份文件在 ' + path.join(dir, 'backups') + '）：把选中的 .db 复制成 ' + DB_FILE + '，并删掉同名 -wal / -shm；')
+    lines.push('5) 重开 DSH，然后用 `dsh-memory doctor` 复核 writable=true。')
+  } else if (status && !status.writable) {
+    lines.push('数据库当前**不可写**：' + status.error)
+    lines.push('配置仍可保存（配置不经过数据库），但卡片读写/审核/图谱会失败。')
+    lines.push('排查方向：目录与文件的 ACL（' + dir + '）、盘符是否只读挂载、是否有别的进程以独占方式打开它。')
+    lines.push('确认方式：`dsh-memory doctor --vault "' + dir + '"`。')
+  }
+  return lines
+}
+
 /** 获取或创建 SQLite 数据库连接（单例 per root）。 */
 const instances = new Map()
 export function getDb(root) {
@@ -22,6 +91,12 @@ export function getDb(root) {
   db.exec('PRAGMA journal_mode=WAL')
   db.exec('PRAGMA foreign_keys=ON')
   initTables(db)
+  // 打开即体检：WAL 到底生效没有、这个库现在能不能写（#33）。结论供 /overview 与 doctor 使用。
+  const health = checkDbHealth(db)
+  healthByRoot.set(resolved, health)
+  if (!health.writable || (health.journalMode && health.journalMode !== 'wal')) {
+    for (const line of rebuildGuidance(resolved, health)) console.error('[memory-eternal] ' + line)
+  }
   instances.set(resolved, db)
   return db
 }

package/lib/refine.js

@@ -0,0 +1,168 @@
+// 记忆精炼 · 「矛盾扫描」（issue #36）
+//
+// 现有 /optimize 只按**相似度**聚类（>=0.55）并合并 —— 它解决「冗余」，但对「矛盾」是**危险**的：
+// 两张语义相近、结论互斥的卡（两种不能同时成立的配置、已被推翻的旧结论）相似度同样很高，
+// 会被当成重复、甚至被 mergeCards 合并掉（而 mergeCards 会**永久删除**源卡）。所以这里补另一半：
+//
+//   宽召回候选对 → LLM 只判「重复 / 补充 / 矛盾 / 无关」 → **人拍板**
+//
+// 两条硬约束：
+//   1. 扫描**绝不写库**（纯预览）；
+//   2. apply 必须由调用方显式给 action，且**只做可恢复动作**（keepA/keepB 送回收站、keepBoth 不动数据）；
+//      决策记进 vault 下的 refine-decisions.json，避免同一对反复骚扰人。
+import fs from 'node:fs'
+import path from 'node:path'
+import { getDb } from './db.js'
+import { deleteCard, mergeCards, textSimilarity } from './vault.js'
+import { callLlmJson, routeCandidates } from './capture.js'
+
+const DECISIONS_FILE = 'refine-decisions.json'
+const RELATIONS = new Set(['duplicate', 'complement', 'conflict', 'unrelated'])
+const pairKey = (a, b) => [String(a), String(b)].sort().join(' | ')
+
+/** 读取历史决策（不存在则空表）。 */
+export function readDecisions(root) {
+  try { return JSON.parse(fs.readFileSync(path.join(root, DECISIONS_FILE), 'utf8')) || {} } catch { return {} }
+}
+
+function writeDecisions(root, data) {
+  const file = path.join(root, DECISIONS_FILE)
+  const tmp = file + '.tmp'
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf8')
+  fs.renameSync(tmp, file)
+}
+
+function rowsOf(root) {
+  const db = getDb(root)
+  return db.prepare("SELECT path, title, kind, body, updated_at FROM cards WHERE status = 'approved' ORDER BY updated_at DESC").all()
+}
+
+/**
+ * 宽召回：相似度 >= minSim 的卡片对（默认 0.30，含**近重复**那一段 —— 恰恰因为一键优化会按相似度
+ * 盲合并，语义相近但结论互斥的对（最危险的那种）必须也送进判别）。已决策过的对会被跳过。
+ * 用正文前缀算相似度（全量 O(n²) 太贵），并跳过已做过决策的对。
+ */
+export async function refineCandidates(root, { minSim = 0.30, maxSim = 1.0, limit = 40, maxCards = 300 } = {}) {
+  const rows = rowsOf(root).slice(0, Math.max(2, Number(maxCards) || 300))
+  const decided = readDecisions(root)
+  const lite = rows.map((r) => ({ path: r.path, title: r.title, kind: r.kind, body: String(r.body || ''), head: String(r.body || '').slice(0, 600) }))
+  const out = []
+  for (let i = 0; i < lite.length; i++) {
+    for (let j = i + 1; j < lite.length; j++) {
+      const a = lite[i], b = lite[j]
+      if (decided[pairKey(a.path, b.path)]) continue
+      const sim = textSimilarity(a.head, b.head)
+      if (sim < minSim || sim > maxSim) continue
+      out.push({
+        a: { path: a.path, title: a.title, kind: a.kind, body: a.body.slice(0, 2000) },
+        b: { path: b.path, title: b.title, kind: b.kind, body: b.body.slice(0, 2000) },
+        sim: Math.round(sim * 1000) / 1000,
+      })
+    }
+  }
+  out.sort((x, y) => y.sim - x.sim)
+  return out.slice(0, Math.max(1, Number(limit) || 40))
+}
+
+/** 容错解析判别输出（模型偶尔裹代码块或有前后话）。 */
+export function parseJudge(text) {
+  let s = String(text || '').trim()
+  s = s.replace(/^```(?:json)?/i, '').replace(/```$/, '').trim()
+  const start = s.indexOf('{')
+  const end = s.lastIndexOf('}')
+  if (start >= 0 && end > start) s = s.slice(start, end + 1)
+  let obj = null
+  try { obj = JSON.parse(s) } catch { return null }
+  if (!obj || typeof obj !== 'object') return null
+  const relation = RELATIONS.has(String(obj.relation)) ? String(obj.relation) : 'unrelated'
+  const keep = ['A', 'B', 'both'].includes(String(obj.keep)) ? String(obj.keep) : 'both'
+  return {
+    relation,
+    keep,
+    conflict: String(obj.conflict || '').slice(0, 300),
+    reason: String(obj.reason || '').slice(0, 300),
+  }
+}
+
+/** 交给模型判别一对卡片的关系（只输出 JSON）。 */
+export async function judgeRefinePair(llm, route, a, b) {
+  const system = [
+    '你是本地知识库的「关系判别器」。给你两张已审核的知识卡，你只做一件事：判断它们的关系。',
+    '只输出严格 JSON（不要 markdown 代码块、不要多余文字）：',
+    '{"relation":"duplicate|complement|conflict|unrelated","conflict":"若矛盾，一句话说明冲突点；否则空串","keep":"A|B|both","reason":"一句话理由"}',
+    '判定口径：',
+    '- duplicate：说的基本是同一件事，可以合并；',
+    '- complement：不冲突，且各自有独立价值，应当都保留；',
+    '- conflict：结论 / 参数 / 做法**互斥**（例如两种不能同时成立的配置、旧结论已被新结论推翻）—— 这类必须人判断，不要建议自动合并；',
+    '- unrelated：只是字面有点像，实际无关。',
+    'keep：若必须只留一张，留哪张（A 或 B）；无法取舍或应当都留 → both。',
+  ].join('\n')
+  const pack = (tag, x) => '### 卡 ' + tag + '：' + x.title + '\n（路径 ' + x.path + '）\n' + String(x.body || '').slice(0, 1800)
+  const user = [pack('A', a), pack('B', b), '请输出 JSON。'].join('\n\n')
+  const res = await callLlmJson(llm, route, { system, user, maxTokens: 800, purpose: 'memory-refine-judge' })
+  if (res.failure) return { failure: res.failure }
+  const judge = parseJudge(res.text)
+  if (!judge) return { failure: { code: 'UNPARSEABLE_OUTPUT', message: '判别输出不是合法 JSON：' + String(res.text || '').slice(0, 120) } }
+  return { judge }
+}
+
+/**
+ * 扫描：宽召回 → 逐对判别。**只读**，返回发现（不动任何卡片）。
+ * @param {{llm:any, limit?:number, provider?:string, model?:string, minSim?:number, maxSim?:number}} opts
+ */
+export async function refineScan(root, { llm, limit = 12, provider, model, minSim, maxSim } = {}) {
+  if (!llm) return { ok: false, error: '当前进程拿不到 llm 服务（请在 DSH 面板里跑，或由宿主触发）' }
+  const cands = await refineCandidates(root, { minSim, maxSim })
+  if (!cands.length) return { ok: true, findings: [], skipped: [], candidates: 0 }
+  let routes = []
+  try { routes = await routeCandidates(llm, { provider, model }) } catch { routes = [] }
+  if (!routes.length) return { ok: false, error: '取不到模型路由（llm.listProviders 为空）' }
+  const route = routes[0]
+  const findings = []
+  const skipped = []
+  for (const c of cands.slice(0, Math.max(1, Number(limit) || 12))) {
+    let r
+    try { r = await judgeRefinePair(llm, route, c.a, c.b) } catch (e) { r = { failure: { code: 'EXCEPTION', message: String((e && e.message) || e) } } }
+    if (r.failure) { skipped.push({ a: c.a.path, b: c.b.path, sim: c.sim, error: r.failure.code + ': ' + r.failure.message }); continue }
+    if (r.judge.relation === 'unrelated') { skipped.push({ a: c.a.path, b: c.b.path, sim: c.sim, error: 'unrelated' }); continue }
+    findings.push({ ...c, ...r.judge })
+  }
+  return { ok: true, candidates: cands.length, useModel: route.provider + '/' + route.model, findings, skipped }
+}
+
+/**
+ * 执行人的决定。**只做可恢复动作**：
+ *   keepA / keepB → 另一张进**回收站**（deleteCard 默认非永久，可从回收中心还原）
+ *   merge         → 走现有 mergeCards（新卡 pending 进审核队列）
+ *   keepBoth      → 不动数据（常用于"前提不同、都留"）
+ * 任何 action 都会把这一对记进 refine-decisions.json，避免下次扫描重复打扰。
+ */
+export async function refineApply(root, { a, b, action, note = '', relation = '' } = {}) {
+  const pa = String(a || '').trim()
+  const pb = String(b || '').trim()
+  if (!pa || !pb) return { ok: false, error: '缺少 a / b' }
+  const act = String(action || '').trim()
+  if (!['keepA', 'keepB', 'merge', 'keepBoth'].includes(act)) return { ok: false, error: '未知动作：' + act + '（可选 keepA / keepB / merge / keepBoth）' }
+  let result = { ok: true, action: act }
+  if (act === 'keepA' || act === 'keepB') {
+    const drop = act === 'keepA' ? pb : pa
+    try {
+      const r = await deleteCard(root, drop)                      // 默认进回收站，可还原
+      result.removed = drop
+      result.recoverable = true
+      if (r && r.ok === false) { result.ok = false; result.error = r.error || '删除失败' }
+    } catch (e) { result.ok = false; result.error = String((e && e.message) || e) }
+  } else if (act === 'merge') {
+    try {
+      const r = await mergeCards(root, [pa, pb])
+      result.merged = r
+      if (!r || r.ok === false) { result.ok = false; result.error = (r && r.error) || '合并失败' }
+    } catch (e) { result.ok = false; result.error = String((e && e.message) || e) }
+  }
+  if (result.ok) {
+    const data = readDecisions(root)
+    data[pairKey(pa, pb)] = { action: act, relation: String(relation || ''), note: String(note || '').slice(0, 500), at: Date.now() }
+    try { writeDecisions(root, data) } catch (e) { result.recordError = String((e && e.message) || e) }
+  }
+  return result
+}

package/lib/vault.js

@@ -1058,7 +1058,15 @@ export async function optimizeApply(root, opts = {}) {
   const cleanupStale = Boolean(opts.cleanupStale)
   const dryRun = Boolean(opts.dryRun)
   const cands = await optimizeCandidates(root)
-  const merge = cands.merge
+  // issue #36：**被判为矛盾的对绝不参与盲合并** —— 相似度高不等于可以合并，两张互斥的卡合并
+  // 会把冲突悄悄"和解"掉（且 mergeCards 会永久删除源卡）。决策来自「矛盾扫描」的 refine-decisions.json。
+  const { readDecisions } = await import('./refine.js')
+  const decided = readDecisions(root)
+  const merge = cands.merge.filter((p) => {
+    const key = [String(p.a.path), String(p.b.path)].sort().join(' | ')
+    const d = decided[key]
+    return !(d && (d.relation === 'conflict' || d.action === 'keepBoth'))
+  })
   const stale = cands.stale
   const merged = []
   const staleDeleted = []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memory-eternal",
-  "version": "0.10.20",
+  "version": "0.10.22",
   "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"
+    "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"
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1"

package/scripts/release.mjs

@@ -48,6 +48,28 @@ const NPM = (() => {
   return hit ? { cmd: process.execPath, args: [hit] } : { cmd: 'npm.cmd', args: [] }
 })()
 
+/** 未完成的发布动作（推送失败 / Release 失败）：最后汇总，并让退出码非零 —— 绝不淹没在"完成"里。 */
+const problems = []
+
+/**
+ * npm 上真的存在这个版本吗？**只信 version 端点**。
+ * 教训（0.10.21 实测）：本地 packument 缓存会说"没有"（`npm view` 404），边缘缓存又会说"有"
+ * （`GET /memory-eternal` 的 versions 里查不到）—— 只有 `/memory-eternal/<版本>` 与 tarball URL 靠谱。
+ */
+const npmHasVersion = async (v) => {
+  try {
+    const r = await fetch(`https://registry.npmjs.org/memory-eternal/${v}`, { cache: 'no-store' })
+    return r.status === 200
+  } catch { return false }
+}
+const waitNpmVersion = async (v, { tries = 12, delayMs = 5000 } = {}) => {
+  for (let i = 0; i < tries; i++) {
+    if (await npmHasVersion(v)) return true
+    await new Promise((r) => setTimeout(r, delayMs))
+  }
+  return false
+}
+
 const run = (cmd, argv, { cwd = ROOT, allowFail = false } = {}) => {
   // Windows 上 npm 只是 .cmd 垫片：execFileSync('npm', …) 直接 ENOENT（Node ≥18 起 spawn
   // .cmd 还要 shell:true，而 shell 拼参数对含空格/中文的 tag 与说明不安全）。所以优先用
@@ -130,15 +152,23 @@ step(3, 'npm publish')
 if (SKIP_NPM) {
   say('（已跳过）')
 } else {
-  const already = run('npm', ['view', `memory-eternal@${pkg.version}`, 'version'], { allowFail: true })
-  if (already.ok && already.out.includes(pkg.version)) {
-    say(`npm 上已存在 ${pkg.version}，跳过发布`)
-  } else if (DRY) {
+  if (DRY) {
     say(`[dry-run] 将执行：npm publish --access public（${pkg.version}）`)
   } else {
-    const r = run('npm', ['publish', '--access public'], { allowFail: true })
-    if (!r.ok) throw new Error(`npm publish 失败（2FA / 网络 / 版本冲突？）：\n${r.out}`)
-    say(`npm publish 完成：memory-eternal@${pkg.version}`)
+    const published = await npmHasVersion(pkg.version)
+    if (published) {
+      say(`npm 上已存在 ${pkg.version}，跳过发布`)
+    } else {
+      const r = run('npm', ['publish', '--access public'], { allowFail: true })
+      if (!r.ok) throw new Error(`npm publish 失败（2FA / 网络 / 版本冲突？）：\n${r.out}`)
+      say(`npm publish 已执行：memory-eternal@${pkg.version}（等待 registry 可见…）`)
+    }
+    // **不信 stdout，只信 registry**：publish 返回 0 不代表包真的上去了（0.10.21 实测：
+    // 本地 packument/npm view 缓存会假装没有，边缘缓存又会假装有）—— 用 version 端点实证。
+    if (!(await waitNpmVersion(pkg.version))) {
+      throw new Error(`npm 上查不到 ${pkg.version}（version 端点超时）：发布可能未生效，请手动 \`npm publish --access public\` 后复核 https://registry.npmjs.org/memory-eternal/${pkg.version}`)
+    }
+    say(`npm 校验通过：https://registry.npmjs.org/memory-eternal/${pkg.version} → 200`)
   }
 }
 
@@ -160,6 +190,10 @@ for (const remote of remotes) {
   const a = run('git', ['push', remote, 'main'], { allowFail: true })
   const b = run('git', ['push', remote, tag], { allowFail: true })
   say(`${remote}: main ${a.ok ? '✓' : '✗ ' + a.out.slice(0, 200)} | tag ${b.ok ? '✓' : '✗ ' + b.out.slice(0, 200)}`)
+  // 推失败绝不能被"完成"淹没（0.10.18 实测：origin main 没上去、只有 tag 上去了，
+  // 而脚本照样打印完成 —— 用户按 GitHub main 安装就会拿到旧版）。记进问题清单。
+  if (!a.ok) problems.push(`${remote} main 未推送成功（${a.out.slice(0, 120)}）→ 重试：git push ${remote} main`)
+  if (!b.ok) problems.push(`${remote} tag ${tag} 未推送成功（${b.out.slice(0, 120)}）→ 重试：git push ${remote} ${tag}`)
 }
 
 // ---- 5. GitHub Release ---------------------------------------------------
@@ -174,6 +208,7 @@ else {
   } else {
     const r = run('gh', ['release', 'create', tag, '--repo', 'EternalNight996/memory-eternal', '--title', title, '--notes-file', notesPath], { allowFail: true })
     say(r.ok ? `GitHub Release 创建成功：${r.out}` : `GitHub Release 失败：${r.out.slice(0, 300)}`)
+    if (!r.ok) problems.push('GitHub Release 创建失败 → 重试：gh release create ' + tag)
   }
 }
 
@@ -207,12 +242,18 @@ if (!giteeToken) {
     })
     const text = await res.text()
     if (res.ok) say(`Gitee Release 创建成功：${tag}`)
-    else say(`⚠ Gitee Release 失败（HTTP ${res.status}）：${text.slice(0, 300)}`)
+    else { say(`⚠ Gitee Release 失败（HTTP ${res.status}）：${text.slice(0, 300)}`); problems.push('Gitee Release 创建失败（HTTP ' + res.status + '）') }
   }
 }
 
 // ---- 7. 汇总 ------------------------------------------------------------
 step(7, `完成${DRY ? '（dry-run，未写任何远端）' : ''}`)
 say(`版本 ${pkg.version} | tag ${tag}`)
+if (problems.length) {
+  say('')
+  say('⚠ 有未完成的发布动作（**不要当作已发布完成**）：')
+  for (const x of problems) say('  · ' + x)
+  process.exitCode = 1   // 让脚本/CI 能发现"三端没齐"
+}
 say('提醒：桌面版用户需 `cd ~/.dsh/profiles/desktop && pnpm update memory-eternal` 后重启 DSH；')
 say('      dsh web 用户需 `cd ~/.dsh/profiles/web && pnpm add memory-eternal@' + pkg.version + '`。')