dsh-config-manager 0.1.76 → 0.1.77

package/src/client/chat/chat-entry-view.test.ts

@@ -58,7 +58,12 @@ import {
   retryChatPointUntilHit,
   type ChatPointWindowState,
 } from './chat-point-window.ts'
-import { chatNodeOccupantOf, declaredSlotKind, registerChatNodeEntry } from './chat-node-registration.ts'
+import {
+  chatNodeOccupantOf,
+  declaredSlotKind,
+  registerChatNodeEntry,
+  registerChatNodeEntryWhenEnabled,
+} from './chat-node-registration.ts'
 import { en as chatEn, zh as chatZh } from './chat-locales.ts'
 import type { RollbackListResult, RollbackPointPort, RollbackPointSummary } from '../../ui/rollback-view.ts'
 
@@ -236,6 +241,95 @@ test('steering is a DIFFERENT key: we never register it (host renderer unchanged
   assert.equal(chatNodeKind(nodeOf({ kind: 'user' })), 'user')
 })
 
+
+test('gate: 关闭时一次都不注册；打开即登记；关掉立刻撤销；再打开再登记', () => {
+  let enabled = false
+  const listeners = new Set<() => void>()
+  const disposed: number[] = []
+  let registrations = 0
+  let live = 0
+  const teardown = registerChatNodeEntryWhenEnabled({
+    probe: { spec: () => ({ kind: 'keyed', scope: 'session' }) },
+    register: () => {
+      registrations += 1
+      live += 1
+      const id = registrations
+      return () => { disposed.push(id); live -= 1 }
+    },
+    isEnabled: () => enabled,
+    subscribe: (listener) => { listeners.add(listener); return () => { listeners.delete(listener) } },
+    warn: () => {},
+  })
+  const flip = (value: boolean): void => {
+    enabled = value
+    for (const listener of [...listeners]) listener()
+  }
+
+  assert.equal(registrations, 0, '缺省关闭：绝不接管 user cell（气泡留给宿主原生渲染）')
+  assert.equal(listeners.size, 1, '无论开关如何都要订阅，否则功能打开时补不上登记')
+
+  flip(true)
+  assert.equal(registrations, 1)
+  assert.equal(live, 1)
+  flip(true)
+  assert.equal(registrations, 1, '重复通知必须幂等（同一时间只能有一条登记）')
+
+  flip(false)
+  assert.equal(live, 0, '关闭 = 撤销登记 ⇒ cell 回到宿主 priority 0')
+  assert.deepEqual(disposed, [1])
+
+  flip(true)
+  assert.equal(registrations, 2, '重新打开必须当场补登记（不重载插件）')
+  assert.equal(live, 1)
+
+  teardown()
+  assert.equal(live, 0, '装配卸载必须撤销登记，不留悬挂注册')
+  assert.equal(listeners.size, 0, '装配卸载必须解绑订阅')
+  assert.deepEqual(disposed, [1, 2])
+})
+
+test('gate: 一直关闭时卸载是安全的（没有登记可撤）', () => {
+  let unsubscribed = 0
+  const teardown = registerChatNodeEntryWhenEnabled({
+    probe: { spec: () => ({ kind: 'keyed', scope: 'session' }) },
+    register: () => { throw new Error('must not register while disabled') },
+    isEnabled: () => false,
+    subscribe: () => () => { unsubscribed += 1 },
+    warn: () => {},
+  })
+  teardown()
+  assert.equal(unsubscribed, 1)
+})
+
+test('gate: 让位时登记返回的 no-op 也照样能撤销，且不重复探测', () => {
+  const warns: string[] = []
+  let enabled = true
+  let registrations = 0
+  const teardown = registerChatNodeEntryWhenEnabled({
+    probe: {
+      spec: () => ({ kind: 'keyed', scope: 'session' }),
+      entriesOfSlot: () => [{ options: { key: 'user', priority: -2 }, registrant: '@someone/other-rewind' }],
+    },
+    register: () => { registrations += 1; return () => {} },
+    isEnabled: () => enabled,
+    subscribe: () => () => {},
+    warn: (message) => { warns.push(message) },
+  })
+  assert.equal(registrations, 0, '别的插件以更低优先级占着 user cell：让位')
+  assert.ok(warns.some((line) => line.startsWith(CHAT_NODE_YIELD_WARN_PREFIX)))
+  enabled = false
+  teardown()
+  assert.equal(registrations, 0)
+})
+
+test('装配点：user cell 的登记走开关闸门（不是无条件遮蔽宿主渲染器）', () => {
+  const src = readFileSync(join(HERE, '..', 'index.ts'), 'utf8')
+  assert.match(src, /ctx\.slots\.inject\(CHAT_NODE_SLOT, \(\) => registerChatNodeEntryWhenEnabled\(\{/)
+  assert.match(src, /isEnabled: isRollbackEntryEnabled/)
+  assert.match(src, /subscribe: subscribeRollbackEntryEnabled/)
+  assert.doesNotMatch(src, /ctx\.slots\.inject\(CHAT_NODE_SLOT, \(\) => registerChatNodeEntry\(/)
+})
+
 const HERE = fileURLToPath(new URL('.', import.meta.url))
 
 /** 读一个组件源码（*.tsx 不能在 node 下 type-strip 加载，故走源码级断言）。 */
@@ -317,6 +411,118 @@ test('文件卡描边与宿主同档：.5px + --cm-line-2（不是更淡的 --cm
   assert.match(scope, /--cm-line-2:\s*var\(--dsw-alias-border-l2\)/, '.chatEntryScope 必须就地重声明 --cm-line-2')
 })
 
+/**
+ * 字号 / 行高 / 限宽必须跟随宿主的「内容字号」（2026-10-17 修 issue #93）。
+ *
+ * 背景：接管 user 渲染器后我们把气泡正文基准写死 `--cm-fs-base: 12.5px`（= §1 的面板基准），
+ * 而宿主的 `.bubble` 写的是 `var(--dsh-content-font-size,14px)` —— 于是 DSH 的「内容字号」
+ * （10–22）**在用户自己的消息上完全失效**：真机内容字号 21 时助手正文字形高 19px、
+ * 气泡 11px（同一张截图，比例 0.58）。宿主口径（本机 app.asar 抽出）：
+ *   · `--dsh-content-font-size` 由 ui-layout 的 ThemePresenter 写在 **body** 上；
+ *   · `--dsh-content-font-delta` = 内容字号 − 14px，由 ui-theme 定义在 body；
+ *   · `--dsh-chat-content-width` 定义在 ui-conversation 的聊天 body（.body / .embeddedBody）。
+ */
+test('气泡字号/行高/限宽跟随宿主内容字号（不得再写死 12.5px 与固定 620px）', () => {
+  const cssSheet = readFileSync(join(HERE, '..', 'config-manager.module.css'), 'utf8')
+  // 注释里会引用这些取值（解释为什么改），负向断言必须先剥注释 —— 与 css-token-guard.test.ts 同法
+  const noComment = cssSheet.replace(/\/\*[\s\S]*?\*\//g, '')
+  const scope = noComment.match(/\.chatEntryScope\s*\{[^}]*\}/)?.[0] ?? ''
+  assert.notEqual(scope, '', '必须能定位 .chatEntryScope 规则块（扫描失效时本用例不得静默通过）')
+  // ① 正文基准 = 宿主的活值 + 兜底 14px（宿主同一条气泡的兜底；不许兜回 12.5px —— 那是面板档）
+  assert.match(scope, /--cm-fs-base:\s*var\(--dsh-content-font-size,\s*14px\)/, '.chatEntryScope 的 --cm-fs-base 必须跟随 --dsh-content-font-size（兜底 14px）')
+  assert.doesNotMatch(scope, /--cm-fs-base:\s*12\.5px/, '不得再把气泡正文写死 12.5px')
+  // ② 行高 = 宿主同一条公式（只改字号会让 21px 下比正文松 2.5px/行）
+  assert.match(scope, /--cm-lh-base:\s*calc\(22px \+ var\(--dsh-content-font-delta,\s*0px\)\)/, '行高必须用宿主同一条公式')
+  assert.match(scope, /font-size:\s*var\(--cm-fs-base\)/, '作用域字号必须消费 --cm-fs-base')
+  assert.match(scope, /line-height:\s*var\(--cm-lh-base\)/, '作用域行高必须消费 --cm-lh-base')
+  // ③ 只改聊天这一处：§1 body 的面板基准仍是 12.5px（动它会全站字号地震）
+  const bodyBlock = noComment.match(/body\s*\{[\s\S]*?\n\}/)?.[0] ?? ''
+  assert.match(bodyBlock, /--cm-fs-base:\s*12\.5px/, '§1 body 的面板基准必须保持 12.5px')
+  // ④ 限宽 = 宿主 .userStack 同一条公式；--cm-fs-meta 保持 11px 档（时间戳/动作标签不跟着放大）
+  assert.doesNotMatch(noComment, /min\(620px,\s*82%\)/, '气泡限宽不得再用固定 620px 近似')
+  const stack = noComment.match(/\.chatEntryStack\s*\{[^}]*\}/)?.[0] ?? ''
+  const notice = noComment.match(/\.chatEntryNotice\s*\{[^}]*\}/)?.[0] ?? ''
+  const WIDTH_FORMULA = /max-width:\s*min\(calc\(var\(--dsh-chat-content-width,\s*748px\) \* \.702\),\s*82%\)/
+  for (const [name, block] of [['.chatEntryStack', stack], ['.chatEntryNotice', notice]] as [string, string][]) {
+    assert.notEqual(block, '', '必须能定位 ' + name + ' 规则块（扫描失效时本用例不得静默通过）')
+    assert.match(block, WIDTH_FORMULA, name + ' 限宽必须与宿主同一条公式')
+  }
+  assert.match(scope, /--cm-fs-meta:\s*11px/, '--cm-fs-meta 保持 11px 档（时间戳/动作标签不跟着放大）')
+})
+
+/**
+ * 2026-10-17（用户要求「复制 icon 和 icon 动画也使用 DSH 原生的」）：动作行图标必须走宿主
+ * ui-primitives 的原生图标集，且**必须保留回落**（老宿主没有那份模块表 ⇒ hostIcon() 回 null）。
+ * 宿主口径（app.asar 抽出，ui-primitives/lib/index.js）：`IconCopyOutlineRegular` / `IconCheckOutlineRegular`
+ * / `IconRefreshOutlineRegular`，都是普通 `(props) => svg` 组件（size 缺省 16、Regular 档 1px 描边、
+ * 颜色 currentColor）；宿主的复制反馈是**直接换图**（`.action svg` 没有任何 transition/animation）。
+ */
+test('动作行图标走宿主原生（复制 → 对勾 → 回退），拿不到宿主图标时必须回落本仓库图标', () => {
+  const entry = sourceOf('ChatEntryView.tsx')
+  for (const name of ['IconCopyOutlineRegular', 'IconCheckOutlineRegular', 'IconRefreshOutlineRegular']) {
+    assert.match(entry, new RegExp("hostIcon\\('" + name + "'\\)"), '动作行图标必须按名字取宿主的 ' + name)
+  }
+  assert.match(entry, /<CopyStateIcon done=\{copied\} size=\{15\} \/>/, '拿不到宿主图标时必须回落 morphicons 的 CopyStateIcon（不能变成空白按钮）')
+  assert.match(entry, /<RefreshIcon size=\{15\} \/>/, '拿不到宿主图标时必须回落本仓库的 RefreshIcon')
+  assert.match(entry, /copied \? <HostCheckIcon size=\{15\} \/> : <HostCopyIcon size=\{15\} \/>/, '复制反馈必须是宿主的**换图**（不是形变动画）')
+  // 闸门只有一处：宿主图标必须经 common/host-primitives.ts 的 hostIcon（不许在组件里裸 require）
+  assert.doesNotMatch(entry, /require\(['"]@deepseek-ai/, '组件里不得裸 require 宿主包（唯一出口 = host-primitives.ts）')
+  const gate = readFileSync(join(HERE, '..', 'common', 'host-primitives.ts'), 'utf8')
+  assert.match(gate, /export function hostIcon\(name: DshIconName\)/, 'hostIcon 必须按闭集名字取图标')
+  assert.match(gate, /type DshIconName = 'IconCopyOutlineRegular' \| 'IconCheckOutlineRegular' \| 'IconRefreshOutlineRegular'/, '闭集必须逐字列这三颗，不搬整张图标表')
+})
+
+/**
+ * 2026-10-17（用户要求「与 DSH 原生气泡完全一致」）：§15b 的几何/字号必须与宿主
+ * MessageItem + MessageIconActions 的**同一条取值**逐字同式（宿主产物抽出的取值清单见
+ * docs/spec/known-gaps.md 的「G-39 增量（八）」）。这张用例是那条口径的源级护栏：
+ * 谁把圆角/内边距/动作行/文件卡改回「近似档」，这里立刻红。
+ */
+test('气泡与动作行逐值对齐宿主：圆角 xl(20px) / 内边距 10·16 / 动作行 28+delta / 文件卡 240·64', () => {
+  const cssSheet = readFileSync(join(HERE, '..', 'config-manager.module.css'), 'utf8')
+  // 注释里会引用这些取值（解释为什么改），负向断言必须先剥注释 —— 与 css-token-guard 同法
+  const noComment = cssSheet.replace(/\/\*[\s\S]*?\*\//g, '')
+  const scope = noComment.match(/\.chatEntryScope\s*\{[^}]*\}/)?.[0] ?? ''
+  assert.notEqual(scope, '', '必须能定位 .chatEntryScope 规则块（扫描失效时本用例不得静默通过）')
+  // ① 镜像 token：宿主 radius xl=20（气泡/文件卡）、sm=8（动作按钮）、动作行与图标跟着 delta 长
+  assert.match(scope, /--cm-r-chat:\s*var\(--dsw-radius-xl,\s*20px\)/, '气泡/文件卡圆角必须镜像宿主 --dsw-radius-xl（20px）')
+  assert.match(scope, /--cm-r-act:\s*var\(--dsw-radius-sm,\s*8px\)/, '动作按钮圆角必须镜像宿主 --dsw-radius-sm（8px）')
+  assert.match(scope, /--cm-chat-action:\s*calc\(28px \+ var\(--dsh-content-font-delta,\s*0px\)\)/, '动作行高度/触达区必须与宿主同式（28px + delta）')
+  assert.match(scope, /--cm-chat-glyph:\s*calc\(15px \+ var\(--dsh-content-font-delta,\s*0px\)\)/, '动作图标必须与宿主同式（15px + delta）')
+
+  // ② 气泡：宿主 .bubble 是**块**（尺寸 100% / 内边距 10px 16px / 圆角 xl）
+  const bubble = noComment.match(/\.chatBubble\s*\{[^}]*\}/)?.[0] ?? ''
+  assert.notEqual(bubble, '', '必须能定位 .chatBubble 规则块')
+  assert.match(bubble, /max-width:\s*100%/)
+  assert.match(bubble, /padding:\s*var\(--cm-sp-5\) var\(--cm-sp-8\)/, '内边距必须等于宿主的 10px 16px')
+  assert.match(bubble, /border-radius:\s*var\(--cm-r-chat\)/, '.chatBubble 必须消费 --cm-r-chat')
+  assert.doesNotMatch(bubble, /display:\s*flex/, '宿主 .bubble 是块级：不得再用 flex 列（技能/引用 chip 会被挤成独立一行）')
+
+  // ③ 动作行：宿主 MessageIconActions（gap 8 / 高 28+delta）+ MessageItem 的 4px / -6px 外边距
+  const actions = noComment.match(/\.chatEntryActions\s*\{[^}]*\}/)?.[0] ?? ''
+  assert.notEqual(actions, '', '必须能定位 .chatEntryActions 规则块')
+  assert.match(actions, /gap:\s*var\(--cm-sp-4\)/, '动作行 gap 必须等于宿主的 8px')
+  assert.match(actions, /height:\s*var\(--cm-chat-action\)/, '动作行高度必须跟随宿主的 28px + delta')
+  assert.match(actions, /margin-top:\s*var\(--cm-sp-2\)/, '动作行上方必须留宿主的 4px')
+  assert.match(actions, /margin-left:\s*calc\(-1 \* var\(--cm-sp-3\)\)/, '动作行必须用宿主同一条负外边距（-6px）对齐气泡右缘')
+
+  // ④ 时刻与文件卡
+  const time = noComment.match(/\.chatEntryTime\s*\{[^}]*\}/)?.[0] ?? ''
+  assert.notEqual(time, '', '必须能定位 .chatEntryTime 规则块')
+  assert.match(time, /font-size:\s*var\(--cm-fs-second\)/, '时刻必须用宿主的次级字号镜像（13px 档）')
+  assert.match(time, /padding-right:\s*var\(--cm-sp-6\)/, '时刻右侧必须留宿主的 12px')
+  const card = noComment.match(/\.chatFileCard\s*\{[^}]*\}/)?.[0] ?? ''
+  assert.notEqual(card, '', '必须能定位 .chatFileCard 规则块')
+  assert.match(card, /width:\s*240px/, '文件卡宽度必须等于宿主的 240px')
+  assert.match(card, /min-height:\s*64px/, '文件卡最小高度必须等于宿主的 64px')
+  assert.match(card, /gap:\s*var\(--cm-sp-5\)/, '文件卡内图标与文字间距必须等于宿主的 10px')
+  assert.match(card, /border-radius:\s*var\(--cm-r-chat\)/, '文件卡圆角必须与气泡同一档（宿主 xl）')
+
+  // ⑤ 动作行的显现语义：宿主靠 data-chat-flow-kind + :has(~ …) 表达「后面还有用户消息就藏起来」
+  assert.match(noComment, /data-chat-flow-kind='user'/, '显现语义必须复用宿主自己的 data-chat-flow-kind 属性')
+  assert.match(noComment, /:has\(~ :is\(\[data-chat-flow-kind='user'\]/, '必须与宿主同一条「后面还有用户/steering 消息 ⇒ 动作行默认隐藏」的规则')
+})
+
 /**
  * 宿主正文投影（2026-10-15）：气泡正文优先交给宿主自己的 projectUserText（会话引用/技能 → chip）。
  * 四条回落判据必须逐条可证 —— 任一条不成立都回落我们自己的纯文本投影（绝不空白、绝不抛）。
@@ -1161,6 +1367,76 @@ test('attachments: one ordered list in content order + compact counts ALL attach
   assert.deepEqual(mixed.images.map((image) => image.attachment), [{ id: 'i1' }, { id: 'i2' }])
 })
 
+test('issue #92：hostAttachments 保留宿主原始载荷、顺序与 content 一致（我们的 ChatEntryFile 拼不回来）', () => {
+  const image = { id: 'i1', width: 10 }
+  const fileRef = { id: 'f1', name: 'a.txt', bytes: 3, mimeType: 'text/plain' }
+  const view = buildChatEntryBubble([
+    { type: 'file', attachment: fileRef },
+    { type: 'image', attachment: image },
+    { type: 'file', attachment: { name: 'b.txt', bytes: 4 } },
+  ])
+  // 宿主 contentParts 的形状逐字：image 包一层 { attachment }，file 是原始 FileAttachmentRef
+  assert.deepEqual(view.hostAttachments, [
+    { type: 'file', file: fileRef },
+    { type: 'image', image: { attachment: image } },
+    { type: 'file', file: { name: 'b.txt', bytes: 4 } },
+  ])
+  assert.equal(view.hostAttachments.length, view.attachments.length, '两份列表同趟走查、同序（不得只算一半）')
+  // 没有 attachment 的块照旧只进 rest：两份列表都不许凭空多一项
+  assert.deepEqual(view.hostAttachments.filter((item) => item.type === 'image').length, 1)
+  const hostile = buildChatEntryBubble([{ type: 'image' }, { type: 'file' }])
+  assert.equal(hostile.hostAttachments.length, 0)
+  assert.equal(hostile.raw.length, 2)
+  // 非数组 / 字符串 content 的安全值里也必须带着这个字段（渲染层会直接读它）
+  assert.deepEqual(buildChatEntryBubble('hi').hostAttachments, [])
+  assert.deepEqual(buildChatEntryBubble(undefined).hostAttachments, [])
+})
+
+test('issue #92：content factory 入参 = 宿主 UserStyleBubble 的 prepared/facts（原文 + rest + 字段存在性）', () => {
+  const content = [
+    { type: 'text', text: 'see @[S](dsh-session:1)' },
+    { type: 'image', attachment: { id: 'i1' } },
+    { type: 'mystery', payload: { deep: 1 } },
+  ]
+  const bare = buildChatEntryView({ kind: 'user', location: { kind: 'step', turn: { turn: 1, status: 'closed' } }, data: { content } })
+  // text 必须是**未投影**的原文（chip 由宿主 factory 内部投影），attachments/extraBlocks 逐字带过去
+  assert.equal(bare.hostContent.content.text, 'see @[S](dsh-session:1)')
+  assert.deepEqual(bare.hostContent.content.attachments, [{ type: 'image', image: { attachment: { id: 'i1' } } }])
+  assert.deepEqual(bare.hostContent.content.extraBlocks, [{ type: 'mystery', payload: { deep: 1 } }])
+  // 宿主用「字段是否存在」区分「没带」与「空」⇒ 没带时两个对象里都不许出现这三个键
+  assert.equal('referenceLabels' in bare.hostContent.content, false)
+  assert.equal('sessionLabels' in bare.hostContent.facts, false)
+  assert.equal('skillNames' in bare.hostContent.facts, false)
+
+  const withData = buildChatEntryView({
+    kind: 'user',
+    location: { kind: 'step', turn: { turn: 1, status: 'closed' } },
+    data: { content: [{ type: 'text', text: 'q' }], referenceLabels: ['s-a', 7], skillNames: ['changelog-writing'] },
+  })
+  assert.deepEqual(withData.hostContent.content.referenceLabels, ['s-a'], '非字符串项照旧被剔除')
+  assert.deepEqual(withData.hostContent.facts.sessionLabels, ['s-a'])
+  assert.deepEqual(withData.hostContent.facts.skillNames, ['changelog-writing'])
+  // 空数组是**真的带了空**（与「没带」不同）
+  const emptyLabels = buildChatEntryView({
+    kind: 'user',
+    location: { kind: 'step', turn: { turn: 1, status: 'closed' } },
+    data: { content: [{ type: 'text', text: 'q' }], referenceLabels: [], skillNames: [] },
+  })
+  assert.deepEqual(emptyLabels.hostContent.content.referenceLabels, [])
+  assert.deepEqual(emptyLabels.hostContent.facts.sessionLabels, [])
+})
+
+test('issue #92：组件把正文委托给宿主 content factory，并把自绘气泡当 fallback（双栈，不在注册期赌形态）', () => {
+  const src = sourceOf('ChatEntryView.tsx')
+  assert.match(src, /CHAT_USER_CONTENT_FACTORY/, '必须按名字委托宿主的 content factory')
+  assert.match(src, /typeof renderFactorySlot === 'function'/, '委托前必须探测该席位是否存在（老宿主没有）')
+  assert.match(src, /fallback:\s*ownContent/, '自绘气泡必须是那次调用的 fallback（factory 缺失时不许出空白气泡）')
+  assert.match(src, /interactive:\s*true/, '宿主对用户消息传 interactive: true，必须同构')
+  assert.match(src, /loadImage,/, '宿主授权过的图片加载器必须原样转发')
+  // 反向：图片**不许**再由我们自己 renderMessageImages 一途承载（0.2.1 起该 props 已不存在）
+  assert.match(src, /const content = typeof renderFactorySlot/, '正文/附件渲染的唯一出口是这一处三元')
+})
+
 test('bubble file cards: file name + extension + size; a missing byte count stays unknown (no fake 0 B)', () => {
   const view = buildChatEntryBubble([
     { type: 'file', attachment: { name: 'C:/tmp/report.final.PDF', bytes: 1536 } },

package/src/client/chat/chat-entry-view.ts

@@ -191,6 +191,56 @@ export type ChatEntryAttachment =
   | { kind: 'image'; image: ChatEntryImage }
   | { kind: 'file'; file: ChatEntryFile }
 
+/* ------------------------------------------------------------ 宿主 content factory（0.2.1+ 委托路径） */
+
+/**
+ * 宿主 `conversation.chat.user.content`（Factory 位）的名字。
+ *
+ * 0.2.1-alpha.3 起用户气泡的正文/附件/引用**整体换轨**到这条 factory：图片位
+ * `conversation.chat.user.images` 是它的 children（single/session），旧的 `conversation.message.images`
+ * 与节点 props 上的 `renderMessageImages` 同时删除（本机解包 0.2.1-rc.2 实测：后者 0 次出现）。
+ * 因此「接管 user 之后自己复刻气泡」这条路在 0.2.1 上拿不到图片位（issue #92）——正确做法是把正文
+ * **委托回宿主自己的 content factory**，图片由 ui-attachment 在该 factory 的渲染上下文里 renderSlot。
+ *
+ * 老宿主（≤0.2.0）没有这条 factory：`FactoryOutlet` 在定义缺失时回落调用方给的 `options.fallback`
+ * ⇒ 渲染层把**自绘气泡**当 fallback 传进去，0.1.x/0.2.0 的路径逐字不变（一个版本双栈兼容）。
+ */
+export const CHAT_USER_CONTENT_FACTORY = 'conversation.chat.user.content'
+
+/**
+ * 宿主 content factory 的附件项（逐字保留宿主 content 里的原始 attachment 载荷）。
+ *
+ * 形状逐字取自宿主 `contentParts`：`{ type:'image', image:{ attachment } }` /
+ * `{ type:'file', file: block.attachment }` —— `file` 那一支是我们的 ChatEntryFile **拼不回来**的
+ * `FileAttachmentRef`，所以必须原样留一份。
+ */
+export type HostUserContentAttachment =
+  | { type: 'image'; image: { attachment: unknown } }
+  | { type: 'file'; file: unknown }
+
+/** 传给宿主 content factory 的正文载荷（= 宿主 UserStyleBubble 的 `prepared`）。 */
+export interface HostUserContentData {
+  /** 拼接后的**原文**（未投影；宿主 content factory 内部自己投影会话引用/技能 chip）。 */
+  text: string
+  attachments: HostUserContentAttachment[]
+  /** 未知 / rest 块（宿主交给 JsonBlock，**必须**原样带过去）。 */
+  extraBlocks: unknown[]
+  /** 仅当节点 data 真的带了该字段时出现（宿主用「字段是否存在」区分「没带」与「空」）。 */
+  referenceLabels?: string[]
+}
+
+/** 传给宿主 content factory 的文本投影事实（= 宿主 UserStyleBubble 的 `facts`）。 */
+export interface HostUserContentFacts {
+  sessionLabels?: string[]
+  skillNames?: string[]
+}
+
+/** 一次 `renderFactorySlot(CHAT_USER_CONTENT_FACTORY, …)` 的入参（`loadImage`/`interactive` 由渲染层补）。 */
+export interface HostUserContentInput {
+  content: HostUserContentData
+  facts: HostUserContentFacts
+}
+
 export interface ChatEntryBubbleView {
   /** 文本块拼接结果（宿主 `texts.join('')`，逐字保留换行与空白；会话引用的线格式已投影成 label）。 */
   text: string
@@ -201,6 +251,12 @@ export interface ChatEntryBubbleView {
   rawText: string
   /** **有序附件列表**：渲染层必须按这个顺序输出（宿主不区分「先图片后文件」）。 */
   attachments: ChatEntryAttachment[]
+  /**
+   * **宿主形状**的有序附件列表（0.2.1+ 委托路径专用）：与 `attachments` 同一趟走查、同一顺序，
+   * 但保留宿主 content 里的**原始 attachment 载荷**（我们的 ChatEntryFile 只留了三个展示字段，
+   * 拼不回宿主 `FileAttachmentRef`）。逐字对齐宿主 `contentParts` 的 `attachments.push`。
+   */
+  hostAttachments: HostUserContentAttachment[]
   /** 图片附件（= `attachments` 里的 image 项，顺序一致；用于计数与「无渲染位」提示）。 */
   images: ChatEntryImage[]
   /** 文件附件（= `attachments` 里的 file 项，顺序一致）。 */
@@ -414,14 +470,15 @@ export function fileSizeTextOf(bytes: number | null): string | null {
 export function buildChatEntryBubble(content: unknown): ChatEntryBubbleView {
   if (typeof content === 'string') {
     const text = projectChatEntryText(content)
-    return { text, rawText: content, attachments: [], images: [], files: [], raw: [], showBubble: text !== '' }
+    return { text, rawText: content, attachments: [], hostAttachments: [], images: [], files: [], raw: [], showBubble: text !== '' }
   }
   if (!Array.isArray(content)) {
-    return { text: '', rawText: '', attachments: [], images: [], files: [], raw: content === null || content === undefined ? [] : [{ id: '0', payload: content }], showBubble: content !== null && content !== undefined }
+    return { text: '', rawText: '', attachments: [], hostAttachments: [], images: [], files: [], raw: content === null || content === undefined ? [] : [{ id: '0', payload: content }], showBubble: content !== null && content !== undefined }
   }
   const texts: string[] = []
   const rawTexts: string[] = []
   const attachments: ChatEntryAttachment[] = []
+  const hostAttachments: HostUserContentAttachment[] = []
   const raw: ChatEntryRawBlock[] = []
   content.forEach((block, index) => {
     const record = asRecord(block)
@@ -435,6 +492,8 @@ export function buildChatEntryBubble(content: unknown): ChatEntryBubbleView {
     }
     if (type === 'image' && record?.['attachment'] !== undefined) {
       attachments.push({ kind: 'image', image: { attachment: record['attachment'] } })
+      // 同一趟走查里并出宿主形状的那一份（同一顺序、原始载荷）—— 见 HostUserContentAttachment
+      hostAttachments.push({ type: 'image', image: { attachment: record['attachment'] } })
       return
     }
     if (type === 'file' && record?.['attachment'] !== undefined) {
@@ -449,6 +508,7 @@ export function buildChatEntryBubble(content: unknown): ChatEntryBubbleView {
           bytes: typeof bytes === 'number' && Number.isFinite(bytes) ? bytes : null,
         },
       })
+      hostAttachments.push({ type: 'file', file: record['attachment'] })
       return
     }
     raw.push({ id: String(index), payload: block })
@@ -458,7 +518,34 @@ export function buildChatEntryBubble(content: unknown): ChatEntryBubbleView {
   // images / files 是 attachments 的**派生视图**（不独立积累，避免两处真相与顺序漂移）
   const images = attachments.flatMap((item) => (item.kind === 'image' ? [item.image] : []))
   const files = attachments.flatMap((item) => (item.kind === 'file' ? [item.file] : []))
-  return { text, rawText, attachments, images, files, raw, showBubble: text !== '' || raw.length > 0 }
+  return { text, rawText, attachments, hostAttachments, images, files, raw, showBubble: text !== '' || raw.length > 0 }
+}
+
+/**
+ * 节点 data + 气泡视图 → 宿主 content factory 的入参（0.2.1+ 委托路径的**唯一**组装点）。
+ *
+ * 逐字对齐宿主 `UserStyleBubble` 的 `prepared` / `facts` 两段 useMemo：
+ *  · `content.text` = 未投影的文本拼接（宿主 factory 自己把它交给 `conversation.user.text` 投影成 chip）；
+ *  · `content.attachments` = 宿主形状的有序附件（同一趟走查产出）；
+ *  · `content.extraBlocks` = rest 块原样；
+ *  · `referenceLabels` / `sessionLabels` / `skillNames` **只在节点真的带了该字段时出现** ——
+ *    宿主用「字段是否存在」区分「没带」与「空数组」，我们传 `[]` 会改变它的分支。
+ *
+ * 本函数不抛（读不到就按「没带」处理），与 buildChatEntryBubble 同一条纪律。
+ */
+export function buildHostUserContentInput(data: ChatEntryNodeDataView, bubble: ChatEntryBubbleView): HostUserContentInput {
+  const content: HostUserContentData = {
+    text: bubble.rawText,
+    attachments: bubble.hostAttachments,
+    extraBlocks: bubble.raw.map((block) => block.payload),
+  }
+  const facts: HostUserContentFacts = {}
+  if (data.referenceLabels !== null) {
+    content.referenceLabels = data.referenceLabels
+    facts.sessionLabels = data.referenceLabels
+  }
+  if (data.skillNames !== null) facts.skillNames = data.skillNames
+  return { content, facts }
 }
 
 /** 渲染计划的一项：图片带 owner 载荷，文件带名称/扩展名/体积文本。 */
@@ -631,19 +718,26 @@ export interface ChatEntryView {
    */
   referenceLabels: string[]
   skillNames: string[]
+  /**
+   * 宿主 content factory 的入参（0.2.1+ 委托路径）。**始终**算好：新宿主用它委托，老宿主把它
+   * 闲置（那条 factory 不存在 ⇒ 渲染层走自绘气泡 fallback），两条路径都不需要再读一次节点。
+   */
+  hostContent: HostUserContentInput
 }
 
 /** 节点 → 整视图模型（读不到一律回安全值；本函数不抛）。 */
 export function buildChatEntryView(node: unknown): ChatEntryView {
   const data = readChatEntryNodeData(node)
   const turn = chatNodeTurn(node)
+  const bubble = buildChatEntryBubble(data.content)
   return {
     turnNumber: turn?.turn ?? null,
     turnStatus: turn?.status ?? null,
-    bubble: buildChatEntryBubble(data.content),
+    bubble,
     clock: formatChatEntryClock(data.time),
     referenceLabels: data.referenceLabels ?? [],
     skillNames: data.skillNames ?? [],
+    hostContent: buildHostUserContentInput(data, bubble),
   }
 }
 

package/src/client/chat/chat-node-registration.ts

@@ -8,6 +8,11 @@
  * 2026-10-12（用户要求「聊天内回退入口只有每条用户消息」）：旧的「整回合」档连同它的偏好模块
  * （`chat-entry-pref` / `chat-entry-mount`）与回合尾入口（`conversation.chat.turnTail`）一并删除 ——
  * 入口恒为每条用户消息气泡里的那一颗，于是这里不再有偏好门，也不再需要「切档时重新评估」的订阅。
+ *
+ * 2026-10-17（用户要求）：开关**关闭时不得再接管用户消息气泡**。原实现是「登记常驻、只收起按钮」——
+ * 功能关掉之后那条气泡仍由我们代画（即使正文已委托宿主 factory，外层壳与动作行仍是我们的）。
+ * 现在登记本身随开关出现 / 撤销（`registerChatNodeEntryWhenEnabled`）：关掉即让出 user cell，
+ * 宿主 `UserMessageNodeView` 原样接管回来。
  */
 import {
   CHAT_NODE_SLOT,
@@ -96,3 +101,69 @@ export function registerChatNodeEntry(options: {
     return () => {}
   }
 }
+
+/**
+ * 开关驱动的登记闸门：**只在功能开启时才接管 user cell**。
+ *
+ * 为什么不是「常驻登记 + 组件里隐藏按钮」：接管 = priority -1 遮蔽宿主 `UserMessageNodeView`，
+ * 只要登记还在，那条气泡（含外层壳与动作行）就由我们画 —— 用户 2026-10-17 明确要求关闭后
+ * **完全不要接管**，气泡交回宿主原生渲染。反过来，开关打开时**必须**有登记，否则入口无处可放
+ * （该 key 没有 children 表，见 `chat-slots.ts`）。
+ *
+ * 纯逻辑（开关读写与订阅都从外面注进来），便于在 node:test 下逐条断言：
+ *  · 关闭 → 一次注册都不发生；
+ *  · 开关转开 → 登记一次（重复通知幂等）；
+ *  · 开关转关 → **立刻撤销登记**（cell 回到宿主 priority 0）；
+ *  · 装配卸载 → 解绑订阅 + 撤销登记，不留悬挂注册。
+ *
+ * @returns 卸载函数（调用点 = `ctx.slots.inject` 的回调返回值）。
+ */
+export interface ChatNodeEntryGateOptions {
+  /** 槽位探测面（同 {@link registerChatNodeEntry}；探测只在真正注册那一次发生）。 */
+  probe: ChatNodeSlotProbe | undefined | null
+  /** 真正的注册调用（调用点包 `ctx.slots.register`，保持编译期校验）。 */
+  register: () => () => void
+  /** 功能此刻是否开启（`rollbackEnabled` 的进程内信号）。 */
+  isEnabled: () => boolean
+  /** 订阅开关变化（返回解绑函数）。 */
+  subscribe: (listener: () => void) => () => void
+  /** 诊断回调（缺省 `console.warn`；单测注入以免污染输出）。 */
+  warn?: (message: string) => void
+}
+
+export function registerChatNodeEntryWhenEnabled(options: ChatNodeEntryGateOptions): () => void {
+  /** 当前登记的解绑函数；null = 现在没有登记（= 宿主渲染器在渲染那条 cell）。 */
+  let disposeEntry: (() => void) | null = null
+
+  const sync = (): void => {
+    if (options.isEnabled() === true) {
+      if (disposeEntry === null) {
+        disposeEntry = registerChatNodeEntry({
+          probe: options.probe,
+          register: options.register,
+          ...(options.warn === undefined ? {} : { warn: options.warn }),
+        })
+      }
+      return
+    }
+    if (disposeEntry !== null) {
+      const dispose = disposeEntry
+      disposeEntry = null
+      dispose()
+    }
+  }
+
+  const unsubscribe = options.subscribe(sync)
+  // 订阅**先建后读**：读到与订阅之间没有窗口，开关恰在此刻翻转也不会漏（多跑一次 sync 是幂等的）。
+  sync()
+
+  return () => {
+    unsubscribe()
+    if (disposeEntry !== null) {
+      const dispose = disposeEntry
+      disposeEntry = null
+      dispose()
+    }
+  }
+}
+

package/src/client/chat/chat-slots.ts

@@ -9,19 +9,25 @@
  *
  * ## 镜像来源（**逐条核过真机 app.asar，不是猜的**）
  *
- * 槽位声明 = `packages/client/ui-chat/src/client/contract/slots.ts`（整包只声明 8 个槽位：
- * conversation.chat.node / conversation.message.images / conversation.chat.commandview /
- * conversation.chat.turnTail / conversation.chat.assistant-actions / conversation.view /
- * conversation.composer.dock / conversation.approval.detail）。
+ * 槽位声明 = `packages/client/ui-chat/src/client/contract/slots.ts`。
  *
  * ### `conversation.chat.node`（本插件**接管**其 `user` key）
  *
  *   kind: 'keyed' · scope: 'session'
- *   ownerProps: { groupPart?, cwd, openFile, openSkill, inspectCall, forkAt, loadImage,
- *                 renderMessageImages, fileMentions, turnProcess, node }
  *   registerOptions: key(必填) / priority(可选，= cell 遮蔽秩，升序、最低者渲染)
  *   replaceRisk: **有**（这是 keyed 遮蔽位：priority -1 会顶掉 shipped 的 UserMessageNodeView）
  *
+ * ownerProps **在 0.2.1-alpha.3 换过一代**（本机解包 `@deepseek-ai/dsh-client-ui-chat` 的
+ * `lib/client.js` + `lib/types/.../slots.d.ts` 实测，2026-10-17，issue #92）：
+ *
+ *   ≤0.2.0 ：{ groupPart?, cwd, openFile, openSkill, inspectCall, forkAt, loadImage,
+ *              renderMessageImages, fileMentions, turnProcess, node }
+ *   ≥0.2.1 ：{ groupPart?, cwd, openFile, inspectCall, forkAt, loadImage, fileMentions, node }
+ *              —— **删掉 `renderMessageImages` 与 `openSkill`**；图片位不再由 ui-chat 直接声明，
+ *              而是 `conversation.chat.user.content` factory 的 children
+ *              （`conversation.chat.user.images`, single/session）⇒ 想拿到图片**必须**委托那条 factory
+ *              （实现与判据见 `ChatEntryView.tsx` / `CHAT_USER_CONTENT_FACTORY`）。
+ *
  * 关键事实（决定了本功能只能走这条路，见 T1 output 的证据段）：
  *  · 宿主对 `{ name:'conversation.chat.node', key:'user' }` **没有声明 children 表**
  *    （对比 turn-tail 节点声明了 turnTail + assistant-actions 两个 list 子位）
@@ -84,14 +90,26 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
            */
           node: unknown
           /**
-           * 图片渲染位（宿主 `conversation.message.images` 的 renderSlot 绑定）——
-           * **必须**用它渲染图片（ui-chat 的私有实现不可导入）。
+           * 图片渲染位（**≤0.2.0** 宿主：`conversation.message.images` 的 renderSlot 绑定）——
+           * 必须用它渲染图片（ui-chat 的私有实现不可导入）。
+           *
+           * **0.2.1-alpha.3 起宿主整行删掉了它**（issue #92：新契约改由
+           * `conversation.chat.user.content` factory 的 `conversation.chat.user.images` 子位承载）
+           * ⇒ 镜像里跟着改成**可选**：渲染层据「它在不在」决定走旧的自绘图片位，还是委托 content factory。
+           */
+          renderMessageImages?: (owner: unknown) => unknown
+          /**
+           * 宿主授权过的图片加载器（0.2.1 起节点渲染器 props 上的稳定席位；转发给 content factory）。
+           * 老宿主上拿不到它（那时 loadImage 被封在 renderMessageImages 的闭包里）。
            */
-          renderMessageImages: (owner: unknown) => unknown
+          loadImage?: unknown
           /** 宿主提供的文件打开器（本插件不消费，保持契约完整）。 */
-          openFile: (path: string) => void
-          /** 宿主提供的 skill 打开器（同上）。 */
-          openSkill: (name: string) => void
+          openFile?: (path: string) => void
+          /**
+           * 宿主提供的 skill 打开器（同上）。0.2.1 起该席位从 ChatNodeOwnerProps 消失
+           * （与 renderMessageImages 同一批）⇒ 同样改成可选。
+           */
+          openSkill?: (name: string) => void
         }
       }
       owner: {