dsh-memu-memory 1.2.0 → 1.2.1

package/tests/consolidation-feed.test.mjs

@@ -0,0 +1,96 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-consolidation-feed-'))
+process.env.DSH_MEMU_HOME = home
+process.env.DSH_MEMU_MEMORY_HOME = home
+
+const state = await import('../lib/state.js')
+const { record, resetActivityLogCache, listEvents, clearEvents } = await import('../lib/activity-log.js')
+const { dispatch } = await import('../lib/rpc.js')
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+// 侧边栏"整理提醒"与日志页的数据链路：跨会话取整理事件，服务端把会话标题与文件夹名
+// 拼进每一行（客户端只回退到裸 id）。标题走宿主 readTitleSnapshots（批量一次）。
+const ctx = {
+  get: (name) => {
+    if (name === 'sessionQuery') {
+      return {
+        readTitleSnapshots: async (ids) => ids.map((id) => ({
+          sessionId: id,
+          status: id === 'session-titled' ? 'fulfilled' : 'rejected',
+          ...(id === 'session-titled' ? { value: { title: { title: ' princess 的深夜备份会话 ' } } } : {}),
+        })),
+      }
+    }
+    return undefined
+  },
+}
+
+test('getConsolidationFeed splits failures and successes, decorates titles, caps each column', async () => {
+  const library = state.createLibrary({ cwd: path.join(home, 'feed-proj'), name: '夜备份工作区' })
+  resetActivityLogCache()
+  // 8 条失败 + 8 条成功，交错落盘；另有别的 kind 的失败（不得混进来）。
+  for (let index = 0; index < 8; index += 1) {
+    record({ kind: 'consolidate', scope: 'private', ok: false, level: 'error', sessionId: index === 7 ? 'session-titled' : 'session-plain-' + index, libraryId: library.id, message: '整理失败 · 空闲 · case-' + index, detail: { reasonCode: 'fork-turn-failed' } })
+    record({ kind: 'consolidate', scope: 'private', ok: true, sessionId: 'session-titled', libraryId: library.id, message: '整理完成 · 空闲', detail: { count: index } })
+  }
+  record({ kind: 'recall', scope: 'private', ok: false, sessionId: 'session-titled', message: '召回失败不进整理提醒' })
+
+  const feed = await dispatch(ctx, 'getConsolidationFeed', { limit: 6 })
+  assert.equal(feed.failures.length, 6, 'failures capped at the requested column size')
+  assert.equal(feed.successes.length, 6, 'successes capped at the requested column size')
+  assert.ok(feed.failures.every(row => row.ok === false), 'the failure column holds only failures')
+  assert.ok(feed.successes.every(row => row.ok !== false), 'the success column holds only successes')
+  // 最新在前：失败列第一条是最后落盘的那条失败。
+  assert.match(feed.failures[0].message, /case-7/)
+  // 会话标题 + 文件夹名由服务端拼好；查不到标题的行回退 null（客户端用短 id）。
+  assert.equal(feed.failures[0].sessionTitle, 'princess 的深夜备份会话')
+  assert.equal(feed.failures[0].libraryName, '夜备份工作区')
+  const plain = feed.failures.find(row => row.sessionId === 'session-plain-6')
+  assert.equal(plain.sessionTitle, null)
+  // 行已瘦身：回执 detail 不整包透传，只留提醒需要的字段。
+  assert.equal(feed.failures[0].reasonCode, 'fork-turn-failed')
+  assert.equal(feed.failures[0].detail, undefined)
+})
+
+test('getActivityLog decorates consolidation rows with session title and library name', async () => {
+  const library = state.createLibrary({ cwd: path.join(home, 'feed-proj-2'), name: '第二个工作区' })
+  resetActivityLogCache()
+  record({ kind: 'consolidate', scope: 'private', ok: false, level: 'error', sessionId: 'session-titled', libraryId: library.id, message: '整理失败 · 空闲 · worker-tools-ptc-only', detail: { reasonCode: 'worker-tools-ptc-only', toolSurface: ['run_code'] } })
+
+  const data = await dispatch(ctx, 'getActivityLog', { kind: 'consolidate', limit: 10 })
+  const row = data.events.find(item => item.message.includes('worker-tools-ptc-only'))
+  assert.ok(row, 'the consolidation row is returned')
+  assert.equal(row.sessionTitle, 'princess 的深夜备份会话')
+  assert.equal(row.libraryName, '第二个工作区')
+})
+
+test('clearConsolidationFailures deletes only failed consolidate rows, everything else stays', async () => {
+  const library = state.createLibrary({ cwd: path.join(home, 'feed-clear'), name: '清除测试区' })
+  resetActivityLogCache()
+  // 同一个临时 home 累积了前面用例的日志：先全清，种进去的才是本用例的全部世界。
+  clearEvents()
+  record({ kind: 'consolidate', scope: 'private', ok: false, level: 'error', sessionId: 'session-titled', libraryId: library.id, message: '整理失败 · 其一', detail: { reasonCode: 'timeout' } })
+  record({ kind: 'consolidate', scope: 'private', ok: false, level: 'error', sessionId: 'session-titled', libraryId: library.id, message: '整理失败 · 其二', detail: { reasonCode: 'timeout' } })
+  record({ kind: 'consolidate', scope: 'private', ok: true, sessionId: 'session-titled', libraryId: library.id, message: '整理完成' })
+  record({ kind: 'recall', scope: 'private', ok: false, sessionId: 'session-titled', message: '召回失败不是整理失败' })
+
+  const result = await dispatch(ctx, 'clearConsolidationFailures', { limit: 6 })
+  assert.equal(result.cleared, 2, 'exactly the two failed consolidate rows are removed')
+  assert.equal((result.feed.failures || []).length, 0, 'the failure column comes back empty')
+  assert.equal((result.feed.successes || []).length, 1, 'the success flow survives')
+  // 其它 kind 的失败行与成功行都不受影响。
+  const kinds = listEvents({ limit: 50 })
+  assert.ok(kinds.some(r => r.kind === 'recall' && r.ok === false), 'non-consolidate failures stay')
+  assert.ok(kinds.some(r => r.kind === 'consolidate' && r.ok !== false), 'consolidate successes stay')
+  // 落盘一致：重读缓存后计数不变（rewrite 是权威，不是只在内存里删）。
+  resetActivityLogCache()
+  assert.equal(listEvents({ kind: 'consolidate', level: 'error', limit: 50 }).length, 0, 'the rewrite reached disk')
+})

package/tests/consolidation-fork.test.mjs

@@ -8,6 +8,7 @@ const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-memory-fork-'))
 process.env.DSH_MEMU_HOME = home
 
 const state = await import('../lib/state.js')
+const activity = await import('../lib/activity-log.js')
 const { requestPrivateConsolidation, isConsolidating } = await import('../lib/private.js')
 
 test.after(() => {
@@ -52,8 +53,9 @@ function assertHostCreateAccepts(spec = {}) {
   }
 }
 
-function host({ live = false, whenIdle = null, parentOptions = { provider: 'test-provider', model: 'test-model' }, requestConfig = null, extraEvents = [], transcriptSize = 0, turnReason = { kind: 'completed' }, emitTurnEnd = true } = {}) {
-  const rec = { liveFollowups: [], created: [], forkFollowups: [], disposed: [], sessionHandlers: [] }
+function host({ live = false, whenIdle = null, parentOptions = { provider: 'test-provider', model: 'test-model' }, requestConfig = null, extraEvents = [], transcriptSize = 0, turnReason = { kind: 'completed' }, emitTurnEnd = true, headerTools = null, childCtxFactory = null } = {}) {
+  const rec = { liveFollowups: [], created: [], forkFollowups: [], disposed: [], sessionHandlers: [], workerToolRegistrations: [], workerToolDisposals: [] }
+  const childContexts = new Map()
   const tick = String.fromCharCode(96)
   const receiptFence = (range, identity) => [tick + tick + tick + 'memu-consolidation-receipt', JSON.stringify({ version: 1, ...identity, status: 'completed', outcome: 'no_value', checkedRange: range, createdIds: [], updatedIds: [], heldIds: [], reasonCode: null, retryable: false }), tick + tick + tick].join('\n')
   // 真实长会话的规模：补齐不产生证据的事件，只影响 fork 成本判定。
@@ -72,16 +74,24 @@ function host({ live = false, whenIdle = null, parentOptions = { provider: 'test
     get: (name) => {
       if (name === 'agents') {
         return {
-          get: (id) => (live
-            ? {
-                followup: (message) => rec.liveFollowups.push({ id, message }),
-                ...(parentOptions ? { options: parentOptions } : {}),
-                ...(requestConfig ? { session: { requestHeader: () => ({ config: requestConfig }) } } : {}),
-              }
-            : undefined),
+          get: (id) => {
+            // attachWorkerTools 用 childContexts 模拟"宿主在 create 后暴露的 agent ctx"。
+            if (childContexts.has(id)) return { ctx: childContexts.get(id) }
+            return (live
+              ? {
+                  followup: (message) => rec.liveFollowups.push({ id, message }),
+                  ...(parentOptions ? { options: parentOptions } : {}),
+                  ...(requestConfig || headerTools ? { session: { requestHeader: () => ({
+                    ...(requestConfig ? { config: requestConfig } : {}),
+                    ...(headerTools ? { tools: headerTools.map((toolName) => ({ name: toolName })) } : {}),
+                  }) } } : {}),
+                }
+              : undefined)
+          },
           create: async (spec) => {
             assertHostCreateAccepts(spec)
             rec.created.push(spec)
+            if (childCtxFactory) childContexts.set(spec.sessionId, childCtxFactory())
             const childSession = { id: spec.sessionId }
             return {
               agent: {
@@ -354,4 +364,126 @@ test('a large transcript that was never consolidated does fork, because the back
   const result = await requestPrivateConsolidation(ctx, 'fork-large-owed')
   assert.equal(result.ok, true, 'the backlog bound lets this one through')
   assert.equal(ctx.rec.created.length, 1, 'a large unconsolidated backlog is worth exactly one fork')
-})
+})
+// ---------------------------------------------------------------- PTC 兼容
+// 现场（2026-10-31，yuike-ptc 会话）：PTC 模式下 request/header 的工具表只有 run_code，
+// probe 曾据此判 unavailable（worker-tools-ptc-only），PTC 会话永远不被整理。宿主的
+// PTC executor 明确 "only run_code is directly callable"，其余工具走 run_code 程序里的
+// SDK 绑定（tools.schemas(agent, toolSet) 枚举可见面）—— header 名单在 PTC 会话里
+// 不承载"能不能写记忆"。修复后：PTC 不构成否证 + fork 时把读写四件挂进 worker 自己的
+// scope（注册表按 scope 链取可见面，不扩散到其它会话）。
+
+test('a PTC session (run_code only header) is consolidated and the worker gets write tools on its own scope', async () => {
+  const registered = []
+  const disposals = []
+  state.ensureSession('fork-ptc', { cwd: path.join(home, 'proj-ptc'), agentPreset: 'yuike-ptc' })
+  const ctx = host({
+    live: true,
+    headerTools: ['run_code'],
+    extraEvents: [
+      { seq: 3, type: 'tool/ptc-dispatch-start', data: { rootCallId: 'r1', parentCallId: 'r1', subCallId: 'r1:ptc:1', name: 'read', arguments: {} } },
+      { seq: 4, type: 'tool/ptc-dispatch', data: { rootCallId: 'r1', parentCallId: 'r1', subCallId: 'r1:ptc:1', name: 'read', arguments: {}, isError: false, content: [] } },
+    ],
+    childCtxFactory: () => ({
+      tools: {
+        register: (tool) => {
+          registered.push(tool?.name)
+          return () => { disposals.push(tool?.name) }
+        },
+      },
+    }),
+  })
+  const result = await requestPrivateConsolidation(ctx, 'fork-ptc')
+  assert.equal(result.ok, true, 'a run_code header must not block consolidation: ' + String(result.error || ''))
+  assert.equal(result.settled, true)
+  assert.equal(ctx.rec.created.length, 1, 'the fork is created for the PTC conversation')
+  // 只挂读写四件；archive/delete/unpin 这些破坏性工具不得进 worker 的工具面。
+  assert.deepEqual([...registered].sort(), ['memu_private_list', 'memu_private_recall', 'memu_private_remember', 'memu_private_update'])
+  // 整理结束（finally）必须卸载挂载，不能给这条一次性 worker 留常驻注册。
+  assert.deepEqual([...disposals].sort(), ['memu_private_list', 'memu_private_recall', 'memu_private_remember', 'memu_private_update'])
+  // 全量挂载的活动元数据：attached=实际子集（此处=完整 wanted）、requested=完整 wanted、
+  // partial=false。三件一起钉住"成功路径不再含糊"。
+  const started = startedEntryFor(ctx, 'fork-ptc')
+  assert.deepEqual([...started.detail.workerToolsAttached].sort(), ['memu_private_list', 'memu_private_recall', 'memu_private_remember', 'memu_private_update'])
+  assert.deepEqual([...started.detail.workerToolsRequested].sort(), ['memu_private_list', 'memu_private_recall', 'memu_private_remember', 'memu_private_update'])
+  assert.equal(started.detail.workerToolsPartial, false, 'a full mount is not partial')
+  const followup = ctx.rec.forkFollowups[0]?.message
+  const brief = Array.isArray(followup?.content)
+    ? followup.content.map((block) => block?.text || '').join('\n')
+    : String(followup || '')
+  assert.match(brief, /run_code/, 'the brief names the PTC transport')
+  assert.match(brief, /tools\.memu_private_remember/, 'the brief shows the SDK invocation shape')
+})
+
+// "整理已开始"那条活动日志：按 sessionId + phase=started 取，childId 对上这次的 fork。
+function startedEntryFor(ctx, sessionId) {
+  const childId = ctx.rec.created[0]?.sessionId
+  const entry = activity.listEvents({ kind: 'consolidate', sessionId })
+    .find((row) => row.detail?.phase === 'started' && row.detail?.childId === childId)
+  assert.ok(entry, 'the consolidation-started activity entry exists')
+  return entry
+}
+
+test('a host registry refusing one write tool leaves a structured partial mount in the activity log', async () => {
+  // 宿主注册表对单件工具说"不"（重名、scope 锁定）是真实的部分挂载路径：registerTools
+  // 逐件 fail-open，其余三件照常挂上。活动日志必须记实际子集 + requested + partial，
+  // 而不是把 wanted 全量误报成已挂载（旧口径的缺陷）。
+  const registered = []
+  const disposals = []
+  state.ensureSession('fork-ptc-partial', { cwd: path.join(home, 'proj-ptc-partial'), agentPreset: 'yuike-ptc' })
+  const ctx = host({
+    live: true,
+    headerTools: ['run_code'],
+    childCtxFactory: () => ({
+      tools: {
+        register: (tool) => {
+          if (tool?.name === 'memu_private_remember') throw new Error('registry refused: name already bound')
+          registered.push(tool?.name)
+          return () => { disposals.push(tool?.name) }
+        },
+      },
+    }),
+  })
+  const result = await requestPrivateConsolidation(ctx, 'fork-ptc-partial')
+  assert.equal(result.ok, true, String(result.error || ''))
+  assert.equal(result.settled, true)
+  assert.deepEqual([...registered].sort(), ['memu_private_list', 'memu_private_recall', 'memu_private_update'],
+    'exactly the tools that actually registered are mounted')
+  assert.deepEqual([...disposals].sort(), ['memu_private_list', 'memu_private_recall', 'memu_private_update'],
+    'dispose unmounts exactly what was mounted')
+  const started = startedEntryFor(ctx, 'fork-ptc-partial')
+  assert.deepEqual([...started.detail.workerToolsAttached].sort(), ['memu_private_list', 'memu_private_recall', 'memu_private_update'],
+    'the log records the actual subset, not the full wanted list')
+  assert.deepEqual([...started.detail.workerToolsRequested].sort(), ['memu_private_list', 'memu_private_recall', 'memu_private_remember', 'memu_private_update'])
+  assert.equal(started.detail.workerToolsPartial, true)
+  // 挂载为部分子集时任务书仍带 PTC 调用形态：worker 知道写记忆走 run_code 的 SDK 绑定。
+  const followup = ctx.rec.forkFollowups[0]?.message
+  const brief = Array.isArray(followup?.content)
+    ? followup.content.map((block) => block?.text || '').join('\n')
+    : String(followup || '')
+  assert.match(brief, /await tools\.memu_private_remember/, 'the brief keeps the PTC invocation shape on a partial mount')
+})
+
+test('a fork context without a tools service records a null mount, the request and the partial flag', async () => {
+  // 宿主不暴露 agent ctx（或 ctx 上没有 tools 服务）→ attachWorkerTools 的现有 warn 路径。
+  // 语义：workerToolsAttached=null = 挂载没有完成（与"挂全了"严格区分）；requested 仍记
+  // 完整 wanted；workerToolsPartial=true —— "未证明拿到完整 wanted 集"，一件都没有
+  // 是它最极端的形态。若这里标 false，false 会被一眼读成"全量挂载"，元数据又不准了。
+  state.ensureSession('fork-ptc-notools', { cwd: path.join(home, 'proj-ptc-notools'), agentPreset: 'yuike-ptc' })
+  const ctx = host({ live: true, headerTools: ['run_code'] })
+  const result = await requestPrivateConsolidation(ctx, 'fork-ptc-notools')
+  assert.equal(result.ok, true, String(result.error || ''))
+  const started = startedEntryFor(ctx, 'fork-ptc-notools')
+  assert.equal(started.detail.workerToolsAttached, null, 'no mount completed, so the log must not claim one')
+  assert.deepEqual([...started.detail.workerToolsRequested].sort(), ['memu_private_list', 'memu_private_recall', 'memu_private_remember', 'memu_private_update'])
+  assert.equal(started.detail.workerToolsPartial, true)
+})
+
+test('a non-PTC header without write tools still refuses to fork', async () => {
+  state.ensureSession('fork-notools', { cwd: path.join(home, 'proj-notools'), agentPreset: 'coding' })
+  const ctx = host({ live: true, headerTools: ['read', 'shell', 'edit'] })
+  const result = await requestPrivateConsolidation(ctx, 'fork-notools')
+  assert.equal(result.ok, false)
+  assert.equal(result.reasonCode, 'worker-tools-missing')
+  assert.equal(ctx.rec.created.length, 0, 'no fork when the model surface provably lacks the write tools')
+})

package/tests/consolidation-snapshot.test.mjs

@@ -262,15 +262,54 @@ test('a header without memory tools is unavailable rather than a silent wasted f
   assert.equal(probe.reasonCode, 'worker-tools-missing')
 })
 
-test('a PTC-only turn is reported as PTC, not as a generic missing tool', () => {
+test('a PTC-only turn is not a refusal: the probe reports ptc and the SDK surface is checked at fork time', () => {
+  // 2026-10-31 口径变更：PTC 模式下 header 只列 transport（这里 ptc_exec，真实宿主为
+  // run_code），其余工具走 run_code 程序里的 SDK 绑定 —— header 名单不承载"能不能写"，
+  // 不再产生 worker-tools-ptc-only 拒绝；fork 后由 attachWorkerTools 挂载读写工具。
   const events = [
     { seq: 0, type: 'request/header', data: { header: { config: { provider: 'p', model: 'm' }, tools: [{ name: 'ptc_exec' }] } } },
-    { seq: 1, type: 'tool/ptc-dispatch', data: {} },
+    { seq: 1, type: 'tool/ptc-dispatch', data: { name: 'ptc_exec' } },
   ]
   const probe = probeToolSurface({ ctx: null, sessionId: 's', events })
-  assert.equal(probe.ok, false)
-  assert.equal(probe.reasonCode, 'worker-tools-ptc-only')
+  assert.equal(probe.ok, true, 'a PTC surface can never disprove write ability')
+  assert.equal(probe.source, 'ptc-header')
   assert.equal(probe.ptcObserved, true)
+  assert.equal(probe.hasWrite, null)
+})
+
+test('a run_code header alone (no dispatch events yet) is still recognized as PTC', () => {
+  // 新 PTC 会话一次 run_code 都没跑过时也要认得出来：run_code 出现在名单里就是证据。
+  const events = [{ seq: 0, type: 'request/header', data: { header: { config: { provider: 'p', model: 'm' }, tools: [{ name: 'run_code' }] } } }]
+  const probe = probeToolSurface({ ctx: null, sessionId: 's', events })
+  assert.equal(probe.ok, true)
+  assert.equal(probe.source, 'ptc-header')
+  assert.equal(probe.ptcObserved, true)
+})
+
+test('a mixed surface (run_code beside native memu_*) proves write ability and keeps the PTC shape', () => {
+  // 混合面：PTC transport 与原生 memu_* 同时出现在 header 名单（preset 部分列出本插件、
+  // 或 PTC 与原生工具共存的会话）。probe 既不能当纯 PTC（hasWrite:null 会丢掉"名单里
+  // 明摆着有写工具"的证据），也不能当普通名单（ptcObserved:false 会丢掉 PTC transport）。
+  // hasWrite:true + ptcObserved:true 是钉住的口径；任务书（buildWorkerBrief）在混合面下
+  // 既要列原生名单、又要带 run_code 的 SDK 调用形态——两种 transport 都覆盖。
+  const events = [{
+    seq: 0,
+    type: 'request/header',
+    data: { header: { config: { provider: 'p', model: 'm' }, tools: [{ name: 'run_code' }, ...MEMU_TOOLS] } },
+  }]
+  const probe = probeToolSurface({ ctx: null, sessionId: 's', events })
+  assert.equal(probe.ok, true)
+  assert.equal(probe.hasWrite, true, 'a native write tool in the list still proves write ability')
+  assert.equal(probe.ptcObserved, true, 'run_code in the list is PTC evidence even beside native tools')
+  assert.equal(probe.source, 'header-event')
+  const brief = buildWorkerBrief({
+    snapshot: { fromSeq: 0, throughSeq: 5, eventCount: 6, hash: 'mix001' },
+    probe,
+    contract: 'MIXED-CONTRACT',
+  })
+  assert.match(brief, /run_code, memu_private_remember, memu_private_update/, 'the brief lists the native names')
+  assert.match(brief, /await tools\.memu_private_remember/, 'the brief keeps the PTC SDK invocation shape on a mixed surface')
+  assert.match(brief, /MIXED-CONTRACT/)
 })
 
 test('a missing tool list is unknown, not a refusal', () => {

package/tests/curator-commit.test.mjs

@@ -0,0 +1,277 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { registerHooks } from 'node:module'
+
+// commitCuratorOutput regressions :
+//   1. A held clone created by a target-changed conflict must NOT inherit the
+//      vector stamp of the batch commit (the batch committed `id`, not heldId),
+//      and membership must not count either the clone or the unindexed `id` row.
+//   2. A global-index write failure after the batch commit must be compensated:
+//      every committed name receives a forget, and partial/complete outcomes are
+//      recorded to the activity log (compensation design, not a transaction).
+//
+// No engine, no download: './memu.js' is replaced before production modules
+// load (same pattern as tests/managed-memory.test.mjs), and './state.js' is
+// wrapped with a one-shot updateGlobalIndex failure switch. Everything else is
+// the real module stack against a temp DSH_MEMU_HOME.
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-curator-commit-'))
+process.env.DSH_MEMU_HOME = home
+process.env.DSH_MEMU_MEMORY_HOME = home
+
+const backend = {
+  commits: [],
+  forgets: [],
+  onCommit: null,
+}
+globalThis.__curatorCommitTest = {
+  async commit(args) {
+    const names = (args.payload?.recall_files || []).map((file) => file.name)
+    backend.commits.push({ names, route: args.route, db: args.db })
+    if (backend.onCommit) await backend.onCommit()
+    return { ok: true }
+  },
+  async forget(args) {
+    backend.forgets.push({ name: args.name, db: args.db })
+    return { deleted: 1, segments: 1 }
+  },
+  async retrieve() { return { files: [], segments: [], resources: [], raw: null } },
+  async listFiles() { return { recall_files: [], resources: [], raw: null } },
+}
+
+// One-shot failure switch on updateGlobalIndex; every other state.js export is
+// forwarded to the real module (local exports shadow the star re-export).
+const indexHook = { failNext: 0, thrown: [] }
+globalThis.__curatorIndexHook = indexHook
+
+const realStateUrl = new URL('../lib/state.js', import.meta.url).href
+const realMemuUrl = new URL('../lib/memu.js', import.meta.url).href
+const memuSource = 'const bridge = globalThis.__curatorCommitTest;'
+  + 'export const commit = (args) => bridge.commit(args), forget = (args) => bridge.forget(args),'
+  + 'retrieve = (args) => bridge.retrieve(args), listFiles = (args) => bridge.listFiles(args);'
+const stateSource = [
+  `import * as real from ${JSON.stringify(realStateUrl)}`,
+  'const hook = globalThis.__curatorIndexHook',
+  'export function updateGlobalIndex(mutator) {',
+  '  if (hook.failNext > 0) { hook.failNext -= 1; const error = new Error("disk full (simulated index failure)"); hook.thrown.push(String(error.message)); throw error }',
+  '  return real.updateGlobalIndex(mutator)',
+  '}',
+  `export * from ${JSON.stringify(realStateUrl)}`,
+].join('\n')
+const hooks = registerHooks({
+  resolve(specifier, context, nextResolve) {
+    if (specifier === './memu.js') return { url: 'data:text/javascript,' + encodeURIComponent(memuSource), shortCircuit: true }
+    if (specifier === './state.js') return { url: 'data:text/javascript,' + encodeURIComponent(stateSource), shortCircuit: true }
+    return nextResolve(specifier, context)
+  },
+})
+
+const catalog = await import('../lib/embedding-catalog.js')
+const vp = await import('../lib/vector-profile.js')
+const vm = await import('../lib/vector-migration.js')
+const curator = await import('../lib/curator.js')
+const state = await import('../lib/state.js')
+const activity = await import('../lib/activity-log.js')
+
+const BGE = 'bge-small-zh-v1.5-int8'
+// A second resolvable catalog entry so switchProfile has a verified profile to
+// activate (same fixture trick as tests/vector-migration.test.mjs).
+const baseEntry = catalog.getEmbeddingModel(BGE)
+const altEntry = JSON.parse(JSON.stringify(baseEntry))
+altEntry.id = 'bge-small-zh-v1.5-int8-alt'
+altEntry.displayName = 'BGE alternative revision (curator commit fixture)'
+altEntry.sources.modelscope.revision = 'c'.repeat(40)
+altEntry.profileFingerprint = catalog.profileFingerprint(altEntry)
+const models = { [BGE]: baseEntry, [altEntry.id]: altEntry }
+vp.setCatalogEntryResolver((id) => models[id] ?? null)
+
+state.updateSettings({ memoryBackend: 'api', vectorSource: 'local' })
+
+const TARGET = 'gmem-target'
+const TARGET_ENTRY = {
+  track: 'memory', domain: 'general', title: '部署窗口约定',
+  content: '每周四凌晨两点到四点是固定的部署窗口，窗口内只允许灰度发布。',
+  confidence: 0.9, status: 'active',
+  createdAt: '2026-01-01T00:00:00.000Z', updatedAt: '2026-01-01T00:00:00.000Z',
+  evidence: [{ sessionId: 'old', quote: 'old quote' }],
+}
+
+function seedGlobalIndex(entries = {}) {
+  state.saveGlobalIndex({ version: 1, entries: structuredClone(entries) })
+}
+
+async function activateVectorGeneration() {
+  // In-memory stand-in for the sqlite vector store so the migration readback
+  // (syncShadow verifies committed items via listFiles) is faithful.
+  const dbs = new Map()
+  const rowsOf = (db) => {
+    if (!dbs.has(db)) dbs.set(db, new Map())
+    return dbs.get(db)
+  }
+  const migrator = vm.createVectorMigrator({
+    async listLibraries() { return [] },
+    // membership() 的戳腿/账本腿读的是真实索引；这里直接转发到真 state.js。
+    loadIndex(libraryId) {
+      return libraryId ? state.loadPrivateIndex(libraryId) : state.loadGlobalIndex()
+    },
+    async commit({ db, item }) { rowsOf(db).set(item.id, item.text) },
+    async forget({ db, itemId }) { rowsOf(db).delete(itemId) },
+    async listFiles({ db }) { return [...rowsOf(db).keys()] },
+    async smoke() { return { ok: true, checks: ['dimension=512'] } },
+  })
+  const switched = await migrator.switchProfile({ profile: BGE })
+  assert.ok(['switched', 'already-active'].includes(switched.status), 'an active generation must be available')
+  return { migrator, generation: switched.generation }
+}
+
+test.after(async () => {
+  try { hooks.unregister?.() } catch {}
+  vp.resetCatalogEntryResolver()
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+const mergeOutput = {
+  memories: [{
+    op: 'merge', domain: 'general', track: 'memory', target_id: TARGET,
+    title: '部署窗口的合并版本',
+    content: '每周四凌晨两点到四点是固定的部署窗口，窗口内只允许灰度发布，全量要等监控确认。',
+    confidence: 0.9,
+    evidence: [{ session_id: 's1', quote: '部署窗口只在周四凌晨' }],
+  }],
+}
+
+test('a held clone from a target-changed conflict carries no vector stamp and membership counts neither it nor the committed id row', async () => {
+  seedGlobalIndex({ [TARGET]: TARGET_ENTRY })
+  const { migrator, generation } = await activateVectorGeneration()
+
+  // The concurrent writer lands while the curator is between its index read and
+  // its index write: the backend commit is the only async seam in between.
+  backend.onCommit = async () => {
+    state.updateGlobalIndex((fresh) => {
+      fresh.entries[TARGET] = { ...fresh.entries[TARGET], content: '内容已被并发修改', updatedAt: '2026-02-02T00:00:00.000Z' }
+    })
+  }
+  const result = await curator.commitCuratorOutput(structuredClone(mergeOutput), { job: { step: 'committing' } })
+  backend.onCommit = null
+
+  assert.equal(result.merged, 1, 'the merge update is still accounted as attempted')
+  assert.equal(result.files.length, 1)
+  const committedId = result.files[0].name
+  assert.deepEqual(backend.commits.map((call) => call.names), [[committedId]], 'the batch committed exactly the new id')
+
+  const index = state.loadGlobalIndex()
+  // The held clone got its own id; the committed id row is NOT in the index.
+  const heldId = Object.keys(index.entries).find((id) => index.entries[id]?.reviewReason === 'target changed while curator was running')
+  assert.ok(heldId, 'the target-changed merge must be held for review')
+  assert.notEqual(heldId, committedId)
+  assert.equal(index.entries[committedId], undefined, 'the committed id must not land in the index when held')
+  const held = index.entries[heldId]
+  assert.equal(held.status, 'pending_review')
+  assert.equal(held.conflictingWith, TARGET)
+  // The regression: the clone spread `...entry` after the stamp loop stamped it.
+  assert.equal(Object.hasOwn(held, 'vector'), false, 'a held clone never entered the vector store, so it must not carry the stamp')
+  assert.equal(index.entries[TARGET].status, 'active', 'the untouched target is not superseded by a held clone')
+
+  // membership: the ledger leg keeps TARGET; the stamp leg admits the new
+  // create/update stamps only. Neither heldId (no stamp, not in ledger) nor the
+  // committed `id` (row exists in the backend, but not in the index) may appear.
+  const membership = migrator.membership()
+  assert.ok(membership, 'an active generation must produce a membership map')
+  const globalIds = membership.global || []
+  assert.ok(globalIds.includes(TARGET), 'the migrated target stays counted')
+  assert.ok(!globalIds.includes(heldId), 'the held clone is not counted as vector membership')
+  assert.ok(!globalIds.includes(committedId), 'the backend row `id` must not be attributed to the index it never landed in')
+})
+
+test('a clean create still carries the current-generation stamp and is counted by membership', async () => {
+  seedGlobalIndex({})
+  const { migrator, generation } = await activateVectorGeneration()
+  const output = {
+    memories: [{
+      op: 'create', domain: 'general', track: 'memory',
+      title: '独立的全新事实',
+      content: '用户倾向于在正式汇报里先给结论再给细节。',
+      confidence: 0.9,
+      evidence: [{ session_id: 's2', quote: '先说结论' }],
+    }],
+  }
+  const result = await curator.commitCuratorOutput(output, { job: { step: 'committing' } })
+  assert.equal(result.created, 1)
+  const index = state.loadGlobalIndex()
+  const entry = Object.values(index.entries)[0]
+  assert.equal(entry.status, 'active')
+  assert.equal(entry.vector?.route, 'managed-local')
+  assert.equal(Number(entry.vector?.generation), generation, 'the stamp names the active generation')
+  const membership = migrator.membership()
+  assert.deepEqual(membership.global, [result.files[0].name])
+})
+
+test('a global-index write failure after the batch commit is compensated name by name and reported', async () => {
+  seedGlobalIndex({})
+  await activateVectorGeneration()
+  const output = {
+    memories: [
+      { op: 'create', domain: 'general', track: 'memory', title: '第一条', content: '第一条全新事实的内容，足够长以通过校验。', confidence: 0.9, evidence: [{ session_id: 's3', quote: '一' }] },
+      { op: 'create', domain: 'general', track: 'memory', title: '第二条', content: '第二条全新事实的内容，与第一条没有关系。', confidence: 0.9, evidence: [{ session_id: 's4', quote: '二' }] },
+    ],
+  }
+  indexHook.failNext = 1
+  await assert.rejects(
+    curator.commitCuratorOutput(structuredClone(output), { job: { step: 'committing' } }),
+    /disk full/,
+    'the original index error must surface, not the compensation result',
+  )
+  const committedNames = backend.commits.at(-1).names
+  assert.equal(committedNames.length, 2)
+  // Compensation: every committed name received a forget against the global db.
+  assert.deepEqual(
+    backend.forgets.map((call) => call.name).sort(),
+    [...committedNames].sort(),
+    'each just-committed name must be forgotten',
+  )
+  assert.ok(backend.forgets.every((call) => call.db === state.globalDbPath()))
+  // The index write failed, so nothing landed: the library must not gain entries
+  // and the curation failure stays the job's error.
+  assert.deepEqual(Object.keys(state.loadGlobalIndex().entries), [])
+  // The compensation outcome is visible in the activity log, not swallowed.
+  const event = activity.listEvents({ kind: 'curate' }).find((item) => item.level === 'error' || item.level === 'warn')
+  assert.ok(event, 'the compensation must be recorded')
+  assert.equal(event.ok, true, 'both names were compensated, so the record says so')
+  assert.deepEqual(event.detail.compensated.sort(), [...committedNames].sort())
+  assert.deepEqual(event.detail.failed, [])
+  assert.match(event.message, /回滚|补偿/)
+})
+
+test('a compensation failure is reported per name and never hides the original error', async () => {
+  seedGlobalIndex({})
+  await activateVectorGeneration()
+  // Make forget fail for the second name only: partial compensation must be
+  // recorded name by name.
+  const originalForget = globalThis.__curatorCommitTest.forget
+  const forgetBaseline = backend.forgets.length
+  globalThis.__curatorCommitTest.forget = async (args) => {
+    if (backend.forgets.length > forgetBaseline) throw new Error('engine db is locked')
+    return originalForget(args)
+  }
+  const output = {
+    memories: [
+      { op: 'create', domain: 'general', track: 'memory', title: '甲', content: '甲事实的内容，与乙无关。', confidence: 0.9, evidence: [{ session_id: 's5', quote: '甲' }] },
+      { op: 'create', domain: 'general', track: 'memory', title: '乙', content: '乙事实的内容，与甲无关。', confidence: 0.9, evidence: [{ session_id: 's6', quote: '乙' }] },
+    ],
+  }
+  indexHook.failNext = 1
+  await assert.rejects(
+    curator.commitCuratorOutput(structuredClone(output), { job: { step: 'committing' } }),
+    /disk full/,
+  )
+  globalThis.__curatorCommitTest.forget = originalForget
+  const event = activity.listEvents({ kind: 'curate' }).filter((item) => item.level === 'error').at(-1)
+  assert.ok(event, 'a partial compensation must be recorded at error level')
+  assert.equal(event.ok, false)
+  assert.equal(event.detail.compensated.length, 1, 'the name whose forget succeeded is recorded as compensated')
+  assert.equal(event.detail.failed.length, 1, 'the name whose forget failed is recorded with its reason')
+  assert.match(event.detail.failed[0].error, /engine db is locked/)
+  assert.match(event.message, /残留孤儿行/)
+})