dsh-config-manager 0.1.73 → 0.1.76

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

@@ -42,6 +42,9 @@ import {
   planChatEntryAttachments,
   planChatNodeRegistration,
   projectChatEntryText,
+  projectChatEntryTextWithHost,
+  chatNodeUserOccupant,
+  CHAT_NODE_YIELD_WARN_PREFIX,
   resetChatPointCache,
   shouldRetryChatPoint,
   CHAT_POINT_LOOKUP_WINDOW_MS,
@@ -55,7 +58,7 @@ import {
   retryChatPointUntilHit,
   type ChatPointWindowState,
 } from './chat-point-window.ts'
-import { declaredSlotKind, registerChatNodeEntry } from './chat-node-registration.ts'
+import { chatNodeOccupantOf, declaredSlotKind, registerChatNodeEntry } 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'
 
@@ -110,6 +113,52 @@ test('registration plan: a keyed declaration registers; anything else is skipped
   assert.deepEqual(planChatNodeRegistration('list'), { kind: 'skip', reason: 'slot-kind-mismatch', declared: 'list' })
 })
 
+/**
+ * 让位判据（2026-10-15，跨插件冲突）：keyed cell「最低的渲染」——别人 priority 更低时我们必定轮不到渲染，
+ * 所以**先读占用再决定注册**：更低 → 让位并告警（不抢格、不静默）；相同（只可能是残留的自己）→ 照常注册
+ * （真撞上由 try/catch 兜住）；宿主那条 priority 0 → 我们 -1 本来就要遮蔽它，当然注册。
+ */
+test('registration plan: yields when another renderer already owns the user cell at a LOWER priority', () => {
+  const host = { priority: 0, registrant: null }
+  const oursOwn = { priority: -1, registrant: 'dsh-config-manager' }
+  const theirs = { priority: -2, registrant: '@someone/other-rewind' }
+  assert.deepEqual(planChatNodeRegistration('keyed', host), { kind: 'register' })
+  assert.deepEqual(planChatNodeRegistration('keyed', oursOwn), { kind: 'register' })
+  assert.deepEqual(planChatNodeRegistration('keyed', theirs), {
+    kind: 'skip',
+    reason: 'shadowed',
+    declared: 'keyed',
+    occupant: theirs,
+  })
+  // 形态不符的判据优先于占用（按 keyed 参数注册本来就会抛）
+  assert.equal(planChatNodeRegistration('list', theirs).kind, 'skip')
+})
+
+test('occupant reader: reads the winning entry per cell from entriesOfSlot shape; anything else is null', () => {
+  const entry = (key: string, priority?: number, registrant?: string) => ({
+    options: { key, ...(priority === undefined ? {} : { priority }) },
+    ...(registrant === undefined ? {} : { registrant }),
+  })
+  assert.equal(chatNodeUserOccupant(null), null)
+  assert.equal(chatNodeUserOccupant({}), null)
+  assert.equal(chatNodeUserOccupant([]), null)
+  assert.deepEqual(chatNodeUserOccupant([entry('agent-teams', -5)]), null, 'other keys are not our cell')
+  // 缺省 priority = 0（宿主缺省），registrant 读不到如实回 null（绝不猜）
+  assert.deepEqual(chatNodeUserOccupant([entry('user')]), { priority: 0, registrant: null })
+  // 多条同 key：取最低的那条（= 会被渲染的那条）
+  assert.deepEqual(
+    chatNodeUserOccupant([entry('user', 0, 'host'), entry('user', -2, 'other')]),
+    { priority: -2, registrant: 'other' },
+  )
+  // 非数值 priority 当成缺省 0；空 registrant 归 null
+  assert.deepEqual(chatNodeUserOccupant([entry('user', Number.NaN, '')]), { priority: 0, registrant: null })
+  // registrant 也可能挂在 options 上（宿主两个位置都读过）
+  assert.deepEqual(chatNodeUserOccupant([{ options: { key: 'user', priority: -3, registrant: 'x' } }]), {
+    priority: -3,
+    registrant: 'x',
+  })
+})
+
 test('register shell: keyed declaration registers exactly once; non-keyed declaration is skipped, not thrown', () => {
   const warn: string[] = []
   let called = 0
@@ -136,6 +185,31 @@ test('register shell: keyed declaration registers exactly once; non-keyed declar
   assert.equal(declaredSlotKind({ spec: () => { throw new Error('boom') } }), null)
 })
 
+test('register shell: yields (does NOT register) when a lower-priority renderer owns the user cell', () => {
+  const warn: string[] = []
+  let called = 0
+  const disposer = registerChatNodeEntry({
+    probe: {
+      spec: () => ({ kind: 'keyed', scope: 'session' }),
+      entriesOfSlot: () => [{ options: { key: 'user', priority: -2 }, registrant: '@someone/other-rewind' }],
+    },
+    register: () => { called += 1; return () => {} },
+    warn: (message) => { warn.push(message) },
+  })
+  assert.equal(called, 0, 'we must not fight for a cell another renderer already owns at a lower priority')
+  assert.equal(typeof disposer, 'function')
+  assert.ok(warn.some((line) => line.startsWith(CHAT_NODE_YIELD_WARN_PREFIX)), 'the yield must be logged, never silent')
+  assert.ok(warn.some((line) => line.includes('-2') && line.includes('@someone/other-rewind')))
+})
+
+test('occupant probe: missing entriesOfSlot / a throwing probe / a foreign shape all mean “nobody occupies it”', () => {
+  assert.equal(chatNodeOccupantOf(undefined), null)
+  assert.equal(chatNodeOccupantOf({ spec: () => ({ kind: 'keyed' }) }), null, 'old hosts expose no entriesOfSlot')
+  assert.equal(chatNodeOccupantOf({ spec: () => {}, entriesOfSlot: () => { throw new Error('boom') } }), null)
+  assert.equal(chatNodeOccupantOf({ spec: () => {}, entriesOfSlot: () => ({ not: 'an array' }) }), null)
+  assert.deepEqual(chatNodeOccupantOf({ spec: () => {}, entriesOfSlot: () => [{ options: { key: 'user', priority: 0 } }] }), { priority: 0, registrant: null })
+})
+
 test('register shell: a throwing register() is contained (never takes the plugin down)', () => {
   const warn: string[] = []
   const disposer = registerChatNodeEntry({
@@ -204,6 +278,95 @@ test('样式纪律：icon 入口与预览文件行只用既有 token/类，未
   }
 })
 
+/**
+ * 底色必须跟随宿主（2026-10-15 用户反馈「浅色主题下用户消息气泡看不见」）。
+ *
+ * 背景：接管 user 渲染器后我们自复刻那条气泡，底色曾写 --cm-surface-2（= --dsw-alias-bg-layer-2）——
+ * 浅色主题下它 = #fff，而页面底 --dsw-alias-bg-base 也是 #fff ⇒ 与页面同色（对比度 0）；
+ * 宿主真机用的是 --dsw-specific-bubble（浅色 = --dsw-static-deepseek-50 = #edf3fe）。
+ * 深色下两者恰好同值，所以这条差距当时被误判成「可接受的近似档」。
+ */
+test('气泡底色跟随宿主的 --dsw-specific-bubble（不得再用 --cm-surface-2 近似）', () => {
+  const cssSheet = readFileSync(join(HERE, '..', 'config-manager.module.css'), 'utf8')
+  // ① 定义行：宿主 token + **可见**兜底（无兜底的 var() 在宿主删档时会整条失效 → transparent；
+  //    兜成 bg-layer-2 也没用 —— 浅色下它同样是 #fff，气泡照样消失）
+  const defs = cssSheet.match(/--cm-chat-bubble:\s*var\(--dsw-specific-bubble,\s*color-mix\(in srgb, var\(--cm-text-1\) 12%, transparent\)\)/g) ?? []
+  assert.ok(defs.length >= 2, '--cm-chat-bubble 必须在 §1 body 与 .chatEntryScope 各定义一次（且兜底是可见色），实际 ' + String(defs.length) + ' 处')
+  assert.equal(
+    (cssSheet.match(/--cm-chat-bubble:[^;]*--dsw-alias-bg-layer-2/g) ?? []).length,
+    0,
+    '兜底不得用 --dsw-alias-bg-layer-2（浅色下 = #fff ⇒ 等于没兜底）',
+  )
+  // ② 消费点：.chatBubble 只写 --cm-*（三层单向依赖），且不得再回到 --cm-surface-2
+  const bubble = cssSheet.match(/\.chatBubble\s*\{[^}]*\}/)?.[0] ?? ''
+  assert.match(bubble, /background:\s*var\(--cm-chat-bubble\)/, '.chatBubble 的底色必须消费 --cm-chat-bubble')
+  assert.doesNotMatch(bubble, /--cm-surface-2|--dsw-/, '.chatBubble 不得再用 --cm-surface-2 近似、也不得裸写 --dsw-*')
+  // ③ 作用域重声明：聊天流不在插件设置页子树内
+  const scope = cssSheet.match(/\.chatEntryScope\s*\{[^}]*\}/)?.[0] ?? ''
+  assert.match(scope, /--cm-chat-bubble:\s*var\(--dsw-specific-bubble/, '.chatEntryScope 必须就地重声明 --cm-chat-bubble')
+})
+
+/** 文件卡描边同轮对齐（2026-10-15）：宿主 = `.5px solid --dsw-alias-border-l2`，我们此前用更淡的 border-l1。 */
+test('文件卡描边与宿主同档：.5px + --cm-line-2（不是更淡的 --cm-line-1）', () => {
+  const cssSheet = readFileSync(join(HERE, '..', 'config-manager.module.css'), 'utf8')
+  // 注释里会出现 token 名（解释为什么改），负向断言必须先剥注释 —— 与 css-token-guard.test.ts 同法
+  const card = cssSheet.replace(/\/\*[\s\S]*?\*\//g, '').match(/\.chatFileCard\s*\{[^}]*\}/)?.[0] ?? ''
+  assert.match(card, /border:\s*0\.5px solid var\(--cm-line-2\)/, '文件卡描边必须与宿主一致：.5px + --cm-line-2')
+  assert.doesNotMatch(card, /--cm-line-1/, '文件卡描边不得再退回更淡的 --cm-line-1')
+  const scope = cssSheet.match(/\.chatEntryScope\s*\{[^}]*\}/)?.[0] ?? ''
+  assert.match(scope, /--cm-line-2:\s*var\(--dsw-alias-border-l2\)/, '.chatEntryScope 必须就地重声明 --cm-line-2')
+})
+
+/**
+ * 宿主正文投影（2026-10-15）：气泡正文优先交给宿主自己的 projectUserText（会话引用/技能 → chip）。
+ * 四条回落判据必须逐条可证 —— 任一条不成立都回落我们自己的纯文本投影（绝不空白、绝不抛）。
+ */
+test('host text projection: four fallback criteria, and every argument goes through verbatim', () => {
+  const calls: unknown[][] = []
+  // 返回值用字符串（合法的 ReactNode）—— 纯层只要求「非空节点」，chip 的真实形状由宿主决定
+  const projector = (text: string, labels: readonly string[], skills: readonly string[], kind: string, references?: { openFile?: unknown; openSkill?: unknown }): string => {
+    calls.push([text, labels, skills, kind, references])
+    return '[chip]'
+  }
+  const options = { sessionLabels: ['会话甲'], skillNames: ['i-have-adhd'], openFile: 'of', openSkill: 'os' }
+  assert.deepEqual(projectChatEntryTextWithHost(projector, 'raw', options), '[chip]')
+  assert.deepEqual(calls[0], ['raw', ['会话甲'], ['i-have-adhd'], 'skill', { openFile: 'of', openSkill: 'os' }])
+  // ① 没有投影器（老宿主模块表里没有 ui-primitives）
+  assert.equal(projectChatEntryTextWithHost(null, 'raw', options), null)
+  assert.equal(projectChatEntryTextWithHost(undefined, 'raw', options), null)
+  // ② 原文为空
+  assert.equal(projectChatEntryTextWithHost(projector, '', options), null)
+  // ③ 投影自己抛错
+  assert.equal(projectChatEntryTextWithHost(() => { throw new Error('boom') }, 'raw', options), null)
+  // ④ 投影拒绝了这段文本（null / undefined / false）
+  assert.equal(projectChatEntryTextWithHost(() => null, 'raw', options), null)
+  assert.equal(projectChatEntryTextWithHost(() => undefined, 'raw', options), null)
+  assert.equal(projectChatEntryTextWithHost(() => false, 'raw', options), null)
+  // 缺省选项也要把完整参数交给投影器（空数组 + 空打开器），绝不缺参
+  calls.length = 0
+  assert.deepEqual(projectChatEntryTextWithHost(projector, 'x'), '[chip]')
+  assert.deepEqual(calls[0], ['x', [], [], 'skill', { openFile: undefined, openSkill: undefined }])
+})
+
+test('bubble keeps the UNprojected text for the host projector and the projected text as the fallback', () => {
+  const view = buildChatEntryBubble([{ type: 'text', text: '看这条 @[会话甲](dsh-session:s9) 引用' }])
+  assert.equal(view.text, '看这条 会话甲 引用')
+  assert.equal(view.rawText, '看这条 @[会话甲](dsh-session:s9) 引用')
+  // 多个文本块：两边都按 content 顺序拼接（非文本块不参与拼接）
+  const multi = buildChatEntryBubble([
+    { type: 'text', text: 'A' },
+    { type: 'image', attachment: { id: 'i' } },
+    { type: 'text', text: 'B' },
+  ])
+  assert.equal(multi.text, 'AB')
+  assert.equal(multi.rawText, 'AB')
+  // 怪形状：字符串 content 两边都有值；空 content 两边都是空串（不编造）
+  assert.deepEqual([buildChatEntryBubble('hi').text, buildChatEntryBubble('hi').rawText], ['hi', 'hi'])
+  const empty = buildChatEntryBubble(null)
+  assert.equal(empty.text, '')
+  assert.equal(empty.rawText, '')
+})
+
 /* ------------------------------------------------------------ ⑤ 回合号只认可核实字段 */
 
 test('turn number: only node.location.kind turn|step counts (same read as the host turnTail)', () => {

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

@@ -45,20 +45,63 @@ export const CHAT_NODE_USER_KEY = 'user'
  */
 export const CHAT_NODE_PRIORITY = -1
 
+/**
+ * 同一个 cell（key=user）当前**会被渲染的那一条**（= priority 最小的那一条）。
+ *
+ * 为什么要读它（2026-10-15，跨插件冲突排查的落地）：`conversation.chat.node` 是 keyed 遮蔽位，
+ * 「最低的渲染」——别的插件若也用 key=user 且 priority 比我们更低（≤ -2），它会赢而我们**静默失效**
+ * （框架不报错）。所以我们在注册**之前**读一次占用：赢家比我们更低就让位并告警，不去抢。
+ */
+export interface ChatNodeOccupant {
+  /** 该条的 priority（宿主缺省 0）。 */
+  priority: number
+  /** 诊断用标识（宿主用 fiber 名盖的戳）；读不到回 null，**绝不猜**。 */
+  registrant: string | null
+}
+
+/** 从 `entriesOfSlot('conversation.chat.node')` 的返回值里读 user cell 的赢家（形状不符一律 null）。 */
+export function chatNodeUserOccupant(entries: unknown): ChatNodeOccupant | null {
+  if (!Array.isArray(entries)) return null
+  let winner: ChatNodeOccupant | null = null
+  for (const entry of entries) {
+    const record = asRecord(entry)
+    const options = asRecord(record?.['options'])
+    if (options === null || options['key'] !== CHAT_NODE_USER_KEY) continue
+    const raw = options['priority']
+    const priority = typeof raw === 'number' && Number.isFinite(raw) ? raw : 0
+    const label = record?.['registrant'] ?? options['registrant']
+    const registrant = typeof label === 'string' && label !== '' ? label : null
+    if (winner === null || priority < winner.priority) winner = { priority, registrant }
+  }
+  return winner
+}
+
 /**
  * 槽位登记计划：**只在 0.2 的 keyed 形态时接管**（2026-10-12：入口只剩「每条用户消息」一种形态，
  * 旧的「整回合」档与偏好门已随 chat-entry-pref / chat-entry-mount 一起删除）。
  *
  * 跳过必须是**失败软化**（只丢这一个入口，不动本插件其余槽位、不动宿主启动）：
  *  · `slot-kind-mismatch`：0.1.x 的 ui-chat 把同一 key 声明成别的形态（对照 turnTail 的
- *    list/chain 双形态实测），按 keyed 参数（key/priority）注册会抛。
+ *    list/chain 双形态实测），按 keyed 参数（key/priority）注册会抛；
+ *  · `shadowed`（2026-10-15）：user cell 已被**更低优先级**的条目占住 —— 我们注册也永远轮不到渲染
+ *    （「最低的渲染」），不如让位并如实告警（不静默、也不去抢别人的格子）。
+ *
+ * 注意 `occupant.priority === CHAT_NODE_PRIORITY` **不算遮蔽**：同一 cell 同 priority 只可能有一条
+ * （再注册会抛，由登记处的 try/catch 兜住），所以那时该试的是注册而不是让位。
  */
 export type ChatNodeRegistrationPlan =
   | { kind: 'register' }
   | { kind: 'skip'; reason: 'slot-kind-mismatch'; declared: string | null }
+  | { kind: 'skip'; reason: 'shadowed'; declared: string | null; occupant: ChatNodeOccupant }
 
-export function planChatNodeRegistration(declaredKind: string | null): ChatNodeRegistrationPlan {
+export function planChatNodeRegistration(
+  declaredKind: string | null,
+  occupant: ChatNodeOccupant | null = null,
+): ChatNodeRegistrationPlan {
   if (declaredKind !== 'keyed') return { kind: 'skip', reason: 'slot-kind-mismatch', declared: declaredKind }
+  if (occupant !== null && occupant.priority < CHAT_NODE_PRIORITY) {
+    return { kind: 'skip', reason: 'shadowed', declared: declaredKind, occupant }
+  }
   return { kind: 'register' }
 }
 
@@ -151,6 +194,11 @@ export type ChatEntryAttachment =
 export interface ChatEntryBubbleView {
   /** 文本块拼接结果（宿主 `texts.join('')`，逐字保留换行与空白；会话引用的线格式已投影成 label）。 */
   text: string
+  /**
+   * **未投影**的文本拼接（会话线格式原样保留）—— 只给宿主 `projectUserText` 用：
+   * 它自己认 `@[label](dsh-session:…)` 并把引用/技能渲染成 chip；我们自己的 `text` 是它的兜底。
+   */
+  rawText: string
   /** **有序附件列表**：渲染层必须按这个顺序输出（宿主不区分「先图片后文件」）。 */
   attachments: ChatEntryAttachment[]
   /** 图片附件（= `attachments` 里的 image 项，顺序一致；用于计数与「无渲染位」提示）。 */
@@ -244,11 +292,12 @@ export function formatChatEntryClock(time: number | null): string | null {
 export const CHAT_SESSION_WIRE_RE = /@\[([^\]\n]+)\]\(dsh-session:[^)\s]+\)/gu
 
 /**
- * 正文的**最小文本投影**：把会话引用线格式换成它的人类可读 label。
+ * 正文的**最小文本投影**（宿主投影不可用时的兜底）：把会话引用线格式换成它的人类可读 label。
  *
- * 宿主做的是「换成 chip 节点」（`projectUserText`，还会把裸 `@name` 也装饰成 chip、把引用汇总成
- * 一行 referenceSummary）；我们**不做 chip**（ui-primitives 包私有、不可导入，见 G-39 已追认差距），
- * 但**绝不把线格式原样打给用户看** —— 那是机器的编码，正常人读不了（t4 复核 D5，medium）。
+ * 2026-10-15 起：气泡正文**优先走宿主自己的** `projectUserText`（见 `projectChatEntryTextWithHost`
+ * —— 它能把会话引用与技能渲染成 chip，并在给了打开器时可点开）；本函数是**兜底与纯文本路径**
+ * （复制按钮、错误边界降级、老宿主没有原语包时）的唯一实现：任何情况下都**不把线格式原样打给用户看**
+ * （那是机器的编码，正常人读不了 —— t4 复核 D5，medium）。
  * 与宿主一致的边界：只认 `dsh-session:` 的括号形式；`g` flag 下逐处替换，正则自身 lastIndex 置零。
  */
 export function projectChatEntryText(text: string): string {
@@ -257,6 +306,61 @@ export function projectChatEntryText(text: string): string {
   return text.replace(CHAT_SESSION_WIRE_RE, '$1')
 }
 
+/**
+ * 宿主 `projectUserText` 的**可注入面**（宽类型：本仓库不引用 ui-primitives 的类型，也不 import 它）。
+ * 返回值是不透明 ReactNode（chip 节点等）；缺省 null = 这台宿主没有该能力。
+ */
+export type ChatEntryTextProjector = (
+  text: string,
+  sessionLabels: readonly string[],
+  slashNames: readonly string[],
+  slashKind: string,
+  references?: { openFile?: unknown; openSkill?: unknown },
+) => ReactNode
+
+/** 宿主投影的入参（全部来自节点 data 与 owner props；缺省即空）。 */
+export interface ChatEntryHostTextOptions {
+  /** `data.referenceLabels`（引用会话的 label 列表）。 */
+  sessionLabels?: readonly string[]
+  /** `data.skillNames`（宿主把它们渲染成 chip —— 我们此前一个元素都不产出）。 */
+  skillNames?: readonly string[]
+  /** 宿主给的文件 / 技能打开器（给了才能点开 chip；没有就只显示 chip 外观）。 */
+  openFile?: unknown
+  openSkill?: unknown
+}
+
+/**
+ * 用**宿主自己**的 `projectUserText` 投影正文（2026-10-15：按生态既有做法补齐 G-39 差距①）。
+ *
+ * 实证（为什么这条现在成立）：ui-primitives 由 DSH shell 的模块表作为 static module seed 预置，
+ * 插件 bundle 的 `require` 能命中 —— 第三方插件 dsh-reedit 就是这么拿 `projectUserText` 的，
+ * 本仓的 `RollbackFileIcon` 也早就这样拿 `FileTypeIcon`。**只能帧内惰取**（顶层 import 在老宿主
+ * 会打挂整个浏览器半加载），入口在 `common/host-primitives.ts`。
+ *
+ * 四条判据缺一不可（本函数**绝不抛**，任一条不满足就回 null ⇒ 调用方回落 `projectChatEntryText`）：
+ *  ① 有投影器（老宿主没有原语包 → null）；② 原文非空；
+ *  ③ 投影不抛错；④ 投影返回**非空节点**（null/undefined/false = 宿主拒绝了这段文本）。
+ *
+ * 为什么投影要当参数传进来：纯层与单测都不认识模块表 —— 抽成参数后，上面四条判据能逐条覆盖。
+ */
+export function projectChatEntryTextWithHost(
+  projector: ChatEntryTextProjector | null | undefined,
+  rawText: string,
+  options: ChatEntryHostTextOptions = {},
+): ReactNode | null {
+  if (typeof projector !== 'function') return null
+  if (rawText === '') return null
+  try {
+    const node = projector(rawText, options.sessionLabels ?? [], options.skillNames ?? [], 'skill', {
+      openFile: options.openFile,
+      openSkill: options.openSkill,
+    })
+    return node === null || node === undefined || node === false ? null : node
+  } catch {
+    return null
+  }
+}
+
 /**
  * 扩展名 → 文件卡上的短徽标：宿主 `fileExtension` + 宿主那行 meta 的同一截断
  * （`fileExtension(name).toUpperCase().slice(0, 8)`）；后缀为空（无点 / 点在末尾）回 null。
@@ -310,12 +414,13 @@ export function fileSizeTextOf(bytes: number | null): string | null {
 export function buildChatEntryBubble(content: unknown): ChatEntryBubbleView {
   if (typeof content === 'string') {
     const text = projectChatEntryText(content)
-    return { text, attachments: [], images: [], files: [], raw: [], showBubble: text !== '' }
+    return { text, rawText: content, attachments: [], images: [], files: [], raw: [], showBubble: text !== '' }
   }
   if (!Array.isArray(content)) {
-    return { text: '', attachments: [], images: [], files: [], raw: content === null || content === undefined ? [] : [{ id: '0', payload: content }], showBubble: content !== null && content !== undefined }
+    return { text: '', rawText: '', attachments: [], 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 raw: ChatEntryRawBlock[] = []
   content.forEach((block, index) => {
@@ -323,6 +428,8 @@ export function buildChatEntryBubble(content: unknown): ChatEntryBubbleView {
     const type = record?.['type']
     if (type === 'text' && typeof record?.['text'] === 'string') {
       // 宿主把这条文本交给 projectUserText（会话引用渲染成 chip）；我们做**最小文本投影**：线格式 → label
+      // （rawTexts 同时留一份未投影原文，宿主投影可用时优先用它 —— 见 ChatEntryBubbleView.rawText）
+      rawTexts.push(record['text'] as string)
       texts.push(projectChatEntryText(record['text'] as string))
       return
     }
@@ -347,10 +454,11 @@ export function buildChatEntryBubble(content: unknown): ChatEntryBubbleView {
     raw.push({ id: String(index), payload: block })
   })
   const text = texts.join('')
+  const rawText = rawTexts.join('')
   // 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, attachments, images, files, raw, showBubble: text !== '' || raw.length > 0 }
+  return { text, rawText, attachments, images, files, raw, showBubble: text !== '' || raw.length > 0 }
 }
 
 /** 渲染计划的一项：图片带 owner 载荷，文件带名称/扩展名/体积文本。 */
@@ -517,7 +625,10 @@ export interface ChatEntryView {
   bubble: ChatEntryBubbleView
   /** 动作行的时间文本（null = 节点没给可用的时间戳）。 */
   clock: string | null
-  /** 宿主 data 的另外两个字段（我们**不**接线到 ui-primitives，渲染层如实记成差距）。 */
+  /**
+   * 宿主 data 的另外两个字段：`referenceLabels` 进引用汇总行；两者都作为 `projectUserText`
+   * 的入参传给**宿主的**正文投影（2026-10-15 起 —— 此前它们只是「如实记下的差距」）。
+   */
   referenceLabels: string[]
   skillNames: string[]
 }
@@ -600,6 +711,12 @@ export function rawBlockText(payload: unknown): string {
 /** 错误边界的 ASCII 诊断前缀（console.* 实参不触发 i18n 守卫；界面文案一律在字典里）。 */
 export const CHAT_ENTRY_WARN_PREFIX = '[config-manager] chat user node renderer degraded to plain text: '
 
+/**
+ * 让位告警的 ASCII 前缀（诊断用，绝不当作界面文案）—— 见 `planChatNodeRegistration` 的 `shadowed`：
+ * 别的插件用更低优先级占住了 key=user 时，我们**不注册**（注册也永远轮不到渲染），只留这条日志。
+ */
+export const CHAT_NODE_YIELD_WARN_PREFIX = '[config-manager] chat user node entry yielded: another renderer owns key "user" at a lower priority: '
+
 /* ------------------------------------------------------------ 回滚点惰取（按会话缓存 + 在途去重） */
 
 /** 缓存 TTL：同一会话里的所有按钮共用一次列表读取；跨分钟自然过期（列表变化由宿主写，非热点）。 */

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

@@ -9,11 +9,23 @@
  * （`chat-entry-pref` / `chat-entry-mount`）与回合尾入口（`conversation.chat.turnTail`）一并删除 ——
  * 入口恒为每条用户消息气泡里的那一颗，于是这里不再有偏好门，也不再需要「切档时重新评估」的订阅。
  */
-import { CHAT_NODE_SLOT, planChatNodeRegistration } from './chat-entry-view.ts'
+import {
+  CHAT_NODE_SLOT,
+  CHAT_NODE_YIELD_WARN_PREFIX,
+  chatNodeUserOccupant,
+  planChatNodeRegistration,
+  type ChatNodeOccupant,
+} from './chat-entry-view.ts'
 
-/** 槽位声明形态探测面（`ctx.slots`）：只读 spec，宽类型读回 kind。 */
+/** 槽位探测面（`ctx.slots`）：读声明的 kind，以及该 cell 当前会被渲染的那一条。 */
 export interface ChatNodeSlotProbe {
+  /** 只读 spec（宽类型读回 kind）。 */
   spec: (key: string) => unknown
+  /**
+   * 每个 cell 当前会被渲染的那一条（SlotRegistry.entriesOfSlot）。
+   * **可选**：老宿主没有这个方法（那时不做占用探测，照常注册）。
+   */
+  entriesOfSlot?: (key: string) => unknown
 }
 
 /** 诊断（ASCII，与界面文案无关；console.* 实参不触发 i18n 守卫）。 */
@@ -33,12 +45,24 @@ export function declaredSlotKind(probe: ChatNodeSlotProbe | undefined | null): s
   }
 }
 
+/** user cell 的当前赢家（没有探测面 / 形状不符 / 探测抛错都回 null —— 探测失败不当成「有人占」）。 */
+export function chatNodeOccupantOf(probe: ChatNodeSlotProbe | undefined | null): ChatNodeOccupant | null {
+  if (probe === undefined || probe === null || typeof probe.entriesOfSlot !== 'function') return null
+  try {
+    return chatNodeUserOccupant(probe.entriesOfSlot(CHAT_NODE_SLOT))
+  } catch {
+    return null
+  }
+}
+
 /**
  * 登记「接管 conversation.chat.node / user」的渲染器。
  *
- * 两道门（顺序即优先级）：
+ * 三道门（顺序即优先级）：
  *  ① 声明形态不是 `keyed`（0.1.x 的 ui-chat 契约不同）→ 跳过（按 keyed 参数注册会抛）；
- *  ② 注册本身抛错 → 吞掉并告警（只丢这一个入口）。
+ *  ② **user cell 已被更低优先级占住**（别的插件也在接管用户消息，2026-10-15）→ 让位并如实告警：
+ *     注册也永远轮不到渲染（keyed cell「最低的渲染」），不抢别人的格子、也不静默；
+ *  ③ 注册本身抛错 → 吞掉并告警（只丢这一个入口）。
  *
  * @returns disposer；跳过 / 失败时是 no-op。
  */
@@ -51,8 +75,18 @@ export function registerChatNodeEntry(options: {
 }): () => void {
   const warn = options.warn ?? warnChatNode
   const declared = declaredSlotKind(options.probe)
-  if (planChatNodeRegistration(declared).kind === 'skip') {
-    warn('[config-manager] chat user node entry skipped: slot declaration is ' + (declared === null ? 'missing' : '"' + declared + '"') + ' (expected "keyed")')
+  const plan = planChatNodeRegistration(declared, chatNodeOccupantOf(options.probe))
+  if (plan.kind === 'skip') {
+    if (plan.reason === 'shadowed') {
+      warn(
+        CHAT_NODE_YIELD_WARN_PREFIX +
+          'priority ' + String(plan.occupant.priority) +
+          (plan.occupant.registrant === null ? '' : ' (registered by ' + plan.occupant.registrant + ')') +
+          ' — entry not registered',
+      )
+    } else {
+      warn('[config-manager] chat user node entry skipped: slot declaration is ' + (declared === null ? 'missing' : '"' + declared + '"') + ' (expected "keyed")')
+    }
     return () => {}
   }
   try {

package/src/client/common/DiffTable.tsx

@@ -13,18 +13,20 @@
  *  · 内容栏只在增删行上着色（`.diffCellAdd` / `.diffCellDel`，12% 混色），上下文行不上色；
  *  · 两栏之间一条竖分割线（块头与正文都要有）。
  *
+ * 规模：**全部画出来，不截断**（2026-10-15 用户：「为什么最多只能加载 400 行？我需要能完整的加载」）。
+ * 到这里的 hunks 已经是宿主给的**全部**内容（单文件字节上限在宿主侧：回滚预览 1 MiB、恢复计划 maxSideBytes），
+ * 渲染层再砍一刀只会让同一份数据在界面上少半截，而用户没有任何办法看到剩下的
+ *（2026-10-14 起那道「最多 400 行对」的上限已删除，连文案一起去掉）。
+ *
  * 分工：行对对齐 / 块头 / 行号列宽 / 行数统计全来自 `src/ui/diff-view.ts`（纯函数、node 单测）；本组件只画。
  * 安全：单元格文本是磁盘 / 宿主原文 ⇒ 展示前**必须**过调用方传进来的 sanitize（本该是 redact）。
  */
 import { Fragment } from 'react'
 import { redact } from '../../security/redaction.ts'
-import { countSideRows, diffLineCounts, maxLineDigits, toSideBySide, type SideBySideRow } from '../../ui/diff-view.ts'
+import { diffLineCounts, maxLineDigits, toSideBySide, type SideBySideRow } from '../../ui/diff-view.ts'
 import type { DiffHunk } from '../../utils/line-diff.ts'
 import css from '../config-manager.module.css'
 
-/** 单文件最多渲染多少行对：diff 上限 6000 行，全量渲染会卡住弹窗（数据完整，只是没画出来）。 */
-export const DIFF_ROW_CAP = 400
-
 export interface DiffTableProps {
   hunks: readonly DiffHunk[]
   /** 左侧列头（before = 当前） */
@@ -36,12 +38,8 @@ export interface DiffTableProps {
    * 调用方**已在别处写过这份路径**（恢复计划行、聊天预览的路径行）时**不要传** —— 同一路径不画两遍。
    */
   title?: string
-  /** 被渲染上限截断时的说明文案（由调用方按自己的字典出话；缺省 = 不提示） */
-  truncatedNotice?: (shown: number, total: number) => string
   /** 单元格文本安全化（**缺省就是 redact**：调用方只能换成别的脱敏器，换不成不脱敏） */
   sanitize?: (text: string) => string
-  /** 渲染上限（缺省 DIFF_ROW_CAP） */
-  rowCap?: number
 }
 
 /** 左侧单元格：成对修改 / 纯删除 → 红底；上下文 → 中性。 */
@@ -65,17 +63,13 @@ function rightNoClass(kind: SideBySideRow['kind']): string {
 }
 
 /** 左右双栏逐行对照（文件头 + 表头 + 块头 + 行号 + 单元格）。 */
-export function DiffTable({ hunks, beforeLabel, afterLabel, title, truncatedNotice, sanitize, rowCap = DIFF_ROW_CAP }: DiffTableProps) {
+export function DiffTable({ hunks, beforeLabel, afterLabel, title, sanitize }: DiffTableProps) {
   const cell = sanitize ?? ((text: string): string => redact(text))
   const groups = toSideBySide(hunks)
-  const total = countSideRows(groups)
   const counts = diffLineCounts(hunks)
   // 行号列宽 = 实际出现的最大行号位数（1–3/4/5/6+ 位四档 ch），内容列平分剩余空间
   const digits = maxLineDigits(hunks)
   const noColClass = digits <= 3 ? css.diffNoColW3 : digits === 4 ? css.diffNoColW4 : digits === 5 ? css.diffNoColW5 : css.diffNoColW6
-  let rendered = 0
-  const capped = total > rowCap
-  const notice = capped && truncatedNotice !== undefined ? truncatedNotice(rowCap, total) : null
   return (
     <>
       {title !== undefined && (
@@ -88,7 +82,6 @@ export function DiffTable({ hunks, beforeLabel, afterLabel, title, truncatedNoti
           </span>
         </div>
       )}
-      {notice !== null && <div className={css.hint}>{notice}</div>}
       <div className={css.diffScroll}>
         <table className={css.diffTable}>
           <colgroup>
@@ -104,17 +97,14 @@ export function DiffTable({ hunks, beforeLabel, afterLabel, title, truncatedNoti
             </tr>
           </thead>
           <tbody>
-            {groups.map((group) => {
-              const rows = capped ? group.rows.slice(0, Math.max(0, rowCap - rendered)) : group.rows
-              rendered += rows.length
-              return (
-                <Fragment key={group.header}>
+            {groups.map((group) => (
+              <Fragment key={group.header}>
                   {/* 块头：两栏各一格、同一段文本（编辑器式单文件 diff 的观感），中间那条竖线由 CSS 补 */}
                   <tr className={css.diffHunkRow}>
                     <td colSpan={2}>{group.header}</td>
                     <td colSpan={2}>{group.header}</td>
                   </tr>
-                  {rows.map((row, index) => (
+                  {group.rows.map((row, index) => (
                     <tr key={group.header + '-' + String(index)}>
                       <td className={leftNoClass(row.kind)}>{row.left?.oldNo ?? ''}</td>
                       <td className={leftCellClass(row.kind)}>{row.left === null ? '' : cell(row.left.text)}</td>
@@ -122,9 +112,8 @@ export function DiffTable({ hunks, beforeLabel, afterLabel, title, truncatedNoti
                       <td className={rightCellClass(row.kind)}>{row.right === null ? '' : cell(row.right.text)}</td>
                     </tr>
                   ))}
-                </Fragment>
-              )
-            })}
+              </Fragment>
+            ))}
           </tbody>
         </table>
       </div>