dsh-better-display 0.3.6 → 0.3.8

package/src/client/ToolActivity.tsx

@@ -17,6 +17,7 @@ import css from './Reader.module.css';
 const LABEL: Record<ToolPhase, string> = { preparing: '输入生成中', running: '执行中', returned: '已返回', succeeded: '已完成', failed: '失败', interrupted: '已中断' };
 const ICONS = { write: IconEditOutlineRegular, read: IconBrowseOutlineRegular, terminal: IconApiOutlineRegular, search: IconSearchOutlineRegular, web: IconSearchOutlineRegular, code: IconApiOutlineRegular, other: IconSparkleRegular } satisfies Record<ToolCategory, unknown>;
 const number = new Intl.NumberFormat('zh-CN');
+const preparingTerminalLabels = { ...terminalBlockLabels, running: '正在生成命令' };
 const language = (path: string | undefined) => path?.split('.').at(-1);
 const duration = (ms: number) => ms < 1000 ? `${Math.round(ms)} 毫秒` : `${(ms / 1000).toFixed(ms < 10000 ? 1 : 0)} 秒`;
 
@@ -28,14 +29,17 @@ function generatedInput(content: string, target: string | undefined, preparing:
   </div>;
 }
 
-function InputView({ model, preparing, fillComposer }: { model: ReturnType<typeof activitySummary>; preparing: boolean; fillComposer: BlockRenderProps['fillComposer'] }) {
+function InputView({ model, phase, fillComposer }: { model: ReturnType<typeof activitySummary>; phase: ToolPhase; fillComposer: BlockRenderProps['fillComposer'] }) {
+  const preparing = phase === 'preparing';
+  const inProgress = preparing || phase === 'running';
   if ((model.name === 'render_ui' || model.name === 'show_widget') && typeof model.args?.html === 'string') {
     return preparing
       ? <StreamingMcpAppPlaceholder title={typeof model.args.title === 'string' ? (model.args.title as string) : undefined} />
       : <McpAppFrame html={model.args.html as string} title={typeof model.args.title === 'string' ? (model.args.title as string) : undefined} fillComposer={fillComposer} />;
   }
   if (model.content) return generatedInput(model.content, model.target, preparing);
-  if (model.command) return <div data-reader-tool-terminal><p className={css.toolDetailNote}>{preparing ? '正在生成命令 · 尚未执行' : '提交的命令'}</p><TerminalBlock command={model.command} cwd={model.cwd} labels={terminalBlockLabels} /></div>;
+  if (model.command) return <div data-reader-tool-terminal><p className={css.toolDetailNote}>{preparing ? '正在生成命令 · 尚未执行' : '提交的命令'}</p><TerminalBlock command={model.command} cwd={model.cwd} running={inProgress} labels={preparing ? preparingTerminalLabels : terminalBlockLabels} /></div>;
+  if (model.category === 'terminal' && preparing && model.argsState === 'partial') return <p className={css.toolDetailNote} data-reader-tool-command-pending>命令仍在生成，收到可识别的命令文本后会显示预览。</p>;
   return <JsonTree data={model.args} label={preparing ? '已收到的输入字段' : '工具输入'} labels={jsonTreeLabels} />;
 }
 
@@ -95,11 +99,11 @@ function ResultFallback({ entry, model, phase, ...render }: BlockRenderProps & {
   const block = entry.block;
   if (!block || !('kind' in block)) return <>
     <p className={css.toolDetailNote}>{phase === 'interrupted' ? '已中断，没有工具结果。已生成的输入仍可查看。' : phase === 'preparing' ? '模型正在生成工具输入，工具还未开始执行。' : '工具已开始执行，正在等待结果。'}</p>
-    <InputView model={model} preparing={phase === 'preparing'} fillComposer={render.fillComposer} />
+    <InputView model={model} phase={phase} fillComposer={render.fillComposer} />
   </>;
   const meta = objectValue(block.meta);
   const text = block.content.filter(item => item.type === 'text').map(item => item.text).join('\n');
-  if (phase === 'interrupted') return <><p className={css.toolDetailNote}>工具已取消，未正常完成。输入和原始返回记录仍可查看。</p><InputView model={model} preparing={false} fillComposer={render.fillComposer} /><pre className={css.toolRaw}>{text}</pre></>;
+  if (phase === 'interrupted') return <><p className={css.toolDetailNote}>工具已取消，未正常完成。输入和原始返回记录仍可查看。</p><InputView model={model} phase={phase} fillComposer={render.fillComposer} /><pre className={css.toolRaw}>{text}</pre></>;
 
   if (model.category === 'terminal') {
     const facts = executionFacts(block);
@@ -247,7 +251,7 @@ export const ToolActivity = memo(function ToolActivityView({ entry, motion, turn
         <div ref={panel} id={`${detailId}-panel`} className={css.toolPanel} role="tabpanel" aria-labelledby={`${detailId}-${tab}`} tabIndex={0}>
           {selected && <p className={css.toolDetailNote}>为保留选区，预览暂停更新；当前状态见卡片标题。</p>}
           {tab === 'result' && <ResultView {...render} {...preview} />}
-          {tab === 'input' && <><InputView model={preview.model} preparing={preview.phase === 'preparing'} fillComposer={render.fillComposer} /><details className={css.detail}><summary>全部输入字段</summary><JsonTree data={preview.model.args} label="输入字段" labels={jsonTreeLabels} /></details></>}
+          {tab === 'input' && <><InputView model={preview.model} phase={preview.phase} fillComposer={render.fillComposer} /><details className={css.detail}><summary>全部输入字段</summary><JsonTree data={preview.model.args} label="输入字段" labels={jsonTreeLabels} /></details></>}
           {tab === 'raw' && <><p className={css.toolDetailNote}>完整记录 · 只读 · 不执行其中的代码</p><h4 className={css.toolRawLabel}>工具输入</h4><pre className={css.toolRaw}>{preview.model.raw || '输入尚未到达'}</pre>{rawResult && <><h4 className={css.toolRawLabel}>工具结果</h4><pre className={css.toolRaw}>{rawResult}</pre></>}</>}
         </div>
       </div>

package/src/client/chat-seat.ts

@@ -0,0 +1,10 @@
+export type ChatSeatKind = 'user' | 'steering';
+
+export function chatSeatProps(kind: ChatSeatKind, key: string): Record<string, string> {
+  return {
+    'data-chat-anchor-key': key,
+    'data-chat-flow-key': key,
+    'data-chat-node-key': key,
+    'data-chat-flow-kind': kind,
+  };
+}

package/src/client/deliverables.ts

@@ -23,6 +23,7 @@ export function basename(path: string): string {
 export function dirname(path: string): string {
   const normalized = path.replace(/[/\\]+$/, '');
   const at = Math.max(normalized.lastIndexOf('/'), normalized.lastIndexOf('\\'));
+  if (at === 0 || (at === 2 && /^[A-Za-z]:/.test(normalized))) return normalized.slice(0, at + 1);
   return at === -1 ? '.' : normalized.slice(0, at) || '.';
 }
 

package/src/client/index.tsx

@@ -6,6 +6,8 @@ import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import { resolveWorkspacePath } from '@deepseek-ai/dsh-util-workspace-path';
 import * as workspacePathPkg from '@deepseek-ai/dsh-util-workspace-path';
 import { dirname } from './deliverables.js';
+import { isAbsoluteWorkspacePath } from '../workspace-path.js';
+import { ensureStyles } from './styles.js';
 import type {} from '@deepseek-ai/dsh-client-ui-conversation/client';
 import type {} from '@deepseek-ai/dsh-client-ui-renderer/client';
 import { Reader } from './Reader.js';
@@ -57,6 +59,9 @@ export { McpAppFrame } from './McpAppFrame.js';
 export const name = 'dsh-better-display-client';
 export const inject = ['slots', 'sessions', 'conversation', 'uiConversation', 'remote', 'remote.session'];
 
+// All CSS imports have injected their nodes before this module's body runs.
+ensureStyles();
+
 export function apply(ctx: Context): void {
   const store = createReaderStore();
   // conversation.view is session-scoped, so session persist keys are
@@ -138,7 +143,7 @@ export function apply(ctx: Context): void {
               const res = await fetch('/better-display/reveal', {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ path: targetPath }),
+                body: JSON.stringify({ path: targetPath, sessionId }),
               });
               if (res.ok) {
                 const data = await res.json();
@@ -150,6 +155,10 @@ export function apply(ctx: Context): void {
 
             // 2. Fallback to official opener with parent directory
             const parentDir = dirname(targetPath);
+            if (!isAbsoluteWorkspacePath(parentDir)) {
+              console.warn('[dsh-better-display] reveal failed; refusing to open a relative parent:', targetPath);
+              return;
+            }
             const remote = ctx.remote as unknown as { session?: { openWorkspacePath: (arg: { path: string }) => Promise<{ ok: boolean; error?: { message: string } }> } } | undefined;
             const remoteSession = remote?.session
               ?? (ctx.get?.('remote.session') as unknown as { openWorkspacePath: (arg: { path: string }) => Promise<{ ok: boolean; error?: { message: string } }> } | undefined);

package/src/client/motion.tsx

@@ -191,7 +191,14 @@ export function RetiringContent({ visible, children }: { visible: boolean; child
     if (!enabled || from < 1) { setPresent(false); return; }
     const next = element.animate([{ height: `${from}px`, opacity: 1 }, { height: '0px', opacity: 0 }], { duration: 220, easing: EASING, fill: 'both' });
     animation.current = next;
-    next.onfinish = () => { if (animation.current === next) { animation.current = null; next.cancel(); setPresent(false); } };
+    const settle = () => { if (animation.current === next) { animation.current = null; next.cancel(); setPresent(false); } };
+    next.onfinish = settle;
+    const deadline = window.setTimeout(settle, 220 + 240);
+    return () => {
+      window.clearTimeout(deadline);
+      if (animation.current === next) animation.current = null;
+      next.cancel();
+    };
   }, [visible, enabled, focusHeld]);
   useEffect(() => () => animation.current?.cancel(), []);
   if (!visible && !present) return null;

package/src/client/official-slots.tsx

@@ -57,8 +57,11 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
 }
 
 // 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']);
+// future registrations, reach the official renderer through the mirror seat.
+// 'user' and 'steering' are mirrored too, so third-party renderers registered
+// on the official node slot (e.g. message-recall buttons) keep working inside
+// the Reader instead of being silently dropped.
+const READER_OWNED_NODES = new Set(['assistant-step', 'tool-call', 'turn-tail', 'turn-process']);
 const EXPECTED: Record<OfficialFamily, Spec> = {
   actions: { kind: 'list', scope: 'session' },
   tools: { kind: 'keyed', scope: 'session' },
@@ -198,7 +201,7 @@ export function installOfficialSlots(ctx: Context): () => void {
           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);
+          family === 'nodes' ? entry => !READER_OWNED_NODES.has(entry.options.key ?? '') : undefined);
       }));
     }
   } catch (error) {

package/src/client/open-file.ts

@@ -1,3 +1,5 @@
+import { isAbsoluteWorkspacePath } from '../workspace-path.js';
+
 export type DeliverableOpenMode = 'external' | 'sidebar';
 
 export interface OpenModeSnapshot {
@@ -22,14 +24,6 @@ export function isFolderOpenPath(path: string): boolean {
   return path === '.' || path === '';
 }
 
-function isWindowsStylePath(value: string): boolean {
-  return /^[A-Za-z]:[/\\]/.test(value) || value.startsWith('\\\\');
-}
-
-function isAbsoluteWorkspacePath(path: string): boolean {
-  return path.startsWith('/') || isWindowsStylePath(path);
-}
-
 function encodeSegment(segment: string): string {
   return encodeURIComponent(segment).replace(/%3A/gi, ':');
 }

package/src/client/styles.ts

@@ -0,0 +1,22 @@
+const plugin = 'dsh-better-display';
+const styles = new Map<string, string>();
+
+/** Retain injected CSS across host cleanup and restore it before Reader paints. */
+export function ensureStyles(): void {
+  if (typeof document === 'undefined') return;
+  const live = new Set<string>();
+  for (const tag of document.querySelectorAll<HTMLStyleElement>(`style[data-plugin="${plugin}"][data-plugin-css]`)) {
+    const id = tag.dataset.pluginCss;
+    if (id === undefined) continue;
+    styles.set(id, tag.textContent ?? '');
+    live.add(id);
+  }
+  for (const [id, text] of styles) {
+    if (live.has(id)) continue;
+    const tag = document.createElement('style');
+    tag.dataset.plugin = plugin;
+    tag.dataset.pluginCss = id;
+    tag.textContent = text;
+    document.head.appendChild(tag);
+  }
+}

package/src/client/tool-activity.ts

@@ -53,10 +53,15 @@ export function stringValue(record: Record<string, unknown> | null, ...keys: str
   return undefined;
 }
 
+/** Top-level fields from complete or in-flight JSON tool arguments. */
+type ParsedInputFields =
+  | { kind: 'complete'; fields: Record<string, unknown> }
+  | { kind: 'partial'; fields: Record<string, unknown> };
+
 /** Read only top-level JSON string values, including an unfinished final string.
  * This never executes input or mistakes escaped/nested content for a path field. */
-export function inputFields(raw: string): Record<string, unknown> {
-  try { return objectValue(JSON.parse(raw)) ?? {}; } catch { /* an in-flight argument is normally incomplete */ }
+function parseInputFields(raw: string): ParsedInputFields {
+  try { return { kind: 'complete', fields: objectValue(JSON.parse(raw)) ?? {} }; } catch { /* an in-flight argument is normally incomplete */ }
   const fields: Record<string, unknown> = Object.create(null);
   const prefix = raw.slice(0, 262144);
   let depth = 0;
@@ -88,14 +93,19 @@ export function inputFields(raw: string): Record<string, unknown> {
     if (closed && /^\s*:/.test(prefix.slice(index + 1))) key = value;
     else if (key !== undefined) { fields[key] = value; key = undefined; }
   }
-  return fields;
+  return { kind: 'partial', fields };
+}
+
+export function inputFields(raw: string): Record<string, unknown> {
+  return parseInputFields(raw).fields;
 }
 
+/** Name and raw arguments of any call block, whether it has landed or is pending. */
 export function toolIdentity(entry: Pick<ToolActivityEntry, 'block' | 'draft'>) {
   const block = entry.block;
   return {
     name: block ? 'kind' in block ? block.call?.name ?? entry.draft?.name ?? '工具调用' : block.name : entry.draft?.name ?? '工具调用',
-    raw: block ? 'kind' in block ? block.call?.argsRaw ?? entry.draft?.argsRaw ?? '' : ('argsRaw' in block ? block.argsRaw : '') : entry.draft?.argsRaw ?? '',
+    raw: block ? 'kind' in block ? block.call?.argsRaw ?? entry.draft?.argsRaw ?? '' : ('argsRaw' in block ? block.argsRaw : entry.draft?.argsRaw ?? '') : entry.draft?.argsRaw ?? '',
   };
 }
 
@@ -254,7 +264,7 @@ export function foldDiffHunks(steps: readonly { kind: string; entry?: ToolActivi
 
 export function activityPhase(entry: Pick<ToolActivityEntry, 'block' | 'draft'>, turnClosed = false): ToolPhase {
   if (!entry.block) return turnClosed ? 'interrupted' : 'preparing';
-  if (!('kind' in entry.block)) return turnClosed ? 'interrupted' : 'running';
+  if (!('kind' in entry.block)) return turnClosed ? 'interrupted' : entry.block.phase === 'preparing' ? 'preparing' : 'running';
   // RC1 publishes canonical cancellation as an error result with a typed code.
   if (entry.block.error?.code === 'ABORTED' || entry.block.error?.code === 'interrupted') return 'interrupted';
   const facts = executionFacts(entry.block);
@@ -308,7 +318,8 @@ export function forgetCallClock(callId: string): void {
 
 export function activitySummary(entry: Pick<ToolActivityEntry, 'block' | 'draft'>) {
   const { name, raw } = toolIdentity(entry);
-  const args = inputFields(raw);
+  const parsed = parseInputFields(raw);
+  const args = parsed.fields;
   const target = stringValue(args, 'file_path', 'path', 'filename', 'filePath');
   const command = stringValue(args, 'command', 'cmd', 'script');
   const description = stringValue(args, 'description');
@@ -331,7 +342,7 @@ export function activitySummary(entry: Pick<ToolActivityEntry, 'block' | 'draft'
     : category === 'web' ? name === 'web_search' ? '搜索网页' : '读取网页'
     : category === 'code' ? (description || '运行代码')
     : name;
-  return { name, raw, args, category, title, target: target ?? command ?? stringValue(args, 'query', 'pattern', 'url'), command,
+  return { name, raw, args, argsState: parsed.kind, category, title, target: target ?? command ?? stringValue(args, 'query', 'pattern', 'url'), command,
     cwd: stringValue(args, 'workdir', 'cwd'), content: stringValue(args, 'content', 'new_string', 'newText', 'file_text') };
 }
 

package/src/dsh-better-display.ts

@@ -1,8 +1,8 @@
-import { spawn } from 'node:child_process';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Context } from '@deepseek-ai/cordis';
 import { scanGenerativeMcpappsStatus } from './skill-roots.js';
 import { skillsFromListResult, toPublicSkillStatus } from './skill-status.js';
+import { createRevealHandler, revealRoots } from './reveal.js';
 
 declare module '@deepseek-ai/cordis' {
   interface Context {
@@ -39,43 +39,7 @@ export function apply(ctx: Context): void {
       const disposeReveal = ctx.webServer!.register({
         kind: 'exact',
         path: '/better-display/reveal',
-        handler: async (req, res) => {
-          if (req.method !== 'POST') {
-            res.statusCode = 405;
-            res.end();
-            return;
-          }
-          let body = '';
-          req.on('data', chunk => { body += chunk; });
-          req.on('end', () => {
-            try {
-              const data = JSON.parse(body);
-              const targetPath = typeof data.path === 'string' ? data.path.trim() : '';
-              if (!targetPath) {
-                res.statusCode = 400;
-                res.end(JSON.stringify({ ok: false, error: 'Empty path' }));
-                return;
-              }
-
-              if (process.platform === 'darwin') {
-                // Exact file reveal in macOS Finder with selection highlight
-                spawn('open', ['-R', targetPath], { detached: true, stdio: 'ignore' });
-              } else if (process.platform === 'win32') {
-                // Exact file selection in Windows Explorer
-                spawn('explorer.exe', [`/select,${targetPath}`], { detached: true, stdio: 'ignore' });
-              } else {
-                spawn('xdg-open', [targetPath], { detached: true, stdio: 'ignore' });
-              }
-
-              res.setHeader('Content-Type', 'application/json');
-              res.statusCode = 200;
-              res.end(JSON.stringify({ ok: true }));
-            } catch (err) {
-              res.statusCode = 400;
-              res.end(JSON.stringify({ ok: false, error: String(err) }));
-            }
-          });
-        },
+        handler: createRevealHandler({ roots: sessionId => revealRoots(ctx, sessionId) }),
       });
       const disposeSkill = ctx.webServer!.register({
         kind: 'exact',

package/src/reveal.ts

@@ -0,0 +1,90 @@
+import { spawn, type SpawnOptions } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { posix, win32 } from 'node:path';
+import type { Context } from '@deepseek-ai/cordis';
+import { isAbsoluteWorkspacePath } from './workspace-path.js';
+
+export async function revealRoots(ctx: Context, sessionId: string | undefined): Promise<readonly string[]> {
+  if (sessionId !== undefined) {
+    const sessions = ctx.get?.('sessions') as { get: (id: string) => { header: { cwd?: string } } | undefined } | undefined;
+    const cwd = sessions?.get(sessionId)?.header.cwd;
+    if (cwd) return [cwd];
+    const query = ctx.get?.('sessionQuery') as {
+      observeSession: (id: string, options: { projectionMode: 'none' }) => Promise<{ header: { cwd?: string } } & Disposable>;
+    } | undefined;
+    if (query) {
+      using observation = await query.observeSession(sessionId, { projectionMode: 'none' });
+      if (observation.header.cwd) return [observation.header.cwd];
+    }
+  }
+  const registry = ctx.get?.('workspaceRegistry') as {
+    list: () => readonly { path: string; sessionIds: readonly string[] }[];
+  } | undefined;
+  return (registry?.list() ?? [])
+    .filter(workspace => sessionId === undefined || workspace.sessionIds.includes(sessionId))
+    .map(workspace => workspace.path);
+}
+
+export function resolveRevealPath(path: string, roots: readonly string[], exists = existsSync): string {
+  if (isAbsoluteWorkspacePath(path)) return path;
+  // Drive-relative and root-relative Windows paths do not identify a workspace.
+  if (/^[A-Za-z]:|^\\/.test(path)) throw new Error('Path is not workspace-relative');
+  const matches = new Set<string>();
+  for (const root of roots) {
+    if (!isAbsoluteWorkspacePath(root)) continue;
+    const paths = /^[A-Za-z]:[/\\]|^\\\\/.test(root) ? win32 : posix;
+    const candidate = paths.resolve(root, path);
+    if (exists(candidate)) matches.add(candidate);
+  }
+  if (matches.size !== 1) throw new Error(matches.size === 0 ? 'Workspace path not found' : 'Workspace path is ambiguous');
+  return [...matches][0];
+}
+
+export function revealPath(
+  path: string,
+  platform = process.platform,
+  spawnProcess: (command: string, args: string[], options: SpawnOptions) => unknown = spawn,
+): void {
+  const options = { detached: true, stdio: 'ignore' } satisfies SpawnOptions;
+  if (platform === 'darwin') {
+    spawnProcess('open', ['-R', path], options);
+  } else if (platform === 'win32') {
+    spawnProcess('explorer.exe', [`/select,"${path}"`], { ...options, windowsVerbatimArguments: true });
+  } else {
+    spawnProcess('xdg-open', [path], options);
+  }
+}
+
+export function createRevealHandler({ roots, reveal = revealPath }: {
+  roots: (sessionId: string | undefined) => Promise<readonly string[]>;
+  reveal?: (path: string) => void;
+}): (req: IncomingMessage, res: ServerResponse) => void {
+  return (req, res) => {
+    if (req.method !== 'POST') {
+      res.statusCode = 405;
+      res.end();
+      return;
+    }
+    let body = '';
+    req.on('data', chunk => { body += chunk; });
+    req.on('end', async () => {
+      res.setHeader('Content-Type', 'application/json');
+      try {
+        const data: unknown = JSON.parse(body);
+        const path = typeof data === 'object' && data !== null && 'path' in data && typeof data.path === 'string'
+          ? data.path.trim() : '';
+        if (!path) throw new Error('Empty path');
+        const sessionId = typeof data === 'object' && data !== null && 'sessionId' in data && typeof data.sessionId === 'string'
+          ? data.sessionId : undefined;
+        const targetPath = resolveRevealPath(path, isAbsoluteWorkspacePath(path) ? [] : await roots(sessionId));
+        reveal(targetPath);
+        res.statusCode = 200;
+        res.end(JSON.stringify({ ok: true }));
+      } catch (err) {
+        res.statusCode = 400;
+        res.end(JSON.stringify({ ok: false, error: String(err) }));
+      }
+    });
+  };
+}

package/src/workspace-path.ts

@@ -0,0 +1,4 @@
+/** Absolute paths accepted by both POSIX and Windows hosts. */
+export function isAbsoluteWorkspacePath(path: string): boolean {
+  return /^(?:\/|[A-Za-z]:[/\\]|\\\\)/.test(path);
+}

package/tests/chat-flow-hook.test.ts

@@ -45,6 +45,19 @@ test('committed client bundle publishes data-chat-flow for git installs', () =>
   assert.match(compiled, /"data-chat-flow":\s*""/);
 });
 
+test('Reader exposes rewind chat seats and pending steering markers', () => {
+  const source = readFileSync(resolve(root, 'src/client/Reader.tsx'), 'utf8');
+  const seat = readFileSync(resolve(root, 'src/client/chat-seat.ts'), 'utf8');
+  assert.match(seat, /data-chat-anchor-key/);
+  assert.match(seat, /data-chat-flow-key/);
+  assert.match(seat, /data-chat-node-key/);
+  assert.match(source, /data-pending-steering/);
+  assert.match(source, /data-pending-attachment-count/);
+  const client = readFileSync(resolve(root, 'lib/client.js'), 'utf8');
+  assert.match(client, /data-chat-anchor-key/);
+  assert.match(client, /data-pending-steering/);
+});
+
 test('skin empty-state hide stays off when Reader mounts inside the scrollport', () => {
   const inspectOnly: AttrNode = {
     attrs: { 'data-conversation-scroll': '' },

package/tests/fixtures/reader-official-users.tsx

@@ -0,0 +1,170 @@
+import { Context } from '@deepseek-ai/cordis';
+import * as React from 'react';
+import * as Primitives from '@deepseek-ai/dsh-client-ui-primitives';
+import { createRoot } from 'react-dom/client';
+import { flushSync } from 'react-dom';
+import { SlotRegistry } from '@fixture/registry';
+import { createSlotRenderer } from '@fixture/renderer';
+import { Reader } from '../../src/client/Reader.js';
+import { createReaderStore } from '../../src/client/store.js';
+import { installOfficialSlots, officialChildren, OFFICIAL_SEATS } from '../../src/client/official-slots.js';
+import type { ReaderProps } from '../../src/client/types.js';
+
+// Real Reader, registry, scope binding and slot renderer. Only session data is synthetic.
+function equal(actual: unknown, expected: unknown) {
+  if (!Object.is(actual, expected)) throw new Error(`Expected ${String(expected)}, got ${String(actual)}`);
+}
+const assert = {
+  equal,
+  ok(value: unknown) { equal(Boolean(value), true); },
+  deepEqual(actual: unknown, expected: unknown) { equal(JSON.stringify(actual), JSON.stringify(expected)); },
+};
+async function verify() {
+  const root = new Context();
+  await root.plugin(SlotRegistry);
+  let run = async () => {};
+  await root.plugin({ name: 'reader-user-test', inject: ['slots'], async apply(ctx: Context) {
+    const slots = ctx.slots as any;
+    slots.install(createSlotRenderer());
+    const source = <T,>(value: T) => ({ getSnapshot: () => value, subscribe: () => () => {} });
+    const binding = { key: 'session-users', ctx: new Context(), hooks: {}, keyedHooks: {}, props: { sessionId: 'session-users' } };
+    slots.installScope('session', {
+      current: source(binding), bindingSource: () => source(binding), renderArea: (_: unknown, props: any) => props.children,
+    });
+    slots.installLocale({ ...source({}), bind: () => (key: string) => key });
+    const turn = { turn: 1, status: 'closed', start: { seq: 1, time: 1 },
+      end: { time: 2, data: { reason: { kind: 'completed' } } }, data: new Map(), steps: [] };
+    const nodes = new Map(['user', 'steering', 'hidden'].map((kind, index) => {
+      const key = `${kind}-key`;
+      return [key, { key, kind: kind === 'hidden' ? 'user' : kind, anchorSeq: index + 1,
+        visibility: kind === 'hidden' ? 'hidden' : 'visible', location: { kind: 'turn', turn },
+        data: { seq: index + 1, time: 1, content: [{ type: 'text', text: `${kind} content` }] } }];
+    }));
+    const chat = { order: [...nodes.keys()], nodes, timeline: { turns: new Map([[1, turn]]) } };
+    const session = { running: false, openState: 'ready', pendingSubmissions: [], hasMore: false, loadingOlder: false };
+    const store = createReaderStore().create('session-users');
+    const props = {
+      sessionId: 'session-users', useChat: (select: any) => select(chat),
+      useSession: (select: any) => select(session), useSessions: (select: any) => select({ byId: { 'session-users': { cwd: '/fixture' } } }),
+      useSessionStatus: (select: any) => select(new Map()), useStore: (select: any) => select(store.getSnapshot()), actions: store.actions,
+      t: (key: string) => key, loadImage: async () => ({ data: new Uint8Array(), mediaType: 'image/png' }),
+      officialImageLoader: Object.assign(async () => null, { peek: () => null }),
+      officialFileMentions: () => undefined, officialPreviewFile: () => {},
+      officialHost: source({ home: '/fixture' }), fillComposer: () => true,
+      openFile: () => {}, loadOlder: async () => {}, openView: () => {},
+    };
+    slots.register({ name: 'root', children: {
+      'conversation.chat.node': { kind: 'keyed', scope: 'session', inject: { hooks: {
+        turnData: (_: unknown, context: any) => () => context.turnData,
+        disclosure: (_: unknown, context: any) => () => context.disclosureReset,
+      } } },
+      'fixture.reader': { kind: 'single', scope: 'session' },
+    } }, ({ SessionProvider, renderSlot }: any) => <SessionProvider>{renderSlot('fixture.reader', {})}</SessionProvider>);
+    slots.register({ name: 'fixture.reader', children: { ...officialChildren(slots), 'dsh-better-display.block': { kind: 'chain', scope: 'session' } } }, ({ renderSlot, renderSlotChain }: any) =>
+      <Reader {...{ ...props, renderSlot, renderSlotChain } as ReaderProps} />);
+    const stopMirror = installOfficialSlots(ctx);
+    run = async () => {
+      const container = document.getElementById('app')!;
+      const reactRoot = createRoot(container);
+      const render = () => {
+        flushSync(() => reactRoot.render(slots.renderSlot('root', {})));
+        return container.innerHTML;
+      };
+      const count = (html: string, text: string) => html.split(text).length - 1;
+      const assertSeats = (html: string) => {
+        for (const kind of ['user', 'steering']) {
+          assert.equal(count(html, `data-reader-key="${kind}-key"`), 1);
+          assert.equal(count(html, `data-chat-anchor-key="${kind}-key"`), 1);
+          assert.equal(count(html, `data-chat-flow-key="${kind}-key"`), 1);
+          assert.equal(count(html, `data-chat-node-key="${kind}-key"`), 1);
+          assert.equal(count(html, `data-chat-flow-kind="${kind}"`), 1);
+        }
+        assert.equal(count(html, 'data-reader-anchor="true"'), 2);
+        assert.ok(!html.includes('hidden content'));
+      };
+
+      // The real renderSlot returns an outlet element for an unoccupied key.
+      let html = render();
+      assertSeats(html);
+      assert.equal(count(html, 'user content'), 1);
+      assert.equal(count(html, 'steering content'), 1);
+      assert.ok(html.includes('补充消息'));
+      const seen: any[] = [];
+      const official = ({ node, sessionId, injectedSession, useTurnData, useDisclosure }: any) => {
+        assert.equal(sessionId, 'session-users');
+        assert.equal(injectedSession, 'session-users');
+        assert.equal(useTurnData(), turn.data);
+        assert.equal(useDisclosure().getSnapshot(), 0);
+        assert.equal(node, nodes.get(node.key));
+        seen.push(node.kind);
+        return <div data-official-user={node.kind}>{node.data.content[0].text}<button>Official recall</button></div>;
+      };
+      const removeUser = slots.register({ name: 'conversation.chat.node', key: 'user',
+        inject: (sessionId: string) => ({ injectedSession: sessionId }), locale: 'chat' }, official);
+      const removeSteering = slots.register({ name: 'conversation.chat.node', key: 'steering',
+        inject: (sessionId: string) => ({ injectedSession: sessionId }), locale: 'chat' }, official);
+      const removeAssistant = slots.register({ name: 'conversation.chat.node', key: 'assistant-step' }, () => <span>Duplicate assistant</span>);
+      await new Promise(resolve => queueMicrotask(resolve));
+      assert.deepEqual(slots.entriesOfSlot(OFFICIAL_SEATS.nodes).map((entry: any) => entry.options.key).sort(), ['steering', 'user']);
+      html = render();
+      assertSeats(html);
+      assert.equal(count(html, 'Official recall'), 2);
+      assert.equal(count(html, 'user content'), 1);
+      assert.equal(count(html, 'steering content'), 1);
+      assert.deepEqual(seen, ['user', 'steering']);
+
+      // A winner intentionally returning null must keep its row hidden.
+      const removeWinner = slots.register({ name: 'conversation.chat.node', key: 'user', priority: -1 }, () => null);
+      await new Promise(resolve => queueMicrotask(resolve));
+      html = render();
+      assertSeats(html);
+      assert.equal(count(html, 'user content'), 0);
+      assert.equal(count(html, 'Official recall'), 1);
+      removeWinner();
+      await new Promise(resolve => queueMicrotask(resolve));
+      assert.equal(count(render(), 'Official recall'), 2);
+      removeUser(); removeSteering(); removeAssistant();
+      await new Promise(resolve => queueMicrotask(resolve));
+      html = render();
+      assertSeats(html);
+      assert.equal(count(html, 'user content'), 1);
+      assert.equal(count(html, 'steering content'), 1);
+      assert.equal(count(html, 'Official recall'), 0);
+      const module = Reflect.get(window, 'easyrewriteModule');
+      if (module) {
+        const plugin = module.factory((name: string) => {
+          if (name === 'react') return React;
+          if (name === '@deepseek-ai/dsh-client-ui-primitives') return Primitives;
+          throw new Error(`Unexpected easyrewrite dependency: ${name}`);
+        });
+        const disposers: Array<() => void> = [];
+        plugin.apply({
+          effect: (effect: () => () => void) => disposers.push(effect()),
+          slots: {
+            inject: (key: string, effect: () => () => void) => key === 'conversation.chat.node' ? effect() : () => {},
+            register: (options: object, component: unknown) => slots.register(options, component),
+          },
+          sessions: { list: source({ current: 'session-users' }), scope: () => ({ get: () => undefined }) },
+          workspaces: {},
+        });
+        await new Promise(resolve => queueMicrotask(resolve));
+        html = render();
+        assertSeats(html);
+        assert.equal(count(html, 'data-dsh-easyrewrite="user"'), 1);
+        assert.equal(count(html, 'data-dsh-easyrewrite="recall-key"'), 1);
+        assert.equal(count(html, 'user content'), 1);
+        assert.equal(count(html, 'steering content'), 1);
+        const recall = container.querySelector<HTMLButtonElement>('[data-dsh-easyrewrite="recall-key"]');
+        assert.ok(recall);
+        flushSync(() => recall!.click());
+        assert.equal(container.querySelectorAll('[data-dsh-easyrewrite="confirm-capsule"]').length, 1);
+        for (const dispose of disposers) dispose();
+      }
+      stopMirror();
+      reactRoot.unmount();
+      Object.assign(window, { readerUserResult: 'passed' });
+    };
+  } });
+  await run();
+}
+verify().catch(error => { console.error(error); Object.assign(window, { readerUserResult: `${error.stack}\n${document.getElementById('app')?.innerHTML}` }); });

package/tests/footer-precedence.test.ts

@@ -21,6 +21,7 @@ const HOST_FOOTER_Z = 7;
 
 /** Lanes a scroll can clamp into the footer band. */
 const CLAMPED_LANES = [
+  '.turnStickyLanes',
   '.turnProcessSticky',
   '.liveFoldContainer',
   '.flowCell[data-flow-summary]',
@@ -85,6 +86,13 @@ test('the top toolbar lane stays at 7 and pins to the scrollport top', () => {
   assert.equal(declarations.get('top'), '0');
 });
 
+test('official code block banners stay beneath Reader sticky lanes', () => {
+  const blockZ = Number(mergedDeclarations(css, '.root :global(.md-code-block)').get('z-index'));
+  const summaryZ = Number(mergedDeclarations(css, '.flowCell[data-flow-summary]').get('z-index'));
+  assert.ok(Number.isFinite(blockZ), 'Reader scopes official markdown code blocks into a stacking context');
+  assert.ok(blockZ < summaryZ, `code block banner context (${blockZ}) must stay below the summary lane (${summaryZ})`);
+});
+
 test('the live status lane pins below the toolbar lane instead of over it', () => {
   const declarations = mergedDeclarations(css, '.turnProcessSticky');
   assert.match(