dsh-better-display 0.1.1

package/src/skill-roots.ts

@@ -0,0 +1,138 @@
+import { access, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  GENERATIVE_MCPAPPS_SKILL,
+  skillListIncludes,
+  skillRootEntryMatches,
+  type HostSkillStatus,
+  type SkillRootInfo,
+} from './skill-status.js';
+
+export function expandHomePath(path: string, home = homedir()): string {
+  if (path === '~') return home;
+  if (path.startsWith('~/') || path.startsWith('~\\')) return join(home, path.slice(2));
+  return path;
+}
+
+/** `$DSH_HOME` or `~/.dsh`, matching official `resolveDshHome`. */
+export function resolveDshHome(env: Record<string, string | undefined> = process.env, home = homedir()): string {
+  const fromEnv = env.DSH_HOME;
+  const selected = fromEnv !== undefined && fromEnv.trim().length > 0 ? fromEnv : join(home, '.dsh');
+  return resolve(expandHomePath(selected, home));
+}
+
+/** `$DSH_AGENTS_HOME` or `~/.agents`. */
+export function resolveAgentsHome(env: Record<string, string | undefined> = process.env, home = homedir()): string {
+  const fromEnv = env.DSH_AGENTS_HOME;
+  const selected = fromEnv !== undefined && fromEnv.trim().length > 0 ? fromEnv : join(home, '.agents');
+  return resolve(expandHomePath(selected, home));
+}
+
+export function userSkillRoots(
+  env: Record<string, string | undefined> = process.env,
+  home = homedir(),
+): readonly SkillRootInfo[] {
+  return [
+    { source: 'user-dsh', path: join(resolveDshHome(env, home), 'skills') },
+    { source: 'user-agents', path: join(resolveAgentsHome(env, home), 'skills') },
+  ];
+}
+
+export function projectSkillRoots(projectRoot: string): readonly SkillRootInfo[] {
+  return [
+    { source: 'project-dsh', path: join(projectRoot, '.dsh', 'skills') },
+    { source: 'project-agents', path: join(projectRoot, '.agents', 'skills') },
+  ];
+}
+
+export async function findProjectRoot(cwd: string): Promise<string> {
+  let current = resolve(cwd);
+  while (true) {
+    if (existsSync(join(current, '.git'))) return current;
+    const parent = dirname(current);
+    if (parent === current) return resolve(cwd);
+    current = parent;
+  }
+}
+
+export async function rootHasGenerativeMcpapps(rootPath: string): Promise<boolean> {
+  let entries;
+  try {
+    entries = await readdir(rootPath, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (entry.name === '.system') continue;
+    if (!skillRootEntryMatches(entry.name)) continue;
+    if (entry.isDirectory()) {
+      try {
+        await access(join(rootPath, entry.name, 'SKILL.md'));
+        return true;
+      } catch {
+        continue;
+      }
+    }
+    if (entry.isFile()) return true;
+  }
+  return false;
+}
+
+/** Resolve the plugin-shipped pack. This path is never treated as a skill root. */
+export function pluginSkillPackPath(moduleUrl = import.meta.url): string | undefined {
+  const here = dirname(fileURLToPath(moduleUrl));
+  const candidates = [
+    join(here, '../skills', GENERATIVE_MCPAPPS_SKILL),
+    join(here, '../../skills', GENERATIVE_MCPAPPS_SKILL),
+    join(here, 'skills', GENERATIVE_MCPAPPS_SKILL),
+  ];
+  return candidates.find(path => existsSync(join(path, 'SKILL.md')));
+}
+
+export async function scanGenerativeMcpappsStatus(options: {
+  cwd?: string;
+  env?: Record<string, string | undefined>;
+  home?: string;
+  packPath?: string;
+  listSkills?: () => Promise<readonly { readonly name?: string }[] | undefined>;
+} = {}): Promise<HostSkillStatus> {
+  const env = options.env ?? process.env;
+  const home = options.home ?? homedir();
+  const roots: SkillRootInfo[] = [...userSkillRoots(env, home)];
+  const cwd = typeof options.cwd === 'string' && options.cwd.trim().length > 0
+    ? (isAbsolute(options.cwd) ? options.cwd : resolve(options.cwd))
+    : undefined;
+  if (cwd !== undefined) roots.unshift(...projectSkillRoots(await findProjectRoot(cwd)));
+
+  const inspected: SkillRootInfo[] = [];
+  let rootHit = false;
+  for (const root of roots) {
+    const present = await rootHasGenerativeMcpapps(root.path);
+    inspected.push({ ...root, present });
+    if (present) rootHit = true;
+  }
+
+  let via: HostSkillStatus['via'] = null;
+  let listHit = false;
+  if (options.listSkills) {
+    try {
+      listHit = skillListIncludes(await options.listSkills());
+      if (listHit) via = 'skills.list';
+    } catch {
+      // Registry/RPC absence falls back to the scanned roots.
+    }
+  }
+  if (!listHit && rootHit) via = 'skill-root';
+
+  const packPath = options.packPath ?? pluginSkillPackPath();
+  return {
+    name: GENERATIVE_MCPAPPS_SKILL,
+    installed: listHit || rootHit,
+    via,
+    roots: inspected,
+    ...packPath !== undefined ? { packPath } : {},
+  };
+}

package/src/skill-status.ts

@@ -0,0 +1,81 @@
+/** Shared generative-mcpapps identity. Plugin-tree presence is not installation. */
+
+export const GENERATIVE_MCPAPPS_SKILL = 'generative-mcpapps';
+
+/** Conventional relative roots only. Never expand $HOME or dump host `root.path`. */
+export const CONVENTIONAL_SKILL_ROOTS = ['.dsh/skills', '.agents/skills'] as const;
+
+/** Copy source relative to the plugin / checkout, not an absolute pack path. */
+export const SKILL_PACK_RELATIVE = `skills/${GENERATIVE_MCPAPPS_SKILL}`;
+
+export type SkillRootSource =
+  | 'project-dsh'
+  | 'project-agents'
+  | 'user-dsh'
+  | 'user-agents'
+  | 'custom'
+  | 'bundled'
+  | (string & {});
+
+export interface SkillRootInfo {
+  readonly source: SkillRootSource;
+  readonly path: string;
+  readonly present?: boolean;
+}
+
+export interface HostSkillStatus {
+  readonly name: typeof GENERATIVE_MCPAPPS_SKILL;
+  readonly installed: boolean;
+  readonly via: 'skills.list' | 'skill-root' | null;
+  readonly roots: readonly SkillRootInfo[];
+  /** Plugin-shipped pack path for copy guidance. Not a harness skill root. */
+  readonly packPath?: string;
+}
+
+export function skillNameMatches(name: unknown): boolean {
+  return typeof name === 'string' && name === GENERATIVE_MCPAPPS_SKILL;
+}
+
+export function skillListIncludes(entries: readonly { readonly name?: string }[] | undefined): boolean {
+  return Array.isArray(entries) && entries.some(entry => skillNameMatches(entry?.name));
+}
+
+/** Directory bundle `name/SKILL.md` or flat `name.md` at a scanned root. */
+export function skillRootEntryMatches(entryName: string): boolean {
+  return entryName === GENERATIVE_MCPAPPS_SKILL || entryName === `${GENERATIVE_MCPAPPS_SKILL}.md`;
+}
+
+export function skillsFromListResult(result: unknown): { name?: string }[] {
+  if (Array.isArray(result)) return result;
+  if (result === null || typeof result !== 'object') return [];
+  const record = result as {
+    ok?: boolean;
+    value?: { skills?: unknown } | unknown;
+    skills?: unknown;
+  };
+  if (record.ok === false) return [];
+  if (Array.isArray(record.skills)) return record.skills as { name?: string }[];
+  if (record.value && typeof record.value === 'object') {
+    const value = record.value as { skills?: unknown };
+    if (Array.isArray(value.skills)) return value.skills as { name?: string }[];
+    if (Array.isArray(record.value)) return record.value as { name?: string }[];
+  }
+  return [];
+}
+
+export function publicSkillRoots(): readonly SkillRootInfo[] {
+  return CONVENTIONAL_SKILL_ROOTS.map(path => ({ source: 'conventional', path }));
+}
+
+/**
+ * Strip host home / pack absolutes before anything user-facing (HTTP or Settings).
+ * Detection still uses the raw scan; this is the public face.
+ */
+export function toPublicSkillStatus(status: HostSkillStatus): HostSkillStatus {
+  return {
+    name: status.name,
+    installed: status.installed,
+    via: status.via,
+    roots: publicSkillRoots(),
+  };
+}

package/tests/browser-closed-gap.tsx

@@ -0,0 +1,20 @@
+import React, { useMemo, useRef, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import type { ChatSnapshot } from '@deepseek-ai/dsh-client-ui-chat/client';
+import { ChoreographedFlow } from '../src/client/ChoreographedFlow.js';
+import { ClosedProcessSummary } from '../src/client/ClosedProcessSummary.js';
+import { ProcessFragment } from '../src/client/motion.js';
+import { presentLiveTurn } from '../src/client/live-turn.js';
+import type { LiveStep } from '../src/client/live-turn.js';
+function Fixture() {
+ const [open,setOpen]=useState(false);const button=useRef<HTMLButtonElement>(null);
+ const steps=useMemo(()=>Array.from({length:500},(_,i):LiveStep=>({kind:'reasoning',key:`r${i}`,nodeKey:`r${i}`,step:i,start:0,blocks:[]})),[]);
+ const frame=useMemo(()=>({items:presentLiveTurn(steps,{status:'closed',reason:'completed',closingStep:501,latestStep:501}),snapshot:{} as ChatSnapshot}),[steps]);
+ return <main style={{padding:30}}><h1>完成后 500 条过程记录：实际组件回归</h1>
+ <button ref={button} onClick={()=>setOpen(v=>!v)}>切换过程展开</button>
+ <ClosedProcessSummary steps={steps} open={open} onChange={setOpen} controls="closed-flow"/>
+ <ChoreographedFlow id="closed-flow" frame={frame} motion enabled={false} urgent={false} processOpen={open} open={{}} onOpenChange={()=>{}}
+ renderStep={step=><ProcessFragment open={open} motion onRead={()=>{}} returnFocusTo={button} nodeKey={step.key}><p>过程内容 {step.key}</p></ProcessFragment>}/>
+ <article data-final-answer>最终回答必须紧随统计，不能隔着 8000px 空白；展开、收起以后仍应如此。</article></main>;
+}
+createRoot(document.getElementById('app')!).render(<Fixture/>);

package/tests/browser-motion.tsx

@@ -0,0 +1,65 @@
+import React, { useMemo, useRef, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import type { ChatSnapshot } from '@deepseek-ai/dsh-client-ui-chat/client';
+import { ChoreographedFlow, useFlowChat } from '../src/client/ChoreographedFlow.js';
+import { presentLiveTurn } from '../src/client/live-turn.js';
+import type { LiveStep } from '../src/client/live-turn.js';
+import { Disclosure, StatusText, useMotionAllowed, useReadingScroll } from '../src/client/motion.js';
+import { ReasoningCard } from '../src/client/ReasoningCard.js';
+import { StreamMotionContext, useStreamingText } from '../src/client/streaming.js';
+import css from '../src/client/Reader.module.css';
+
+const sample = '旧内容保持原位，先完成连续收拢，再确认数字，最后继续输出。This is a real component regression fixture, not a replacement animation. ';
+function Text({ step }: { step: LiveStep }) {
+  const node = useFlowChat(s => 'nodeKey' in step ? s.nodes.get(step.nodeKey) : undefined);
+  const source = (node?.data as { text?: string })?.text ?? '';
+  const text = useStreamingText(source, true, { startedAt: 0, interrupted: false, selected: false });
+  if (step.kind === 'reasoning') return <ReasoningCard step={step.step} active motion selected={false} onRead={() => {}}>
+    <div data-test-text={step.key} style={{ whiteSpace: 'pre-wrap' }}>{text.text}</div>
+  </ReasoningCard>;
+  return <div data-reader-anchor style={{ padding: '10px 0' }} data-test-text={step.key}>{step.kind === 'body' ? sample : '工具 · 读取源文件，等待下一个步骤'}</div>;
+}
+function Demo() {
+  const [n, setN] = useState(1);
+  const [tail, setTail] = useState(0);
+  const [auto, setAuto] = useState(true);
+  const [motionSetting, setMotion] = useState(true);
+  const motion = useMotionAllowed(motionSetting);
+  const [urgent, setUrgent] = useState(false);
+  const [expanded, setExpanded] = useState(true);
+  const [open, setOpen] = useState<Record<string, boolean>>({});
+  const root = useRef<HTMLDivElement>(null); const button=useRef<HTMLButtonElement>(null);
+  useReadingScroll(root, motion);
+  const frame = useMemo(() => {
+    const steps: LiveStep[] = [];
+    const nodes = new Map();
+    for (let i=1; i<=n; i++) {
+      steps.push({ kind: 'reasoning', key: `r${i}`, nodeKey:`r${i}`, start:0, blocks:[], step:i });
+      nodes.set(`r${i}`, { data: { text: sample.repeat(i===n && n>1 ? 3 + tail : 5) } });
+      if (i<n || n===1) {
+        steps.push({kind:'body',key:`b${i}`,nodeKey:`b${i}`,start:1,blocks:[],step:i});
+        steps.push({kind:'other',key:`t${i}`,nodeKey:`t${i}`});
+      }
+    }
+    return {items:presentLiveTurn(steps,{status:'open'},auto),snapshot:{nodes:{get:(key:string)=>nodes.get(key)}} as unknown as ChatSnapshot};
+  }, [n,tail,auto]);
+  (window as any).fixture = { next:()=>setN(v=>v+1), burst:()=>{setN(v=>v+1); setTimeout(()=>setN(v=>v+2),100); setTimeout(()=>setTail(v=>v+2),180);}, stop:()=>setUrgent(true), reduce:()=>setMotion(false), reset:()=>{setN(1);setTail(0);setUrgent(false);setOpen({});setMotion(true);setAuto(true);} };
+  return <><nav style={{padding:12,display:'flex',gap:12,flexWrap:'wrap'}}>
+    <b>转场验收 · 真实组件 / 模拟数据</b>
+    <button onClick={()=>(window as any).fixture.next()}>下一步</button>
+    <button onClick={()=>(window as any).fixture.burst()}>突发三步</button>
+    <button onClick={()=>(window as any).fixture.stop()}>停止</button>
+    <button onClick={()=>(window as any).fixture.reset()}>重置</button>
+    <button onClick={()=>setMotion(v=>!v)}>动效{motion?'开':'关'}</button>
+  </nav><div data-conversation-scroll style={{height:'calc(100vh - 70px)',overflow:'auto'}}>
+    <StreamMotionContext.Provider value={{enabled:motion,activatedAt:Date.now()}}>
+    <div ref={root} className={css.root} data-motion={motion?'on':'off'}><div className={css.column} data-chat-flow="">
+      <div className={css.toolbar}><button className={css.textButton} onClick={()=>setAuto(v=>!v)}>自动折叠{auto?'开':'关'}</button></div>
+      <div className={css.turnProcessSticky}><Disclosure open={expanded} onChange={setExpanded} buttonRef={button} label={<StatusText text="正在处理" motion={motion}/>} /></div>
+      <ChoreographedFlow id="fixture-flow" frame={frame} motion={motion} enabled={auto} urgent={urgent} processOpen={expanded}
+        open={open} onOpenChange={(key,value)=>setOpen(s=>({...s,[key]:value}))} renderStep={step=><Text step={step}/>} />
+      <div data-test-footer style={{height:72}}>输入区位置参照 · 后台数据不会被修改</div>
+    </div></div></StreamMotionContext.Provider>
+  </div></>;
+}
+createRoot(document.getElementById('app')!).render(<Demo />);

package/tests/browser-sticky-lanes.tsx

@@ -0,0 +1,22 @@
+import React, { useMemo, useRef, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import type { ChatSnapshot } from '@deepseek-ai/dsh-client-ui-chat/client';
+import { StickyLane } from '../src/client/StickyLane.js';
+import { ChoreographedFlow } from '../src/client/ChoreographedFlow.js';
+import { ClosedProcessSummary } from '../src/client/ClosedProcessSummary.js';
+import { Disclosure, StatusText } from '../src/client/motion.js';
+import { presentLiveTurn } from '../src/client/live-turn.js';
+import type { LiveStep } from '../src/client/live-turn.js';
+import css from '../src/client/Reader.module.css';
+const steps:LiveStep[]=[...Array.from({length:6},(_,i):LiveStep=>({kind:'reasoning',key:`r${i}`,nodeKey:`r${i}`,step:i,start:0,blocks:[]})),{kind:'body',key:'body',nodeKey:'body',step:6,start:0,blocks:[]},{kind:'other',key:'extra',nodeKey:'extra'},{kind:'reasoning',key:'latest',nodeKey:'latest',step:7,start:0,blocks:[]},{kind:'body',key:'answer',nodeKey:'answer',step:7,start:0,blocks:[]}];
+function Fixture(){
+ const [expanded,setExpanded]=useState(true),[open,setOpen]=useState<Record<string,boolean>>({}),[closed,setClosed]=useState(false);const button=useRef<HTMLButtonElement>(null);
+ const frame=useMemo(()=>({items:presentLiveTurn(steps,{status:'open',reason:null,latestStep:7,closingStep:null}),snapshot:{} as ChatSnapshot}),[]);
+ return <><button onClick={()=>setClosed(v=>!v)}>切换完成状态</button><div data-conversation-scroll style={{height:'calc(100vh - 32px)',overflow:'auto'}}><div className={css.root} data-dsh-better-display="fixture"><div className={css.column} data-chat-flow="">
+ <StickyLane kind="toolbar" className={css.toolbar}><button className={css.textButton}>自动折叠开</button></StickyLane>
+ <section className={css.turn} data-reader-turn="1"><div style={{height:240,background:'#eef2ff',alignSelf:'flex-end',width:'65%'}}>用户消息：滚动抵达顶部才吸顶。</div>
+ <StickyLane kind="status" className={css.turnProcessSticky}><Disclosure open={expanded} onChange={setExpanded} buttonRef={button} label={<StatusText text="正在使用工具" motion={false}/>} /></StickyLane>
+ {closed?<><ClosedProcessSummary steps={steps.slice(0,-1)} open={expanded} onChange={setExpanded} controls="body"/><div id="body" style={{height:1600}}>最终回答占位，验证完成后统计仍然吸顶。</div></>:<ChoreographedFlow id="flow" frame={frame} motion={false} enabled={false} urgent={false} processOpen={expanded} open={open} onOpenChange={(k,v)=>{setExpanded(true);setOpen(x=>({...x,[k]:v}));}} renderStep={s=>s.key==='answer'?<div style={{height:1600}}>当前输出保持完整，统计不应被推出视野。</div>:expanded?<div style={{height:s.key==='latest'?300:100}}>过程 {s.key}</div>:null}/>}
+ </section><div style={{height:180}}>下一轮之前</div></div></div></div></>;
+}
+createRoot(document.getElementById('app')!).render(<Fixture/>);

package/tests/browser-waiting-clock.tsx

@@ -0,0 +1,14 @@
+import React, { useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { WaitingStatus } from '../src/client/WaitingStatus.js';
+import { waitingAnchor } from '../src/client/waiting-clock.js';
+function Fixture() {
+ const [inputs,setInputs]=useState([{key:'u1',kind:'user',data:{time:Date.now()-300000}}]);
+ const [renders,setRenders]=useState(0);
+ const anchor=waitingAnchor(inputs.map(x=>x.key),key=>inputs.find(x=>x.key===key));
+ return <main style={{padding:30}}><h1>等待计时回归：真实组件、模拟输入</h1>
+ <button onClick={()=>setInputs(x=>[...x,{key:`s${x.length}`,kind:'steering',data:{time:Date.now()}}])}>追加 steering</button>
+ <button onClick={()=>setRenders(x=>x+1)}>普通输出更新</button><span>更新次数 {renders}</span>
+ <WaitingStatus anchor={anchor} label="深度求索中..."/></main>;
+}
+createRoot(document.getElementById('app')!).render(<Fixture/>);

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

@@ -0,0 +1,66 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+/** Maid-atelier / phoebe-atelier hide rule, reduced to the :has() predicate. */
+const SKIN_HIDE = '[data-conversation-scroll]:not(:has([data-chat-flow])) > [data-composer-seat]';
+
+interface AttrNode {
+  attrs: Record<string, string>;
+  children: AttrNode[];
+}
+
+function hasAttr(node: AttrNode, name: string): boolean {
+  if (Object.hasOwn(node.attrs, name)) return true;
+  return node.children.some(child => hasAttr(child, name));
+}
+
+/** True when the skin rule would set the seat to display:none. */
+function skinHidesComposerSeat(scroll: AttrNode): boolean {
+  return !hasAttr(scroll, 'data-chat-flow');
+}
+
+function readerColumn(hook: boolean): AttrNode {
+  return {
+    attrs: hook ? { 'data-chat-flow': '' } : {},
+    children: [{ attrs: { 'data-reader-turn': '1' }, children: [] }],
+  };
+}
+
+test('Reader source keeps the native ChatView chat-flow hook on its column', () => {
+  const source = readFileSync(resolve(root, 'src/client/Reader.tsx'), 'utf8');
+  const column = source.match(/<div className=\{css\.column\}[^>]*>/);
+  assert.ok(column, 'Reader still renders css.column');
+  assert.match(column[0], /data-chat-flow=""/);
+});
+
+test('committed client bundle publishes data-chat-flow for git installs', () => {
+  const client = readFileSync(resolve(root, 'lib/client.js'), 'utf8');
+  assert.match(client, /"data-chat-flow":\s*""/);
+  const compiled = readFileSync(resolve(root, 'lib/types/client/Reader.js'), 'utf8');
+  assert.match(compiled, /"data-chat-flow":\s*""/);
+});
+
+test('skin empty-state hide stays off when Reader mounts inside the scrollport', () => {
+  const inspectOnly: AttrNode = {
+    attrs: { 'data-conversation-scroll': '' },
+    children: [
+      { attrs: { 'data-reader-turn': '1' }, children: [] },
+      { attrs: { 'data-composer-seat': '' }, children: [] },
+    ],
+  };
+  const withReader: AttrNode = {
+    attrs: { 'data-conversation-scroll': '' },
+    children: [readerColumn(true), { attrs: { 'data-composer-seat': '' }, children: [] }],
+  };
+  assert.equal(skinHidesComposerSeat(inspectOnly), true, SKIN_HIDE);
+  assert.equal(skinHidesComposerSeat(withReader), false, SKIN_HIDE);
+  assert.equal(skinHidesComposerSeat({
+    attrs: { 'data-conversation-scroll': '' },
+    children: [readerColumn(false), { attrs: { 'data-composer-seat': '' }, children: [] }],
+  }), true);
+});

package/tests/cloud-gate.test.ts

@@ -0,0 +1,34 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { accessSync, constants, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+test('cloud hard-gate files are committed and ban other models / computer use', () => {
+  const hooks = JSON.parse(readFileSync(resolve(root, '.cursor/hooks.json'), 'utf8')) as {
+    hooks: { subagentStart: { command: string }[] };
+  };
+  assert.equal(hooks.hooks.subagentStart[0]?.command, '.cursor/hooks/block-other-models.sh');
+
+  const script = resolve(root, '.cursor/hooks/block-other-models.sh');
+  accessSync(script, constants.X_OK);
+  const hook = readFileSync(script, 'utf8');
+  assert.match(hook, /computeruse|computerUse/);
+  assert.match(hook, /browser/);
+  assert.match(hook, /claude|sonnet|opus/);
+
+  const worker = readFileSync(resolve(root, '.cursor/agents/worker.md'), 'utf8');
+  assert.match(worker, /model: inherit/);
+  assert.match(worker, /force-default-model: true/);
+
+  const cloud = readFileSync(resolve(root, '.cursor/CLOUD.md'), 'utf8');
+  assert.match(cloud, /Only use Grok 4\.6/);
+  assert.match(cloud, /Never Claude, Sonnet, Opus, GPT, or Gemini/);
+  assert.match(cloud, /model: inherit/);
+  assert.match(cloud, /Do not spawn the Task tool, computerUse, or browser/);
+  assert.match(cloud, /Composer is the only fallback/);
+  assert.match(cloud, /Do not pass a `model` argument/);
+  assert.match(cloud, /Prefer Grok or Composer only/);
+});

package/tests/conversation-scroll.test.ts

@@ -0,0 +1,47 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { flowTop, landTurn, READING_LINE_OFFSET_PX, scrollerOf } from '../src/client/conversation-scroll.ts';
+
+interface FakeBox {
+  top: number;
+  scrollTop: number;
+  closest: (selector: string) => FakeBox | null;
+  getBoundingClientRect: () => { top: number };
+}
+
+function box(top: number, extra: Partial<FakeBox> = {}): FakeBox {
+  const node: FakeBox = {
+    top,
+    scrollTop: 0,
+    closest: () => null,
+    getBoundingClientRect: () => ({ top: node.top }),
+    ...extra,
+  };
+  return node;
+}
+
+test('scrollerOf prefers the conversation scroll host over the reader root', () => {
+  const host = box(40);
+  const root = box(80, { closest: selector => selector === '[data-conversation-scroll]' ? host : null });
+  assert.equal(scrollerOf(root as unknown as HTMLElement), host as unknown as HTMLElement);
+});
+
+test('scrollerOf falls back to the reader root when no host exists', () => {
+  const root = box(0);
+  assert.equal(scrollerOf(root as unknown as HTMLElement), root as unknown as HTMLElement);
+});
+
+test('landTurn writes only scrollport.scrollTop using the official reading-line offset', () => {
+  const scrollport = box(100, { scrollTop: 50 });
+  const row = box(300);
+  landTurn(row as unknown as HTMLElement, scrollport as unknown as HTMLElement);
+  assert.equal(flowTop(row as unknown as HTMLElement, scrollport as unknown as HTMLElement), 200);
+  assert.equal(scrollport.scrollTop, 50 + 200 - READING_LINE_OFFSET_PX);
+});
+
+test('landTurn to the last row clamps naturally via the caller scrollport assignment', () => {
+  const scrollport = box(0, { scrollTop: 900 });
+  const row = box(40);
+  landTurn(row as unknown as HTMLElement, scrollport as unknown as HTMLElement);
+  assert.equal(scrollport.scrollTop, 900 + 40 - READING_LINE_OFFSET_PX);
+});

package/tests/deliverables.test.ts

@@ -0,0 +1,128 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import type { TurnLocation } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import { basename, createProducedFileMentions, dirname, getTurnDeliverables, showDeliverablesRow } from '../src/client/deliverables.ts';
+import type { ReaderFlowEntry } from '../src/client/tool-activity.ts';
+
+test('basename and dirname handle POSIX and Windows style paths', () => {
+  assert.equal(basename('src/client/Reader.tsx'), 'Reader.tsx');
+  assert.equal(dirname('src/client/Reader.tsx'), 'src/client');
+  assert.equal(basename('C:\\project\\src\\index.ts'), 'index.ts');
+  assert.equal(dirname('C:\\project\\src\\index.ts'), 'C:\\project\\src');
+  assert.equal(basename('simple.txt'), 'simple.txt');
+  assert.equal(dirname('simple.txt'), '.');
+  assert.equal(basename('/root/file.md/'), 'file.md');
+  assert.equal(dirname('/root/file.md/'), '/root');
+});
+
+test('getTurnDeliverables extracts produced paths from turn deliverables data', () => {
+  const map = new Map<string, unknown>();
+  map.set('deliverables', {
+    produced: [
+      { seq: 1, path: 'src/client/Reader.tsx' },
+      { seq: 2, path: 'src/client/Reader.module.css' },
+      { seq: 3, path: 'src/client/Reader.tsx' }, // duplicate
+    ],
+  });
+  const turn = { data: map } as unknown as TurnLocation;
+  const paths = getTurnDeliverables(turn);
+  assert.deepEqual(paths, ['src/client/Reader.tsx', 'src/client/Reader.module.css']);
+});
+
+test('getTurnDeliverables falls back to tool flow when turn data is absent', () => {
+  const flow: ReaderFlowEntry[] = [
+    {
+      kind: 'tool',
+      key: 'tool:1',
+      callId: 'call:1',
+      step: 1,
+      order: 0,
+      block: {
+        kind: 'tool-call',
+        name: 'write',
+        argsRaw: JSON.stringify({ file_path: 'src/client/new-feature.ts', content: 'hello' }),
+      } as any,
+    },
+    {
+      kind: 'tool',
+      key: 'tool:2',
+      callId: 'call:2',
+      step: 2,
+      order: 1,
+      block: {
+        kind: 'tool-call',
+        name: 'edit',
+        argsRaw: JSON.stringify({ file_path: 'src/client/Reader.tsx', old_string: 'a', new_string: 'b' }),
+      } as any,
+    },
+    {
+      kind: 'tool',
+      key: 'tool:3',
+      callId: 'call:3',
+      step: 3,
+      order: 2,
+      block: {
+        kind: 'tool-result',
+        isError: true, // error result should be skipped
+        name: 'write',
+        argsRaw: JSON.stringify({ file_path: 'bad.txt', content: 'err' }),
+      } as any,
+    },
+    {
+      kind: 'tool',
+      key: 'tool:4',
+      callId: 'call:4',
+      step: 4,
+      order: 3,
+      block: {
+        kind: 'tool-call',
+        name: 'read', // read should not be considered a deliverable
+        argsRaw: JSON.stringify({ file_path: 'package.json' }),
+      } as any,
+    },
+  ];
+
+  const paths = getTurnDeliverables(undefined, flow);
+  assert.deepEqual(paths, ['src/client/new-feature.ts', 'src/client/Reader.tsx']);
+});
+
+test('createProducedFileMentions resolves exact paths and unique basenames, leaving ambiguous basenames inert', () => {
+  const opened: string[] = [];
+  const openFile = (p: string) => { opened.push(p); };
+  const paths = [
+    'src/client/Reader.tsx',
+    'src/server/Reader.tsx', // duplicate basename
+    'src/client/Reader.module.css', // unique basename
+  ];
+  const mentions = createProducedFileMentions(paths, openFile);
+
+  // Exact path resolves
+  const exact = mentions.resolve('src/client/Reader.tsx');
+  assert.ok(exact);
+  assert.equal(exact.title, 'src/client/Reader.tsx');
+  assert.equal(exact.label, '打开 src/client/Reader.tsx');
+  exact.open();
+  assert.deepEqual(opened, ['src/client/Reader.tsx']);
+
+  // Unique basename resolves
+  const unique = mentions.resolve('Reader.module.css');
+  assert.ok(unique);
+  assert.equal(unique.title, 'src/client/Reader.module.css');
+  unique.open();
+  assert.deepEqual(opened, ['src/client/Reader.tsx', 'src/client/Reader.module.css']);
+
+  // Ambiguous basename leaves undefined (never guess or open the wrong file)
+  const ambiguous = mentions.resolve('Reader.tsx');
+  assert.equal(ambiguous, undefined);
+
+  // Unrelated file leaves undefined
+  const unrelated = mentions.resolve('unknown.js');
+  assert.equal(unrelated, undefined);
+});
+
+test('produced-files row waits for turn close even when paths already exist', () => {
+  const paths = ['src/client/Watcher.tsx'];
+  assert.equal(showDeliverablesRow('open', paths), false);
+  assert.equal(showDeliverablesRow('closed', paths), true);
+  assert.equal(showDeliverablesRow('closed', []), false);
+});