@drscrewdriver/dsh-better-display 0.3.3-fork.1

package/src/client/native/ContextInjectionRow.tsx

@@ -0,0 +1,106 @@
+import { useState } from 'react'
+import type { ContextMessageNode } from '@deepseek-ai/dsh-client-ui-conversation/client'
+import type { TranslateNS } from '@deepseek-ai/dsh-client-ui-slots'
+import { DisclosureRow, IconBrowseOutlineRegular } from '@deepseek-ai/dsh-client-ui-primitives'
+import { ReferenceIcon } from './ReferenceIcon.js'
+import { contextBody } from './ContextBody.js'
+import { toolUpdateRows } from './tool-update.js'
+import css from './ContextInjectionRow.module.css'
+
+/** Props for the logged non-user message presentation. */
+export interface ContextInjectionRowProps {
+  content: ContextMessageNode['content']
+  source: ContextMessageNode['source']
+  /**
+   * Role and producer name projected from the durable source.
+   *
+   * Host generations disagree on the field name: newer builds project
+   * `provenance`, the 0.1.6-alpha generations project `producer`. Both are
+   * optional here and resolved below, so the row renders on either host instead
+   * of throwing on `undefined.role` and degrading its whole block boundary.
+   */
+  provenance?: ContextMessageNode['producer'] | null
+  /** Alpha-generation spelling of {@link provenance}. */
+  producer?: ContextMessageNode['producer'] | null
+  /** Producer-declared information form; null renders the opaque body. */
+  form: ContextMessageNode['form']
+  /** The owning view's locale seat, passed down as a plain prop. */
+  t: TranslateNS<'chat'>
+}
+
+/**
+ * Render logged context with the Tool calls disclosure chrome from Figma.
+ *
+ * The header names the role the context plays and, beside it, the producer the
+ * durable source identifies, so a reader can tell an injected skill catalog
+ * from a workspace instruction file or a recalled session without expanding.
+ * The expanded body follows the producer-declared form; an absent or unknown
+ * form renders the opaque body.
+ * @param props - Durable content, its projected producer role/name and form, and the locale seat.
+ * @returns A collapsed context row with a bounded, form-specific body.
+ */
+export function ContextInjectionRow({ content, source, provenance, producer, form, t }: ContextInjectionRowProps) {
+  const [open, setOpen] = useState(false)
+  // Two host generations, one component. A row whose projection is absent
+  // entirely still renders: the marker falls back to a plain injection.
+  const view = provenance ?? producer ?? { role: 'inject' as const, label: null }
+  // Resolved rather than declared: a form whose fields are unreadable renders
+  // the opaque body, and the marker must say what the row actually shows.
+  const { rendered, summary, body } = contextBody(form, { content, source, t })
+  const tools = toolUpdateRows(content)
+  const toolSummary = tools === null || tools.single !== null ? null
+    : tools.added.length > 0 && tools.removed.length > 0
+      ? t('message.toolsChanged', { added: tools.added.length, removed: tools.removed.length })
+      : tools.added.length > 0
+        ? t('message.toolsAddedCount', { count: tools.added.length })
+        : t('message.toolsRemovedCount', { count: tools.removed.length })
+
+  return (
+    <DisclosureRow
+      className={css.root}
+      icon={view.role === 'recall' && tools === null
+        ? <span data-context-recall-icon><ReferenceIcon kind="session" /></span>
+        : <IconBrowseOutlineRegular size={14} />}
+      chevronClassName={css.chevron}
+      title={tools?.single !== undefined && tools.single !== null
+        ? t(tools.single.type === 'tool-addition' ? 'message.toolAdded' : 'message.toolRemoved', { name: tools.single.toolName })
+        : tools !== null
+          ? t('message.toolsUpdated')
+          : t(view.role === 'recall' ? 'message.contextRecall' : 'message.contextInjection')}
+      collapsedContent={toolSummary !== null ? (
+        <>
+          <span className={css.sep} aria-hidden />
+          <span className={css.summary}>{toolSummary}</span>
+        </>
+      ) : tools !== null || view.label === null ? undefined : (
+        /* ToolRow's separator shape: an aria-hidden dot, so the accessible name
+           stays the two readable parts and the two disclosure rows expose one
+           name shape. A source that names no producer drops the dot with it. */
+        <>
+          <span className={css.sep} aria-hidden />
+          <span className={css.source} data-context-source>{view.label}</span>
+          {summary !== null && (
+            <>
+              <span className={css.sep} aria-hidden />
+              <span className={css.summary} data-context-summary>{summary}</span>
+            </>
+          )}
+        </>
+      )}
+      keepContentWhenOpen
+      open={open && tools?.single == null}
+      expandable={tools?.single == null}
+      expandOnRowClick
+      onToggle={() => { setOpen(value => !value) }}
+    >
+      <div className={css.body} data-context-injection-body data-context-form={rendered ?? undefined}>
+        {tools === null ? body : (
+          <div className={css.toolChanges}>
+            {tools.added.length > 0 && <div>{t('message.toolsAdded', { names: tools.added.join(', ') })}</div>}
+            {tools.removed.length > 0 && <div>{t('message.toolsRemoved', { names: tools.removed.join(', ') })}</div>}
+          </div>
+        )}
+      </div>
+    </DisclosureRow>
+  )
+}

package/src/client/native/ReferenceIcon.tsx

@@ -0,0 +1,35 @@
+import type { ReactNode } from 'react'
+import {
+  IconBrowseOutlineRegular, IconFolderCloseRegular,
+} from '@deepseek-ai/dsh-client-ui-primitives'
+
+/** Reference domains with distinct composer and transcript glyphs. */
+export type ReferenceIconKind = 'session' | 'file' | 'folder'
+
+/** Props shared by inline reference glyphs. */
+export interface ReferenceIconProps {
+  kind: ReferenceIconKind
+  size?: number
+  className?: string | undefined
+}
+
+/**
+ * Render the icon that identifies one inline reference domain.
+ * @param props - Reference kind, optional size, and optional CSS class.
+ * @returns The corresponding current-color SVG glyph.
+ */
+export function ReferenceIcon({ kind, size = 16, className }: ReferenceIconProps): ReactNode {
+  switch (kind) {
+    case 'session':
+      return (
+        <svg width={size} height={size} className={className} viewBox="0 0 16 16" fill="none" aria-hidden>
+          <path
+            d="M8 0.597656C3.91296 0.597656 0.599716 3.91103 0.599609 7.99805C0.599609 9.13171 0.854567 10.2079 1.31152 11.1699L1.59277 11.7607L2.77441 11.1992L2.49414 10.6084L2.36035 10.3076C2.06865 9.59612 1.90723 8.81645 1.90723 7.99805C1.90733 4.63362 4.63554 1.90625 8 1.90625C11.3644 1.90635 14.0917 4.63368 14.0918 7.99805C14.0918 11.3625 11.3644 14.0907 8 14.0908C7.311 14.0908 6.80642 14.0414 6.35938 13.918C5.919 13.7963 5.50105 13.5929 5.00098 13.2441C4.26805 12.7329 3.21756 12.5526 2.35156 13.0996L2.33789 13.1084L2.32422 13.1182L1.74805 13.5234L2.18164 14.8184L3.05957 14.2002C3.37505 14.0068 3.84248 14.0319 4.25195 14.3174C4.84447 14.7307 5.39718 15.009 6.01172 15.1787C6.61963 15.3465 7.25579 15.3984 8 15.3984C12.087 15.3983 15.4004 12.0851 15.4004 7.99805C15.4003 3.9111 12.087 0.59776 8 0.597656ZM4.56836 8.50977V9.80371H8.12402V8.50977H4.56836ZM4.56836 7.30078H11.4619V6.00684H4.56836V7.30078Z"
+            fill="currentColor"
+          />
+        </svg>
+      )
+    case 'file': return <IconBrowseOutlineRegular size={size} className={className} />
+    case 'folder': return <IconFolderCloseRegular size={size} className={className} />
+  }
+}

package/src/client/native/tool-call-model.ts

@@ -0,0 +1,248 @@
+/**
+ * Pure row-model derivation for tool summary rows: variant classification,
+ * one-line summary, expanded-body text, and flattened result output from the
+ * frozen call slice. Input material comes from the call ARGUMENTS; output and
+ * error material from the settled result node. A call whose render intent is
+ * a terminal card gets its expanded body from the views instead, through
+ * `terminalCardModel` in terminal-card-model.ts.
+ */
+// The block union's defining home is runtime (fold-product types); this
+// contract only forwards it (type-definition authority stays with the layer
+// that produces the values).
+import { abbreviateHomePath } from '@deepseek-ai/dsh-util-workspace-path'
+import type { ToolCallBlock, ToolResultNode } from '@deepseek-ai/dsh-client-ui-conversation/client'
+
+export type { ToolCallBlock } from '@deepseek-ai/dsh-client-ui-conversation/client'
+
+/** Tool-call row variants selected by the generic atomic renderer. */
+export type ToolRowVariant = 'search' | 'read' | 'bash' | 'write' | 'edit' | 'code' | 'others'
+
+/** Row state semantic; colors self-supplied via StateDot (design gives none). */
+export type ToolRowState = 'running' | 'ok' | 'error' | 'stopped'
+
+/** Figma row titles per variant (design literals, not translatable copy). */
+export const VARIANT_TITLES: Record<ToolRowVariant, string> = {
+  search: 'Search', read: 'Read', bash: 'Bash',
+  write: 'Write', edit: 'Edit', code: 'Code', others: 'Tool call',
+}
+
+/**
+ * Known tool name -> variant.
+ *
+ * `cordis_define` is deliberately absent: ui-cordis registers a keyed
+ * `tool.call.toolview` entry for it, and a keyed hit REPLACES the generic row
+ * (this table is only reached through GenericToolCard, the dispatch fallback in
+ * ToolCallTree). An entry here would be unreachable, and a second title for the
+ * same call would be a second answer to a question the card already owns.
+ */
+const TOOL_VARIANTS: Record<string, ToolRowVariant> = {
+  bash: 'bash',
+  // The PowerShell twin is a shell tool: the bash row family (icon, colors)
+  // with its own title from TOOL_TITLES, not the generic `others` row.
+  pwsh: 'bash',
+  read: 'read',
+  web_fetch: 'read',
+  web_search: 'search',
+  grep: 'search',
+  glob: 'search',
+  write: 'write',
+  edit: 'edit',
+  run_code: 'code',
+  cordis_package_inspect: 'read',
+  cordis_runtime_inspect: 'read',
+  // The three run-control verbs take one package id and produce a receipt, so
+  // the generic row is the decided intent, not an unclassified default: there is
+  // no program to show (that is `cordis_define`'s card) and no file to open. The
+  // id lands in the summary slot, and the titles below name the act.
+  cordis_run: 'others',
+  cordis_stop: 'others',
+  cordis_undefine: 'others',
+}
+
+/** Tool-owned titles that refine a generic row variant without replacing it. */
+const TOOL_TITLES: Record<string, string> = {
+  cordis_package_inspect: 'Inspect',
+  cordis_runtime_inspect: 'Inspect',
+  cordis_run: 'Run Cordis Plugin',
+  cordis_stop: 'Stop Cordis Plugin',
+  cordis_undefine: 'Remove Cordis Plugin',
+  pwsh: 'Pwsh',
+}
+
+/**
+ * Classify a tool name into its row variant.
+ * @param toolName - wire tool name.
+ * @returns matching variant, others when unknown.
+ */
+export function classifyTool(toolName: string): ToolRowVariant {
+  return TOOL_VARIANTS[toolName] ?? 'others'
+}
+
+/** Everything ToolRow needs, derived once from the frozen slice. */
+export interface ToolRowModel {
+  variant: ToolRowVariant
+  title: string
+  summary: string
+  /**
+   * Filesystem path from args (`path` / `file_path`) when the row is a file
+   * tool; absent for URL reads and non-file tools. The chat view resolves
+   * relative values against the session cwd before opening.
+   */
+  filePath: string | undefined
+  /** Expanded-body input text (pretty args); null = no input section. */
+  body: string | null
+  /** Flattened result text ({@link resultText}); null while running or when the result carries no text. */
+  output: string | null
+  /** First line of the result text on an error row; null for every other state. */
+  errorSummary: string | null
+  state: ToolRowState
+}
+
+/**
+ * Flatten a settled result's content blocks to display text: text blocks
+ * verbatim, other block shapes as pretty JSON. Empty content on a failed call
+ * falls back to the structured error's `name: code` line.
+ * @param node - the settled result node.
+ * @returns the flattened result text (may be empty).
+ */
+export function resultText(node: ToolResultNode): string {
+  const parts: string[] = []
+  for (const block of node.content) {
+    if (block.type === 'text') parts.push(block.text)
+    else parts.push(JSON.stringify(block, null, 2))
+  }
+  if (parts.length === 0 && node.error !== undefined) {
+    parts.push(`${node.error.name}: ${node.error.code}`)
+  }
+  return parts.join('\n')
+}
+
+function parseArgs(argsRaw: string): unknown {
+  try {
+    return JSON.parse(argsRaw)
+  } catch {
+    // Non-JSON args (mid-stream truncation): summary/body fall back to the raw string.
+    return undefined
+  }
+}
+
+function firstLine(text: string): string {
+  const nl = text.indexOf('\n')
+  return nl === -1 ? text : text.slice(0, nl)
+}
+
+function pickString(args: Record<string, unknown>, keys: readonly string[]): string | undefined {
+  for (const key of keys) {
+    const v = args[key]
+    if (typeof v === 'string' && v !== '') return v
+  }
+  return undefined
+}
+
+/** Summary key preference per variant (args-derived; result-derived summaries are a ledger item). */
+const SUMMARY_KEYS: Record<ToolRowVariant, readonly string[]> = {
+  bash: ['description', 'command'],
+  read: ['path', 'file_path', 'url'],
+  search: ['query', 'pattern', 'url'],
+  write: ['path', 'file_path'],
+  edit: ['path', 'file_path'],
+  code: ['description'],
+  others: [],
+}
+
+/**
+ * Strip the workspace root from a workspace-rooted absolute path (display only).
+ * @param text - the path to shorten.
+ * @param cwd - session workspace root; absent or empty leaves the path unchanged.
+ * @returns the path relative to the workspace root, or unchanged when it is not rooted there.
+ */
+export function relativizeToCwd(text: string, cwd: string | undefined): string {
+  if (cwd === undefined || cwd === '') return text
+  const root = cwd.replace(/[/\\]+$/, '')
+  if (text.startsWith(`${root}/`) || text.startsWith(`${root}\\`)) return text.slice(root.length + 1)
+  return text
+}
+
+function deriveSummary(variant: ToolRowVariant, argsRaw: string): string {
+  const parsed = parseArgs(argsRaw)
+  if (typeof parsed !== 'object' || parsed === null) return firstLine(argsRaw)
+  const args = parsed as Record<string, unknown>
+  if (variant === 'search' && Array.isArray(args.queries)) {
+    const queries = args.queries.filter((query): query is string => typeof query === 'string' && query !== '')
+    if (queries.length > 0) return queries.map(firstLine).join(', ')
+  }
+  const picked = pickString(args, SUMMARY_KEYS[variant])
+  if (picked !== undefined) return firstLine(picked)
+  for (const v of Object.values(args)) {
+    if (typeof v === 'string' && v !== '') return firstLine(v)
+  }
+  return firstLine(argsRaw)
+}
+
+/** Path keys only — never `url` (web_fetch lands on the read variant). */
+const FILE_PATH_KEYS = ['path', 'file_path'] as const
+
+/** File-tool variants whose summary may be an openable workspace path. */
+const FILE_PATH_VARIANTS: ReadonlySet<ToolRowVariant> = new Set(['read', 'write', 'edit'])
+
+function deriveFilePath(variant: ToolRowVariant, argsRaw: string): string | undefined {
+  if (!FILE_PATH_VARIANTS.has(variant)) return undefined
+  const parsed = parseArgs(argsRaw)
+  if (typeof parsed !== 'object' || parsed === null) return undefined
+  const picked = pickString(parsed as Record<string, unknown>, FILE_PATH_KEYS)
+  return picked === undefined ? undefined : firstLine(picked)
+}
+
+function deriveBody(variant: ToolRowVariant, argsRaw: string): string | null {
+  if (argsRaw === '') return null
+  const parsed = parseArgs(argsRaw)
+  if (parsed === undefined) return argsRaw
+  // The code row's expanded body IS the program (monospace via the row's
+  // variant styling), not the args JSON envelope around it.
+  if (variant === 'code' && typeof parsed === 'object' && parsed !== null) {
+    const code = (parsed as Record<string, unknown>).code
+    if (typeof code === 'string' && code !== '') return code
+  }
+  return JSON.stringify(parsed, null, 2)
+}
+
+/**
+ * Derive the full row model from a frozen call slice.
+ * @param toolName - wire tool name (dispatch-supplied; survives windowless results).
+ * @param block - RunningToolCall or ToolResultNode off the snapshot caches.
+ * @param cwd - session workspace root; workspace-rooted path summaries display relative to it.
+ * @param home - host account home; a leftover POSIX home path displays as `~`.
+ * @returns the row model.
+ */
+export function toolRowModel(toolName: string, block: ToolCallBlock, cwd?: string, home?: string): ToolRowModel {
+  const variant = classifyTool(toolName)
+  const done = 'kind' in block
+  const argsRaw = (done ? block.call?.argsRaw : ('argsRaw' in block ? block.argsRaw : '')) ?? ''
+  const state: ToolRowState = !done ? 'running'
+    : block.error?.code === 'interrupted' ? 'stopped'
+      : block.isError ? 'error' : 'ok'
+  const base = argsRaw === ''
+    ? block.callId
+    : abbreviateHomePath(relativizeToCwd(deriveSummary(variant, argsRaw), cwd), home)
+  const toolTitle = TOOL_TITLES[toolName]
+  // Others keeps the static "Tool call" title (figma literal); the real tool
+  // name rides the mutable summary slot unless the tool owns a specific title.
+  const summary = variant === 'others' && toolName !== '' && toolTitle === undefined
+    ? `${toolName} · ${base}`
+    : base
+  // The empty string is "no text" for both derived result fields: a settled
+  // call with blank content has nothing to expand, and a blank first line
+  // would erase the collapsed error row's summary slot.
+  const output = done ? (resultText(block) || null) : null
+  const errorSummary = state === 'error' && output !== null ? firstLine(output) : null
+  return {
+    variant,
+    title: toolTitle ?? VARIANT_TITLES[variant],
+    summary,
+    filePath: deriveFilePath(variant, argsRaw),
+    body: deriveBody(variant, argsRaw),
+    output,
+    errorSummary,
+    state,
+  }
+}

package/src/client/native/tool-update.ts

@@ -0,0 +1,32 @@
+/** One developer tool-change block the 0.1.7-rc.2 context row names in place. */
+export interface ToolChangeBlock {
+  type: 'tool-addition' | 'tool-removal'
+  toolName: string
+}
+
+/** Names collected from a context whose every block is a tool change. */
+export interface ToolUpdateRows {
+  added: readonly string[]
+  removed: readonly string[]
+  /** The only block, when the row is a single add or removal. */
+  single: ToolChangeBlock | null
+}
+
+/**
+ * Classify a context as the rc.2 tool-update row.
+ * Mixed or empty content stays on the generic injection presentation.
+ * @param content - durable context blocks.
+ * @returns collected names, or null when any block is not a tool change.
+ */
+export function toolUpdateRows(content: readonly { readonly type: string; readonly toolName?: string }[]): ToolUpdateRows | null {
+  if (content.length === 0) return null
+  const rows: ToolChangeBlock[] = []
+  for (const block of content) {
+    if (block.type !== 'tool-addition' && block.type !== 'tool-removal') return null
+    if (typeof block.toolName !== 'string') return null
+    rows.push({ type: block.type, toolName: block.toolName })
+  }
+  const added = rows.flatMap(row => row.type === 'tool-addition' ? [row.toolName] : [])
+  const removed = rows.flatMap(row => row.type === 'tool-removal' ? [row.toolName] : [])
+  return { added, removed, single: rows.length === 1 ? rows[0]! : null }
+}

package/src/client/native/upstream.json

@@ -0,0 +1,41 @@
+{
+  "repository": "DeepSeek Harness",
+  "commit": "b150a551b8d465e31e418e1b2eaf5e79bbb7d28e",
+  "adaptations": [
+    "Public type import in place of private type-only path",
+    "ESM .js import suffixes",
+    "Local ReferenceIcon location"
+  ],
+  "files": [
+    {
+      "source": "packages/client/ui-conversation/src/client/chat/ContextInjectionRow.tsx",
+      "output": "ContextInjectionRow.tsx",
+      "sha256": "afb41e6285f2abaf0eb6a1f843dbc135c8480bd48848beed1f94e395ac0f68c8"
+    },
+    {
+      "source": "packages/client/ui-conversation/src/client/chat/ContextInjectionRow.module.css",
+      "output": "ContextInjectionRow.module.css",
+      "sha256": "af61636789223d2476ec818a76d795bc7c13ca1a433f834d78702a825bd000de"
+    },
+    {
+      "source": "packages/client/ui-conversation/src/client/chat/ContextBody.tsx",
+      "output": "ContextBody.tsx",
+      "sha256": "94f41356d59bdcdae7225f3cb8cd9b0c0b1a32d24153d82512bfba7c40443cc8"
+    },
+    {
+      "source": "packages/client/ui-conversation/src/client/chat/ContextBody.module.css",
+      "output": "ContextBody.module.css",
+      "sha256": "b3838bf9cf38af53b31fd6333b4766ad063024d9a59cd636a38e3e0e07d7bf61"
+    },
+    {
+      "source": "packages/client/ui-conversation/src/client/reference/ReferenceIcon.tsx",
+      "output": "ReferenceIcon.tsx",
+      "sha256": "6315cb1ceafa830cd9e38ce296ddf5791ab93562e4f5a7bdbda1ef9ac6f7ed57"
+    },
+    {
+      "source": "packages/client/ui-tool/src/client/tool/models/tool-call-model.ts",
+      "output": "tool-call-model.ts",
+      "sha256": "02536cb0be80168351857083d0f0b71554216cd3195bad8016b1e4bb567acc7f"
+    }
+  ]
+}

package/src/client/official-slots.tsx

@@ -0,0 +1,211 @@
+import { createElement, memo, useMemo, type ComponentType, type ReactNode } from 'react';
+import type { Context } from '@deepseek-ai/cordis';
+import type { SlotEntryDef, SlotMap, SlotSpec, StoredEntry } from '@deepseek-ai/dsh-client-ui-slots';
+import type {} from '@deepseek-ai/dsh-client-ui-renderer/client';
+
+/**
+ * RC2 composition adapter. Only public registry operations are used. We lend
+ * registrations a Reader-owned seat, not a second implementation of their UI.
+ * The platform still binds injection, hooks, locale, stores and boundaries.
+ * Original entries, declarations and components are never changed.
+ *
+ * Child seats have unique names because RC2 declarations have one owner. The
+ * sole component wrapper translates those names before delegating to the
+ * framework-provided renderSlot. It does not implement a slot renderer.
+ */
+export const OFFICIAL_SLOTS = {
+  actions: 'conversation.chat.assistant-actions',
+  tools: 'tool.call.toolview',
+  tail: 'conversation.chat.turnTail',
+  nodes: 'conversation.chat.node',
+  images: 'conversation.message.images',
+} as const;
+export type OfficialFamily = keyof typeof OFFICIAL_SLOTS;
+export const OFFICIAL_SEATS = {
+  actions: 'dsh-better-display.official.actions/conversation.chat.assistant-actions',
+  tools: 'dsh-better-display.official.tools/tool.call.toolview',
+  tail: 'dsh-better-display.official.tail/conversation.chat.turnTail',
+  nodes: 'dsh-better-display.official.nodes/conversation.chat.node',
+  images: 'dsh-better-display.official.images/conversation.message.images',
+} as const;
+export type OfficialSeat = typeof OFFICIAL_SEATS[OfficialFamily];
+export const officialSeat = (family: OfficialFamily, source: string = OFFICIAL_SLOTS[family]) =>
+  `dsh-better-display.official.${family}/${source}`;
+
+type Spec = SlotSpec<SlotEntryDef>;
+type Render = (key: string, owner: object, options?: object) => ReactNode;
+type RenderProps = { renderSlot: Render; renderSlotChain?: Render } & Record<string, unknown>;
+type Registration = StoredEntry['options'] & Omit<StoredEntry, 'options' | 'component'> & { name: string };
+
+/** The documented, type-erased registry inspection/registration boundary. */
+export interface CompositionRegistry {
+  spec(key: string): Spec | undefined;
+  entriesOfSlot(key: string): readonly StoredEntry[];
+  subscribe(key: string, listener: () => void): () => void;
+  inject(key: string, effect: () => () => void): () => void;
+  register(options: Registration, component: unknown): () => void;
+}
+
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+  interface SlotMap {
+    'dsh-better-display.official.actions/conversation.chat.assistant-actions': SlotMap['conversation.chat.assistant-actions'];
+    'dsh-better-display.official.tools/tool.call.toolview': SlotMap['tool.call.toolview'];
+    'dsh-better-display.official.tail/conversation.chat.turnTail': SlotMap['conversation.chat.turnTail'];
+    'dsh-better-display.official.nodes/conversation.chat.node': SlotMap['conversation.chat.node'];
+    'dsh-better-display.official.images/conversation.message.images': SlotMap['conversation.message.images'];
+  }
+}
+
+// Existing Reader presentations own these rows. All other node kinds, including
+// future registrations, reach the official renderer through the fallback seat.
+const READER_NODES = new Set(['user', 'steering', 'assistant-step', 'tool-call', 'turn-tail', 'turn-process']);
+const EXPECTED: Record<OfficialFamily, Spec> = {
+  actions: { kind: 'list', scope: 'session' },
+  tools: { kind: 'keyed', scope: 'session' },
+  tail: { kind: 'list', scope: 'session' },
+  nodes: { kind: 'keyed', scope: 'session' },
+  images: { kind: 'single', scope: 'session' },
+};
+
+/**
+ * Reader already presents produced paths with its copy/reveal actions. RC2's
+ * official tail additionally owns explicit `present` artifacts. Leave those
+ * cards, actions and state intact, and omit only the duplicate produced chips.
+ * This changes a presentation prop, never the source match or session data.
+ * Unrecognized shapes pass through intact for safe forward degradation.
+ */
+export function readerTailMatch(value: unknown, displayedPaths?: readonly string[]): unknown {
+  if (!value || typeof value !== 'object') return value;
+  const match = value as Record<string, unknown>;
+  const displayed = new Set(displayedPaths ?? []);
+  return displayed.size > 0 && Array.isArray(match.produced) && Array.isArray(match.presented)
+    ? { ...match, produced: match.produced.filter(path => !displayed.has(path)) }
+    : value;
+}
+
+function tailPresentation(component: unknown) {
+  const Original = component as ComponentType<Record<string, unknown>>;
+  return memo(function ReaderTailPresentation(props: Record<string, unknown>) {
+    const matched = useMemo(() => readerTailMatch(props.matched, props.readerProducedPaths as readonly string[] | undefined), [props.matched, props.readerProducedPaths]);
+    return createElement(Original, { ...props, matched });
+  });
+}
+
+export function officialChildren(slots: Pick<CompositionRegistry, 'spec'>): { [K in OfficialSeat]: SlotSpec<SlotMap[K]> } {
+  return Object.fromEntries(Object.entries(OFFICIAL_SLOTS).map(([name, source]) => {
+    const family = name as OfficialFamily;
+    const spec = slots.spec(source);
+    if (spec && (spec.kind !== EXPECTED[family].kind || spec.scope !== EXPECTED[family].scope)) {
+      throw new Error(`Official slot contract changed: ${source} (${spec.kind}/${spec.scope})`);
+    }
+    // In particular, retain conversation.chat.node's contextual turn-data hook.
+    return [officialSeat(family), spec ?? EXPECTED[family]];
+  })) as { [K in OfficialSeat]: SlotSpec<SlotMap[K]> };
+}
+
+function translatedComponent(entry: StoredEntry, names: ReadonlyMap<string, string>) {
+  if (names.size === 0) return entry.component;
+  const Original = entry.component as ComponentType<Record<string, unknown>>;
+  return memo(function OfficialSlotChildren(props: RenderProps) {
+    const renders = useMemo(() => {
+      const translate = (render: Render | undefined): Render => (key, owner, options) => {
+        const seat = names.get(key);
+        if (!seat || !render) throw new Error(`Undeclared official child slot: ${key}`);
+        return render(seat, owner, options);
+      };
+      return {
+        renderSlot: translate(props.renderSlot),
+        ...(props.renderSlotChain ? { renderSlotChain: translate(props.renderSlotChain) } : {}),
+      };
+    }, [props.renderSlot, props.renderSlotChain]);
+    return createElement(Original, { ...props, ...renders });
+  });
+}
+
+/**
+ * Mirror one elected contribution set incrementally. Unrelated additions do not
+ * remount existing cards or recreate their subscriptions. A source unload/HMR
+ * disposes the corresponding subtree and closures before its replacement.
+ */
+export function mirrorOfficialSlot(
+  slots: CompositionRegistry,
+  source: string,
+  target: string,
+  namespace: string,
+  accept: (entry: StoredEntry) => boolean = () => true,
+): () => void {
+  const mounted = new Map<StoredEntry, () => void>();
+  let stopped = false;
+  const reconcile = () => {
+    if (stopped) return;
+    const entries = slots.entriesOfSlot(source).filter(accept);
+    const wanted = new Set(entries);
+    for (const [entry, dispose] of mounted) {
+      if (wanted.has(entry)) continue;
+      dispose();
+      mounted.delete(entry);
+    }
+    for (const entry of entries) {
+      if (mounted.has(entry)) continue;
+      const names = new Map(Object.keys(entry.children ?? {}).map(key => [key, `${namespace}/${key}`]));
+      const children = Object.fromEntries([...names].map(([key, seat]) => [seat, entry.children![key]]));
+      const disposers: (() => void)[] = [];
+      const dispose = () => { for (const stop of disposers.splice(0).reverse()) stop(); };
+      try {
+        const { component: _component, options, children: _children, ...metadata } = entry;
+        const presentation = source === OFFICIAL_SLOTS.tail && entry.locale === 'deliverables'
+          ? { ...entry, component: tailPresentation(entry.component) }
+          : entry;
+        disposers.push(slots.register({
+          ...options, ...metadata, name: target,
+          ...(names.size ? { children } : {}),
+          registrant: `dsh-better-display → ${entry.registrant ?? source}`,
+        }, translatedComponent(presentation, names)));
+        for (const [key, seat] of names) {
+          disposers.push(mirrorOfficialSlot(slots, key, seat, namespace));
+        }
+        mounted.set(entry, dispose);
+      } catch (error) {
+        dispose();
+        throw error;
+      }
+    }
+  };
+  const unsubscribe = slots.subscribe(source, reconcile);
+  const dispose = () => {
+    stopped = true;
+    unsubscribe();
+    for (const stop of [...mounted.values()].reverse()) stop();
+    mounted.clear();
+  };
+  try { reconcile(); } catch (error) { dispose(); throw error; }
+  return dispose;
+}
+
+export function installOfficialSlots(ctx: Context): () => void {
+  // The SlotMap overloads are for statically declared keys. Aliases are a
+  // runtime composition, using exactly the public erased metadata contract.
+  const slots = ctx.slots as unknown as CompositionRegistry;
+  const disposers: (() => void)[] = [];
+  try {
+    for (const [name, source] of Object.entries(OFFICIAL_SLOTS)) {
+      const family = name as OfficialFamily;
+      disposers.push(slots.inject(source, () => {
+        const spec = slots.spec(source)!;
+        const target = officialSeat(family);
+        const declared = slots.spec(target);
+        if (spec.kind !== declared?.kind || spec.scope !== declared.scope) {
+          throw new Error(`Official slot contract changed: ${source}`);
+        }
+        return mirrorOfficialSlot(slots, source, target, `dsh-better-display.official.${family}`,
+          family === 'nodes' ? entry => !READER_NODES.has(entry.options.key ?? '') : undefined);
+      }));
+    }
+  } catch (error) {
+    for (const stop of disposers.reverse()) stop();
+    throw error;
+  }
+  return () => { for (const stop of disposers.splice(0).reverse()) stop(); };
+}
+
+export type OfficialSlotKey = typeof OFFICIAL_SLOTS[OfficialFamily] & keyof SlotMap;