dsh-config-manager 0.1.72 → 0.1.76

package/src/client/chat/RollbackFileIcon.tsx

@@ -9,56 +9,18 @@
  *  ② **DSH 自带**：`@deepseek-ai/dsh-client-ui-primitives` 的 `FileTypeIcon` —— 这正是 DSH 左侧文件树
  *     （`dsh-client-ui-sidebar-files` 的 FilesBody）逐字使用的那颗组件（同一份按类型着色的画集）。
  *
- * ## 为什么这里是「惰取 + try/catch」而不是顶层 import（**关键**）
- * 该包由 DSH shell 的模块表作为 **static module seed** 预置（`dsh-web-frontend` 的 `staticModules`
- * 里就有它），插件 bundle 的 `require` 能直接命中 —— 第三方插件 dsh-better-sidebar 走的就是这条路。
- * 但那是**较新宿主**才有的模块表：老宿主加载本插件时 `require` 会抛（missed the module table）。
- * 顶层 `import` 会被打包器改写成**模块体顶层**的 `require`，那一刻抛错会让**整个浏览器半加载失败**
- * （设置页一起没）—— 为了「一颗图标」赔掉整插件，绝不。所以这里：
- *  · 只在**真要画 icon 时**才 require（帧内），
- *  · 拿不到 / 形态不符 / 抛错一律回落一颗**极简的本地 SVG 文件图标**（`fallbackFileGlyph`），
- *    既不打挂任何东西，也不空着。
- * 该包因此不进 bundle：源码里只有 `require` 调用（bundle 白名单在 src/utils/bundle-scan.ts 登记）。
+ * ## 惰取门在 `common/host-primitives.ts`（2026-10-15 抽出）
+ * 那颗「帧内惰取 + try/catch + 三态缓存」的门改为全仓唯一出口（同一份门现在也供聊天气泡的
+ * 正文投影使用）——本文件只保留**两级回落**：外部来源（better-sidebar）→ 宿主 FileTypeIcon
+ * → 本地极简 SVG。为什么不能顶层 import、为什么必须帧内取，见那个文件的头注释。
  */
-import type { ComponentType, ReactNode } from 'react'
+import type { ReactNode } from 'react'
 import { Icon } from '../common/Icon.tsx'
+import { hostFileTypeIcon } from '../common/host-primitives.ts'
 
 /** 装配点注入的「外部图标来源」（dsh-better-sidebar 的 `fileIcon`）；返回 null = 它不认这一条。 */
 export type RollbackFileIconRenderer = (path: string) => ReactNode | null
 
-/** `FileTypeIcon` 我们真的用到的入参面（只声明消费的字段，不复制第三方类型）。 */
-interface DshFileTypeIconProps {
-  path: string
-  size?: number
-  className?: string
-}
-
-/** 惰取结果的三态缓存（undefined = 还没试过；null = 试过了，这台宿主没有）。 */
-let cachedDshFileTypeIcon: ComponentType<DshFileTypeIconProps> | null | undefined
-
-/**
- * 惰取 DSH 自带的 `FileTypeIcon`（**每次进程只试一次**，失败就记 null 不再重试）。
- *
- * 为什么不用 `import()`：动态 import 在 cjs 产物里同样要走模块表，且会把整个包拖进 chunk；
- * 这里的 `require` 是 DSH loader 交给插件工厂的那一个（banner 里 `factory: (require) => {...}`）。
- */
-function dshFileTypeIcon(): ComponentType<DshFileTypeIconProps> | null {
-  if (cachedDshFileTypeIcon !== undefined) return cachedDshFileTypeIcon
-  cachedDshFileTypeIcon = null
-  try {
-    const loaded = (typeof require === 'function' ? require('@deepseek-ai/dsh-client-ui-primitives') : null) as
-      | { FileTypeIcon?: unknown }
-      | null
-    const icon = loaded?.FileTypeIcon
-    if (typeof icon === 'function' || typeof icon === 'object') {
-      cachedDshFileTypeIcon = icon as ComponentType<DshFileTypeIconProps>
-    }
-  } catch {
-    cachedDshFileTypeIcon = null
-  }
-  return cachedDshFileTypeIcon
-}
-
 /**
  * 最后的兜底：共享图标原语的通用「文件」图标（`common/Icon.tsx` 的 `name="file"`）。
  * 只有「没有 better-sidebar + 宿主模块表里没有 ui-primitives」两条同时成立时才会出现 ——
@@ -90,7 +52,7 @@ export function RollbackFileIcon({ path, size = 14, render }: RollbackFileIconPr
     // null / undefined / false = 这一条外部来源接不住 ⇒ 回落 DSH 自带画法（不猜、不空着）
     if (node !== null && node !== undefined && node !== false) return <>{node}</>
   }
-  const Dsh = dshFileTypeIcon()
+  const Dsh = hostFileTypeIcon()
   if (Dsh !== null) return <Dsh path={path} size={size} />
   return fallbackFileGlyph(size)
 }

package/src/client/chat/RollbackReviewDialog.tsx

@@ -34,7 +34,7 @@
 import { useEffect, useRef, useState } from 'react'
 import * as Dialog from '@radix-ui/react-dialog'
 import type { TranslateNS } from '../client-types.ts'
-import { rollbackPreviewScope } from '../../ui/rollback-view.ts'
+import { rollbackPreviewScope, rollbackSkippedSegments } from '../../ui/rollback-view.ts'
 import type {
   RollbackPointPort,
   RollbackPreviewResult,
@@ -321,6 +321,12 @@ export function RollbackReviewDialog({ sessionId, turn, port, rt, t, openChildSe
   /** 选择框（第 1 条）当前是否「连文件一起退」以及它能不能被点。 */
   const revertFiles = revertFilesOn(draft)
   const revertFilesEnabled = canRevertFiles(preview)
+  /**
+   * 被跳过的段（C3）：工作区段不可用时引擎会跳过它、结果为 partial —— 同一份事实在设置页会
+   * 渲染（RollbackCard 的 `rollback.rewind.result.skipped`），聊天侧此前只说「部分恢复 / 恢复 0 项」，
+   * 没人告诉用户**文件一个都没退、以及为什么**。判据与设置页同源（rollbackSkippedSegments）。
+   */
+  const skippedSegments = rollbackSkippedSegments(result)
   /**
    * t8：这条对话此刻正在运行（引擎 preview 的 `session.active`）。运行中时：
    *  · 默认档 = 只回溯消息（`defaultDraft`）；· 文件开关禁用（`canRevertFiles`）；
@@ -393,7 +399,9 @@ export function RollbackReviewDialog({ sessionId, turn, port, rt, t, openChildSe
                     工作区态没有可用记录时**禁用**（那时没有文件可退，开关点了也没有区别）。 */}
                 <div className={css.previewChoiceRow}>
                   <Checkbox
-                    checked={revertFiles}
+                    // 工作区段不可用时显示为**未勾选**（C4）：勾着却禁用会让人以为「文件会退、只是改不了」，
+                    // 而实际提交的 workspace 段会被引擎跳过 —— 勾选态必须与真的会发生的事一致。
+                    checked={revertFiles && revertFilesEnabled}
                     disabled={busy || !revertFilesEnabled}
                     onChange={(next) => { setDraft((previous) => setRevertFiles(previous, next) ?? previous) }}
                     label={t('chat.preview.revertFiles')}
@@ -455,8 +463,8 @@ export function RollbackReviewDialog({ sessionId, turn, port, rt, t, openChildSe
                     {inlineDiff !== null && (
                       <div className={css.inlineDiffBox}>
                         {inlineNotice !== null && <div className={css.hint}>{inlineNotice}</div>}
-                        <div className={`${css.hint} ${css.mono}`}>{inlineDiff.path}</div>
-                        <RollbackDiffPane state={inlineDiff.state} rt={rt} />
+                        {/* 路径由差异表的文件头承载（.diffFileHead）：这里不再画第二遍 */}
+                        <RollbackDiffPane state={inlineDiff.state} rt={rt} title={inlineDiff.path} />
                       </div>
                     )}
                   </>
@@ -516,6 +524,14 @@ export function RollbackReviewDialog({ sessionId, turn, port, rt, t, openChildSe
                   </div>
                 )}
 
+                {/* ⑤b 被跳过的段（C3）：**部分恢复时最该说的一句** —— 哪一段没做。
+                    键与设置页共用（同一条事实只有一处文案）。 */}
+                {skippedSegments.length > 0 && (
+                  <div className={css.hint}>
+                    {rt('rollback.rewind.result.skipped', { list: skippedSegments.map((row) => rt(rk(row.key))).join(' / ') })}
+                  </div>
+                )}
+
                 {/* ⑥ fork 出来的子会话（有才显示；自动打开失败如实降级） */}
                 {childId !== null && (
                   <div className={css.statRow}>

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/chat/chat-point-window.ts

@@ -119,11 +119,16 @@ export class ChatPointWindowController {
   private current: ChatPointWindowState = { lookup: null, open: false }
   private started = false
   private cancelled = false
+  /** 默认排程器留下的待触发定时器（≤12 s）；dispose 清掉，避免悬空 timer 与晚到的回调 */
+  private pendingTimer: ReturnType<typeof setTimeout> | null = null
 
   constructor(options: ChatPointWindowOptions) {
     // 参数属性（`constructor(private readonly x)`）会产出运行期语法，erasableSyntaxOnly 下不允许 —— 显式赋值
     this.options = options
-    this.schedule = options.retry ?? ((fn: () => void, delayMs: number) => { setTimeout(fn, delayMs) })
+    // 默认排程器把句柄留下来，dispose 时清掉（注入的 retry 由调用方自理）
+    this.schedule = options.retry ?? ((fn: () => void, delayMs: number) => {
+      this.pendingTimer = setTimeout(() => { this.pendingTimer = null; fn() }, delayMs)
+    })
   }
 
   /** 当前状态（与最后一次 onState 回调同形）。 */
@@ -141,6 +146,11 @@ export class ChatPointWindowController {
    */
   dispose(): void {
     this.cancelled = true
+    // 取消后**不再需要任何晚到的回调**：默认排程器的定时器一并清掉（注入的 retry 由调用方负责）
+    if (this.pendingTimer !== null) {
+      clearTimeout(this.pendingTimer)
+      this.pendingTimer = null
+    }
     this.current = { lookup: this.current.lookup, open: false }
   }