dsh-memu-memory 1.2.0 → 1.2.2

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,128 @@ 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 的读写面
+// （WORKER_WRITE_TOOLS + WORKER_READ_TOOLS）挂进 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')
+  // 只挂 worker 的读写面（记忆读写 + 关联裁决/候选 + 词典检索/写入）；
+  // archive/delete/unpin 这些破坏性工具不得进 worker 的工具面。
+  assert.deepEqual([...registered].sort(), ['memu_lexicon_propose', 'memu_lexicon_search', 'memu_private_link', 'memu_private_link_suggest', 'memu_private_list', 'memu_private_recall', 'memu_private_remember', 'memu_private_update'])
+  // 整理结束（finally）必须卸载挂载，不能给这条一次性 worker 留常驻注册。
+  assert.deepEqual([...disposals].sort(), ['memu_lexicon_propose', 'memu_lexicon_search', 'memu_private_link', 'memu_private_link_suggest', '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_lexicon_propose', 'memu_lexicon_search', 'memu_private_link', 'memu_private_link_suggest', 'memu_private_list', 'memu_private_recall', 'memu_private_remember', 'memu_private_update'])
+  assert.deepEqual([...started.detail.workerToolsRequested].sort(), ['memu_lexicon_propose', 'memu_lexicon_search', 'memu_private_link', 'memu_private_link_suggest', '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_lexicon_propose', 'memu_lexicon_search', 'memu_private_link', 'memu_private_link_suggest', 'memu_private_list', 'memu_private_recall', 'memu_private_update'],
+    'exactly the tools that actually registered are mounted')
+  assert.deepEqual([...disposals].sort(), ['memu_lexicon_propose', 'memu_lexicon_search', 'memu_private_link', 'memu_private_link_suggest', '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_lexicon_propose', 'memu_lexicon_search', 'memu_private_link', 'memu_private_link_suggest', '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_lexicon_propose', 'memu_lexicon_search', 'memu_private_link', 'memu_private_link_suggest', '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_lexicon_propose', 'memu_lexicon_search', 'memu_private_link', 'memu_private_link_suggest', '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,17 +262,95 @@ 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('auxiliary link and lexicon tools alone do not prove the worker can write memory', () => {
+  // 判据只看 CORE_WRITE_TOOLS：link / link_suggest / lexicon_propose 是辅助面，
+  // 一份只列它们、没有 remember/update 的名单仍然是"不能写记忆"，不能据此 fork。
+  const events = [{
+    seq: 0,
+    type: 'request/header',
+    data: { header: { config: { provider: 'p', model: 'm' }, tools: [
+      { name: 'memu_private_link' },
+      { name: 'memu_private_link_suggest' },
+      { name: 'memu_lexicon_propose' },
+      { name: 'memu_lexicon_search' },
+    ] } },
+  }]
+  const probe = probeToolSurface({ ctx: null, sessionId: 's', events })
+  assert.equal(probe.ok, false)
+  assert.equal(probe.reasonCode, 'worker-tools-missing')
+  assert.equal(probe.hasWrite, false)
+})
+
+test('the brief teaches the suggest-then-adjudicate loop and lexicon extraction', () => {
+  const brief = buildWorkerBrief({
+    snapshot: { fromSeq: 0, throughSeq: 5, eventCount: 6, hash: 'brief01' },
+    probe: { tools: ['memu_private_remember', 'memu_private_update', 'memu_private_link_suggest', 'memu_lexicon_propose'] },
+    contract: 'BRIEF-CONTRACT',
+  })
+  assert.match(brief, /memu_private_link_suggest\(\{ids:\[\.\.\.\]\}\)/, 'the call shape is spelled out')
+  assert.match(brief, /已经自动连好/, 'high-confidence links are applied before the worker sees candidates')
+  assert.match(brief, /每轮最多确认 5 条/)
+  assert.match(brief, /noop/)
+  assert.match(brief, /conflict/)
+  assert.match(brief, /memu_lexicon_search/)
+  assert.match(brief, /memu_lexicon_propose/)
+  assert.match(brief, /term 是索引键/)
+  assert.match(brief, /sensitive trigger/)
+  assert.match(brief, /tools-unavailable/, 'the tools-unavailable contract survives')
+  assert.match(brief, /没有回执视为本次整理失败/, 'the receipt requirement survives')
+  assert.match(brief, /BRIEF-CONTRACT/)
+})
+
+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', () => {
   const probe = probeToolSurface({ ctx: null, sessionId: 's', events: [{ seq: 0, type: 'request/header', data: { header: { config: {} } } }] })
   assert.equal(probe.ok, true)