memory-eternal 0.21.0 → 0.22.0

package/lib/db.js

@@ -213,6 +213,18 @@ function initTables(db) {
 
     CREATE INDEX IF NOT EXISTS idx_card_updates_card ON card_updates(card_id);
 
+    -- 审核制修改：待审副本 → 原卡。agent 只能提交副本，通过后由 setCardStatus 覆盖原卡。
+    -- 单独建表（而不是给两张卡表加列）：旧库打开时 CREATE TABLE IF NOT EXISTS 即可补上，无需迁移。
+    CREATE TABLE IF NOT EXISTS card_revisions (
+      revision_path TEXT PRIMARY KEY,
+      target_path TEXT NOT NULL,
+      target_id INTEGER,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_card_revisions_target ON card_revisions(target_path);
+
     CREATE TABLE IF NOT EXISTS feedback (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       query TEXT NOT NULL,

package/lib/mcp.js

@@ -5,7 +5,8 @@
 // （stdout 是协议通道，被 console.log 污染会破坏握手）。
 //
 // 支持的协议版本：2025-06-18 / 2025-03-26 / 2024-11-05（协商取请求版本）。
-// 工具：memory_recall / memory_capture / memory_stats / memory_audit_list。
+// 工具：memory_recall / memory_capture / memory_stats / memory_audit_list / memory_revise。
+// memory_revise 只**提交**修改副本进审核（不会直接改库、不能批准），与 issue #17 的审核边界一致。
 //
 // 审核边界（issue #17）：MCP 侧**只读**。新增的 memory_audit_list 只列待审/驳回，
 // 不提供任何 approve/reject —— 否则任何接了 MCP 的智能体都能批准自己刚写进去的卡，
@@ -14,7 +15,7 @@
 // 启动：node bin/dsh-memory.mjs mcp   （或 node lib/mcp.js）
 
 import readline from 'node:readline'
-import { search, overview, stats, ensureVault, listCards, countCards } from './vault.js'
+import { search, overview, stats, ensureVault, listCards, countCards, reviseCard } from './vault.js'
 import { runStandaloneCapture, defaultVaultDir } from './capture-run.js'
 import { recordLedger } from './ledger.js'
 
@@ -72,6 +73,25 @@ export const MCP_TOOLS = [
       },
     },
   },
+  {
+    name: 'memory_revise',
+    description:
+      '提交「审核制修改」：把一张已批准的知识卡复制成待审副本（可改标题/标签/正文），进入审核中心。' +
+      '人工批准后才会覆盖原卡；agent 不能直接改已入库内容，也不能自己批准。' +
+      '用于修正过期/错误的知识 —— 比再写一张新卡更干净（审核界面会标成「修改」，通过即覆盖）。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: '要修改的原卡 path（memory_recall 结果里的「路径：…」）' },
+        title: { type: 'string', description: '新标题（不改就不传）' },
+        tags: { type: 'array', items: { type: 'string' }, description: '新标签（不改就不传）' },
+        body: { type: 'string', description: '新正文（不改就不传）' },
+        reason: { type: 'string', description: '修改原因，会显示在审核中心' },
+        source: { type: 'string', description: '来源标记，如 claude-code / codex' },
+      },
+      required: ['path'],
+    },
+  },
 ]
 
 function toolResult(text, isError = false) {
@@ -108,6 +128,25 @@ export async function callTool(name, args, vaultRoot, meta = {}) {
       if (!out.ok && out.action === 'failed') return toolResult(`沉淀失败：${out.reason}`, true)
       return toolResult(JSON.stringify(out))
     }
+    case 'memory_revise': {
+      const rel = String(args?.path || '').trim()
+      if (!rel) return toolResult('（未提供要修改的卡片 path）')
+      try {
+        const src = String(args?.source || meta.submittedBy || 'mcp')
+        const out = await reviseCard(vaultRoot, {
+          target: rel,
+          title: args?.title === undefined ? undefined : String(args.title),
+          tags: Array.isArray(args?.tags) ? args.tags : undefined,
+          body: args?.body === undefined ? undefined : String(args.body),
+          reason: String(args?.reason || ''),
+          source: src,
+          submittedBy: src,
+        })
+        return toolResult('已提交修改，待人工审核通过后覆盖原卡。\n修改副本：' + out.path + '\n原卡：' + out.target + (out.reused ? '\n（已存在待审修改，本次就地更新，未新增条目）' : ''))
+      } catch (e) {
+        return toolResult('提交修改失败：' + ((e && e.message) || e), true)
+      }
+    }
     case 'memory_audit_list': {
       await ensureVault(vaultRoot)
       const wanted = String(args?.status || 'pending').toLowerCase()

package/lib/node-bin.js

@@ -11,8 +11,9 @@
 //
 // 本模块把「找出一个真正能跑 node 脚本的子进程入口」收敛到一处：
 //   1. MEMORY_ETERNAL_NODE 显式指定（逃生口，便于测试与非常规宿主）；
-//   2. 非 Electron 宿主：process.execPath 本身就是 node，直接用；
-//   3. Electron 宿主：优先从 PATH 找真正的 node；
+//   2. 非 Electron 宿主：**优先从 PATH 找 node**（issue #56：brew/nvm/volta 在 PATH 上的入口
+//      是稳定 shim，而 process.execPath 是带版本号的真实路径），execPath 降为兜底；
+//   3. Electron 宿主：同样优先从 PATH 找真正的 node；
 //   4. 都找不到时退回 process.execPath，并由 childEnv() 打开
 //      ELECTRON_RUN_AS_NODE，让 Electron 二进制以纯 node 模式运行。
 
@@ -22,8 +23,8 @@ import path from 'node:path'
 let cachedBinary = null
 let cachedSource = null
 
-/** 在 PATH 中查找真正的 node 可执行文件；找不到返回 null。 */
-function findNodeOnPath() {
+/** 在 PATH 中查找真正的 node 可执行文件；找不到返回 null。（导出便于测试断言 PATH 优先） */
+export 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) {
@@ -72,17 +73,21 @@ export function nodeBinary() {
   }
 
   if (!process.versions.electron) {
-    // 非 Electron：正常情况下 process.execPath 就是 node 本身；但**长命进程**（watchdog）的
-    // execPath 指向的是它启动时那份 node —— brew 升级后可能已被删除（#44）。此时退回 PATH。
-    if (exists(process.execPath)) {
-      cachedBinary = process.execPath
-      cachedSource = 'execPath'
-      return cachedBinary
-    }
+    // issue #56：非 Electron 下**必须 PATH 优先**。process.execPath 是「这一次装的那份 node」的
+    // 真实路径（macOS Homebrew：/opt/homebrew/Cellar/node/26.13.0_2/bin/node），它会被写进
+    // ~/.claude.json 等外部客户端的 MCP 条目；brew upgrade node 一删旧目录，这些条目就 ENOENT。
+    // PATH 上的入口（/opt/homebrew/bin/node、~/.volta/bin/node、nvm 的 shim）才是稳定的。
+    // 同时它决定了 align 的 currentNodePath —— 写入侧与校验侧一起收敛到 shim，才不会互相打脸。
+    // execPath 仍保留为兜底（PATH 上没有 node 时行为与 #44 之前一致）。
     const viaPath = findNodeOnPath()
     if (viaPath) {
       cachedBinary = viaPath
-      cachedSource = 'path-fallback'
+      cachedSource = 'path'
+      return cachedBinary
+    }
+    if (exists(process.execPath)) {
+      cachedBinary = process.execPath
+      cachedSource = 'execPath'
       return cachedBinary
     }
     cachedBinary = process.execPath

package/lib/vault.js

@@ -341,7 +341,7 @@ export async function listCards(root, { status, kind, agent, tag = '', limit, of
       rows.push(...db.prepare(`SELECT * FROM ${store.table} WHERE path IN (${ph})`).all(...paths))
     }
     const byPath = new Map(rows.map((r) => [r.path, rowToCard(r)]))
-    return page.map((r) => byPath.get(r.path)).filter(Boolean)
+    return attachRevisions(db, page.map((r) => byPath.get(r.path)).filter(Boolean))
   }
 
   const tail = Number.isInteger(limit) && limit > 0
@@ -355,7 +355,7 @@ export async function listCards(root, { status, kind, agent, tag = '', limit, of
     { kind, agent, tag, tail },
   )
   const finalArgs = Number.isInteger(limit) && limit > 0 ? [...args, limit, Math.max(0, offset | 0)] : args
-  return db.prepare(sql).all(...finalArgs).map(rowToCard)
+  return attachRevisions(db, db.prepare(sql).all(...finalArgs).map(rowToCard))
 }
 
 /** 计数（分页接口要用 total 判断还有没有下一页）。 */
@@ -464,12 +464,15 @@ export async function readCard(root, rel, { allowUnapproved = false } = {}) {
   }
   const status = String(row.status || '')
   const { text } = rowToMarkdown(row)
+  // 修改副本要带上「改的是哪张卡」，审核界面据此标注「修改」而不是「新卡」。
+  const rev = getRevision(db, rel)
+  const revision = rev ? { targetPath: rev.target_path, targetId: rev.target_id } : null
   const updates = db.prepare('SELECT content, created_at FROM card_updates WHERE card_id = ? ORDER BY created_at ASC').all(row.id)
   if (updates.length > 0) {
     const updateLines = updates.map((u) => `- ${u.created_at.slice(0, 10)}：${u.content}`)
-    return { path: rel, status, store: mainRow ? 'main' : 'quarantine', text: text + '\n## 更新记录\n\n' + updateLines.join('\n') + '\n' }
+    return { path: rel, status, store: mainRow ? 'main' : 'quarantine', text: text + '\n## 更新记录\n\n' + updateLines.join('\n') + '\n', ...(revision ? { revision } : {}) }
   }
-  return { path: rel, status, store: mainRow ? 'main' : 'quarantine', text }
+  return { path: rel, status, store: mainRow ? 'main' : 'quarantine', text, ...(revision ? { revision } : {}) }
 }
 
 /** 状态中文标签（错误信息与日志用）。 */
@@ -499,6 +502,11 @@ export async function deleteCard(root, rel, { permanent = false } = {}) {
         db.prepare('DELETE FROM card_updates WHERE card_id = ?').run(id)
         db.prepare('DELETE FROM feedback WHERE card_path = ?').run(rel)
       }
+      // 修改副本与原卡的关联也一起清掉：删原卡时，指向它的待审副本没有应用对象了
+      const revs = db.prepare('SELECT revision_path FROM card_revisions WHERE target_path = ?').all(rel)
+      for (const r of revs) db.prepare('DELETE FROM quarantine WHERE path = ?').run(r.revision_path)
+      db.prepare('DELETE FROM card_revisions WHERE target_path = ?').run(rel)
+      db.prepare('DELETE FROM card_revisions WHERE revision_path = ?').run(rel)
       db.prepare('DELETE FROM cards WHERE path = ?').run(rel)
       db.prepare('DELETE FROM quarantine WHERE path = ?').run(rel)
     })
@@ -522,6 +530,8 @@ export async function restoreCard(root, rel) {
   const db = getDb(root)
   const existing = db.prepare('SELECT status FROM quarantine WHERE path = ?').get(rel)
   if (!existing) throw new Error('卡片不在回收站/隔离区: ' + rel)
+  // 修改副本不能「恢复」成一张独立卡 —— 那会跟原卡重复。它只能被批准（覆盖原卡）或删除。
+  if (getRevision(db, rel)) throw new Error('这是知识卡的修改副本：请在审核中心「批准」以覆盖原卡，或直接删除')
   const r = moveCardBetweenStores(db, 'quarantine', 'cards', rel, { status: MAIN_STATUS, deletedAt: null })
   db.prepare('INSERT INTO audit_log (card_path, old_status, new_status, changed_by, reason) VALUES (?, ?, ?, ?, ?)').run(rel, existing.status, MAIN_STATUS, 'restore', '回收站恢复')
   return { ok: true, restored: true, ...r }
@@ -539,6 +549,12 @@ export async function setCardStatus(root, rel, status, { changedBy = 'system', r
   const existing = findCardRow(db, rel)
   if (!existing) throw new Error('卡片不存在: ' + rel)
 
+  // 审核制修改：待审副本被批准 = 用副本内容覆盖原卡（身份/状态/类型不变），副本随即消失。
+  if (target === MAIN_STATUS && existing.table === 'quarantine') {
+    const rev = getRevision(db, rel)
+    if (rev) return applyRevision(db, rel, rev, { changedBy, reason })
+  }
+
   if (target === MAIN_STATUS) {
     if (existing.table === 'cards') {
       db.prepare('UPDATE cards SET status = ?, updated_at = ? WHERE path = ?').run(target, new Date().toISOString(), rel)
@@ -702,6 +718,99 @@ export async function updateCardContent(root, rel, { title, tags, body, reason }
   return { ok: true, path: rel, store: found.table, updated: now }
 }
 
+// ── 审核制修改（agent 提交 → 人工审核 → 覆盖原卡）────────────────────────
+
+/** 查「待审副本 → 原卡」映射；不是修改副本时返回 null。 */
+function getRevision(db, revisionPath) {
+  return db.prepare('SELECT * FROM card_revisions WHERE revision_path = ?').get(revisionPath) || null
+}
+
+/** 给卡片对象挂上 revision 信息（审核中心据此标「修改」而不是「新卡」）。 */
+function attachRevisions(db, cards) {
+  if (!cards.length) return cards
+  const ph = cards.map(() => '?').join(',')
+  const rows = db.prepare(`SELECT revision_path, target_path, target_id FROM card_revisions WHERE revision_path IN (${ph})`).all(...cards.map((c) => c.path))
+  if (!rows.length) return cards
+  const byPath = new Map(rows.map((r) => [r.revision_path, r]))
+  const targets = [...new Set(rows.map((r) => r.target_path))]
+  const tph = targets.map(() => '?').join(',')
+  const titles = new Map(db.prepare(`SELECT path, title FROM cards WHERE path IN (${tph})`).all(...targets).map((r) => [r.path, r.title]))
+  return cards.map((c) => {
+    const r = byPath.get(c.path)
+    return r ? { ...c, revision: { targetPath: r.target_path, targetId: r.target_id, targetTitle: titles.get(r.target_path) || '' } } : c
+  })
+}
+
+/**
+ * 提交一张「审核制修改」：把已批准的卡片复制一份到隔离区（status=pending），
+ * 内容用调用方给的新标题/标签/正文。**这里绝不改原卡** —— 只有审核通过（setCardStatus）
+ * 才会用副本覆盖原卡。agent 走 /card/revise 或 MCP memory_revise，只能到这一步。
+ *
+ * 同一张卡已有待审修改时就地更新，避免审核队列里堆一串同一张卡的副本。
+ */
+export async function reviseCard(root, { target, title, tags, body, reason = '', source = '', submittedBy = '' } = {}) {
+  const db = getDb(root)
+  const rel = String(target || '').trim()
+  if (!rel) throw new Error('缺少要修改的卡片 path')
+  const found = findCardRow(db, rel)
+  if (!found) throw new Error('原卡片不存在: ' + rel)
+  if (found.table !== 'cards') throw new Error('只能修改已审核通过的卡片（当前状态：' + found.row.status + '）')
+  const targetRow = found.row
+  // 已有待审修改时，未传的字段沿用副本当前值（否则第二次提交会把上次的改动抹掉）
+  const pending = db.prepare('SELECT q.* FROM card_revisions r JOIN quarantine q ON q.path = r.revision_path WHERE r.target_path = ? AND q.status = ?').get(rel, 'pending')
+  const baseRow = pending || targetRow
+  const nextTitle = title === undefined ? baseRow.title : String(title).trim()
+  const nextTags = tags === undefined ? normalizeTags(baseRow.tags) : normalizeTags(tags)
+  const nextBody = body === undefined ? String(baseRow.body).trim() : String(body).trim()
+  if (!nextTitle) throw new Error('标题不能为空')
+  if (!nextBody) throw new Error('正文不能为空')
+  const now = new Date().toISOString()
+  if (pending) {
+    db.prepare('UPDATE quarantine SET title = ?, tags = ?, body = ?, summary = ?, updated_at = ?, reason = ? WHERE path = ?')
+      .run(nextTitle, JSON.stringify(nextTags), nextBody, nextBody.slice(0, 200), now, reason || pending.reason || '', pending.path)
+    db.prepare('UPDATE card_revisions SET updated_at = ? WHERE revision_path = ?').run(now, pending.path)
+    return { ok: true, path: pending.path, target: rel, targetId: targetRow.id, reused: true, status: 'pending' }
+  }
+  // 副本放在独立目录 99-Revisions/：不与任何 kind 根目录冲突，也永远不会被当成新卡批准进主库
+  const base = `99-Revisions/${safeSlug(targetRow.title || 'card')}`
+  let revisionPath = `${base}.md`
+  let i = 2
+  while (pathTaken(db, revisionPath)) { revisionPath = `${base}-${i}.md`; i++ }
+  const id = nextCardId(db)
+  db.prepare(`
+    INSERT INTO quarantine
+      (id, path, kind, title, tags, body, summary, status, source, submitted_by, severity, reason, created_at, updated_at, quarantined_at, quarantine_reason)
+    VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?, 'info', ?, ?, ?, datetime('now'), '修改待审')
+  `).run(id, revisionPath, targetRow.kind, nextTitle, JSON.stringify(nextTags), nextBody, nextBody.slice(0, 200), source, submittedBy, reason || ('修改知识卡：' + rel), now, now)
+  db.prepare('INSERT INTO card_revisions (revision_path, target_path, target_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?)').run(revisionPath, rel, targetRow.id, now, now)
+  db.prepare('INSERT INTO audit_log (card_path, old_status, new_status, changed_by, reason) VALUES (?, ?, ?, ?, ?)').run(revisionPath, null, 'pending', submittedBy || 'agent', '提交修改：' + rel)
+  return { ok: true, path: revisionPath, target: rel, targetId: targetRow.id, reused: false, status: 'pending' }
+}
+
+/**
+ * 审核通过修改副本：用副本内容覆盖原卡，副本及其映射一起消失。
+ * 只改内容（标题 / 标签 / 正文 / 摘要 + updated_at）；状态、类型、来源、创建时间仍属原卡。
+ */
+function applyRevision(db, revisionPath, rev, { changedBy = 'user', reason = '' } = {}) {
+  return inTransaction(db, () => {
+    const revRow = db.prepare('SELECT * FROM quarantine WHERE path = ?').get(revisionPath)
+    if (!revRow) throw new Error('修改副本不存在: ' + revisionPath)
+    const target = db.prepare('SELECT * FROM cards WHERE path = ?').get(rev.target_path)
+    if (!target) throw new Error('原卡片已不存在（可能已被删除）：' + rev.target_path)
+    const now = new Date().toISOString()
+    const tags = normalizeTags(revRow.tags)
+    db.prepare('UPDATE cards SET title = ?, tags = ?, body = ?, summary = ?, updated_at = ? WHERE path = ?')
+      .run(revRow.title, JSON.stringify(tags), revRow.body, String(revRow.body).trim().slice(0, 200), now, rev.target_path)
+    db.prepare('INSERT INTO card_updates (card_id, content, created_at) VALUES (?, ?, ?)')
+      .run(target.id, '经审核修改：' + (reason || ('由 ' + (revRow.submitted_by || 'agent') + ' 提交，' + changedBy + ' 批准')), now)
+    db.prepare('DELETE FROM quarantine WHERE path = ?').run(revisionPath)
+    db.prepare('DELETE FROM card_revisions WHERE revision_path = ?').run(revisionPath)
+    db.prepare('INSERT INTO audit_log (card_path, old_status, new_status, changed_by, reason) VALUES (?, ?, ?, ?, ?)')
+      .run(rev.target_path, MAIN_STATUS, MAIN_STATUS, changedBy, '应用修改（来源 ' + revisionPath + '）')
+    return { ok: true, status: MAIN_STATUS, store: 'cards', applied: true, path: rev.target_path, revisionPath, updated: now }
+  })
+}
+
 /** 合并多张卡为一张。 */
 export async function mergeCards(root, paths) {
   const list = (Array.isArray(paths) ? paths : []).map((p) => String(p || '').trim()).filter(Boolean)

package/orca-plugin/orca-plugin.json

@@ -3,7 +3,7 @@
   "id": "memory-eternal",
   "publisher": "eternalnight996",
   "name": "memory-eternal",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Memory Atlas for Orca: open the local memory vault, pending review and knowledge graph from a sandboxed Orca panel.",
   "author": {
     "name": "EternalNight996",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memory-eternal",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "记忆核心（Memory Eternal）：自研的 DeepSeek Harness 记忆插件，不移植任何既有记忆框架——对话结束后自动沉淀知识卡到本地 Markdown Vault（自研去重、自研 CJK 检索、可 git 管理），设置页提供图形化知识库（统计 / 搜索 / 知识图谱 + 侧边栏一键弹窗），Agent 通过 memory_recall 工具按需召回历史上下文。零人工干预。",
   "icon": "assets/icon.png",
   "license": "MIT",