dsh-better-display 0.3.2 → 0.3.5

package/scripts/verify-flowcell.mjs

@@ -0,0 +1,87 @@
+/** Actual FlowCell browser regression. Use --baseline for the v0.3.4 A/B reproduction. */
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { execFileSync } from 'node:child_process';
+import { createServer } from 'node:http';
+import { dirname, join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { homedir } from 'node:os';
+const { launchPinnedChromium } = await import(pathToFileURL(join(homedir(), '.codex/playwright-runtime/runtime.mjs')).href);
+
+const root = resolve(import.meta.dirname, '..');
+const out = join(root, '.evidence/flowcell');
+const require = createRequire(join(root, 'package.json'));
+const harness = process.env.DSHX_HARNESS;
+if (!harness) throw new Error('Set DSHX_HARNESS to the target checkout.');
+const webRequire = createRequire(join(harness, 'packages/client/web/package.json'));
+const variants = process.argv.includes('--baseline') ? ['baseline', 'fixed'] : ['fixed'];
+const { build } = await import(pathToFileURL(createRequire(require.resolve('tsx')).resolve('esbuild')).href);
+await mkdir(out, { recursive: true });
+const fixture = `import React, {useState} from 'react';
+import {createRoot} from 'react-dom/client';
+import {ReviewFlowCell} from './src/client/ChoreographedFlow.tsx';
+function Demo(){
+  const [config,setConfig]=useState({hidden:true,instant:false,motion:true,height:160});
+  window.review={set:patch=>setConfig(previous=>({...previous,...patch}))};
+  return <ReviewFlowCell {...config} rowKey="probe"><div data-review-content style={{height:config.height,background:'#dae7f5'}}>FlowCell content</div></ReviewFlowCell>;
+}
+createRoot(document.getElementById('app')).render(<Demo/>);`;
+for (const variant of variants) {
+  const source = variant === 'baseline'
+    ? execFileSync('git', ['show', 'v0.3.4:src/client/ChoreographedFlow.tsx'], { cwd: root, encoding: 'utf8' })
+    : await readFile(join(root, 'src/client/ChoreographedFlow.tsx'), 'utf8');
+  await build({
+    stdin: { contents: fixture, resolveDir: root, loader: 'tsx' },
+    outfile: join(out, `${variant}.js`), bundle: true, platform: 'browser', format: 'esm', jsx: 'automatic',
+    define: { 'process.env.NODE_ENV': '"production"' },
+    alias: { react: dirname(require.resolve('react/package.json')), 'react-dom': dirname(webRequire.resolve('react-dom/package.json')) },
+    loader: { '.woff2': 'dataurl', '.woff': 'dataurl', '.ttf': 'dataurl', '.svg': 'dataurl' },
+    plugins: [{ name: 'expose-exact-flowcell-for-regression', setup(builder) {
+      builder.onLoad({ filter: /ChoreographedFlow\.tsx$/ }, () => ({ contents: source + '\nexport {FlowCell as ReviewFlowCell};', loader: 'tsx', resolveDir: join(root, 'src/client') }));
+    }}],
+  });
+}
+const server = createServer(async (req, res) => {
+  const match = /^\/(baseline|fixed)\.(js|css)$/.exec(req.url);
+  if (match) {res.setHeader('Content-Type', match[2] === 'js' ? 'text/javascript' : 'text/css');res.end(await readFile(join(out, match[0].slice(1))));return;}
+  const variant = req.url === '/baseline' ? 'baseline' : 'fixed';
+  res.setHeader('Content-Type', 'text/html');
+  res.end(`<!doctype html><meta charset="utf-8"><link rel="stylesheet" href="/${variant}.css"><style>body{margin:24px;font:16px system-ui}#app{width:600px}</style><div id="app"></div><script type="module" src="/${variant}.js"></script>`);
+});
+await new Promise(done => server.listen(0, '127.0.0.1', done));
+const browser = await launchPinnedChromium();
+const results = [];
+try {
+  for (const variant of variants) {
+    const page = await browser.newPage({viewport:{width:800,height:650}});
+    const errors=[]; page.on('pageerror',e=>errors.push(String(e)));
+    await page.goto(`http://127.0.0.1:${server.address().port}/${variant}`);
+    await page.waitForFunction(()=>!!window.review);
+    const set = async patch => {await page.evaluate(patch=>window.review.set(patch),patch);await page.waitForTimeout(600);};
+    const probe = () => page.locator('[data-flow-key="probe"]').evaluate(el=>({height:el.getBoundingClientRect().height,inner:el.firstElementChild?.getBoundingClientRect().height??0,animations:el.getAnimations().length,hidden:el.hidden}));
+    const checkpoints=[];
+    await set({hidden:false}); checkpoints.push({step:'expand',...await probe()});
+    await set({height:40}); checkpoints.push({step:'content-shrink',...await probe()});
+    await page.screenshot({path:join(out,`${variant}-shrink.png`)});
+    await set({height:300}); checkpoints.push({step:'content-grow',...await probe()});
+    await set({hidden:true}); checkpoints.push({step:'collapse',...await probe()});
+    for(let i=0;i<3;i++){await set({hidden:false});checkpoints.push({step:`expand-cycle-${i+1}`,...await probe()});await set({hidden:true});checkpoints.push({step:`collapse-cycle-${i+1}`,...await probe()});}
+    await set({hidden:false});await set({instant:true,hidden:true});checkpoints.push({step:'instant-collapse',...await probe()});
+    await set({instant:false,motion:false,hidden:false});await set({height:80});checkpoints.push({step:'motion-disabled',...await probe()});
+    await set({motion:true,hidden:true});
+    await page.evaluate(()=>{window.review.set({hidden:false});setTimeout(()=>window.review.set({hidden:true}),40);setTimeout(()=>window.review.set({hidden:false}),80);});
+    await page.waitForTimeout(800);checkpoints.push({step:'rapid-reversal',...await probe()});
+    assert.deepEqual(errors,[]);
+    if(variant==='baseline'){
+      const shrunk=checkpoints.find(x=>x.step==='content-shrink');
+      assert.ok(shrunk.animations>0&&shrunk.height-shrunk.inner>100,'Baseline must reproduce stale fill and blank region');
+    }else{
+      for(const x of checkpoints){assert.equal(x.animations,0,`${x.step}: animation retained`);assert.ok(Math.abs(x.height-x.inner)<1,`${x.step}: incorrect geometry ${JSON.stringify(x)}`);}
+    }
+    results.push({variant,checkpoints,errors});await page.close();
+  }
+  const result={passed:true,baseline:variants.includes('baseline')?'v0.3.4':null,scope:'Actual FlowCell component, synthetic content; isolated pinned Chromium',results};
+  await writeFile(join(out,'result.json'),JSON.stringify(result,null,2)+'\n');
+  console.log(JSON.stringify(result));
+}finally{await browser.close();await new Promise(done=>server.close(done));}

package/scripts/verify-tool-shimmer.mjs

@@ -0,0 +1,62 @@
+/** Offline pixel regression for the shipped tool-summary CSS; no Host or model. */
+import assert from 'node:assert/strict';
+import { readFile, mkdir, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const root = resolve(import.meta.dirname, '..');
+const bundle = resolve(process.argv[2] ?? join(root, 'lib/client.js'));
+const out = join(root, '.evidence/tool-shimmer');
+await mkdir(out, { recursive: true });
+const js = await readFile(bundle, 'utf8');
+const line = js.split('\n').find(line => /const css\$\d+ = "\.\w+_root\{/.test(line));
+assert.ok(line, 'Reader CSS must be present in the shipped bundle');
+const css = JSON.parse(line.slice(line.indexOf('=') + 1).trim().replace(/;$/, ''));
+const summary = css.match(/\.(\w+_nativeToolSummary)\[data-running\]/)?.[1];
+assert.ok(summary);
+const { launchPinnedChromium } = await import(pathToFileURL(join(homedir(), '.codex/playwright-runtime/runtime.mjs')).href);
+const browser = await launchPinnedChromium();
+const results = [];
+try {
+  for (const theme of ['dark', 'light']) for (const width of [180, 800]) {
+    const page = await browser.newPage({ viewport: { width: 900, height: 120 }, deviceScaleFactor: 2 });
+    await page.setContent(`<style>${css}body{margin:20px;background:${theme === 'dark' ? '#141414' : '#fff'};--dsw-alias-label-tertiary:${theme === 'dark' ? '#aaa' : '#666'};font:14px system-ui}.row{display:flex;width:${width}px}</style><div class="row" data-motion="on"><span data-running class="${summary}">Re-run acceptance criteria verification</span></div>`);
+    const target = page.locator(`.${summary}`);
+    const capture = async time => {
+      await target.evaluate((el, time) => {
+        const animations = el.getAnimations();
+        if (animations.length !== 1) throw new Error(`Expected one animation, found ${animations.length}`);
+        animations[0].pause(); animations[0].currentTime = time;
+      }, time);
+      return target.screenshot();
+    };
+    const timing = await target.evaluate(el => el.getAnimations()[0].effect.getTiming().duration);
+    const first = await capture(0);
+    const middle = await capture(timing * .25);
+    const beforeWrap = await capture(timing - 1);
+    const afterWrap = await capture(timing);
+    assert.notDeepEqual(middle, first, 'The highlight must visibly travel across the text');
+    assert.deepEqual(beforeWrap, first, 'The sweep must fully leave the text before wrapping');
+    assert.deepEqual(afterWrap, first, 'The cycle boundary must preserve identical text pixels');
+    await writeFile(join(out, `${theme}-${width}-start.png`), first);
+    await writeFile(join(out, `${theme}-${width}-middle.png`), middle);
+    await writeFile(join(out, `${theme}-${width}-end.png`), beforeWrap);
+    const runningStyle = await target.evaluate(el => ({ repeat: getComputedStyle(el).backgroundRepeat, animationCount: el.getAnimations().length }));
+    assert.equal(runningStyle.repeat, 'no-repeat');
+    await page.locator('[data-motion]').evaluate(el => { el.dataset.motion = 'off'; });
+    assert.equal(await target.evaluate(el => el.getAnimations().length), 0, 'Reader motion-off must stop shimmer');
+    await page.locator('[data-motion]').evaluate(el => { el.dataset.motion = 'on'; });
+    await page.emulateMedia({ reducedMotion: 'reduce' });
+    const reduced = await target.evaluate(el => ({ count: el.getAnimations().length, fill: getComputedStyle(el).webkitTextFillColor }));
+    assert.equal(reduced.count, 0, 'System reduced motion must stop shimmer');
+    assert.notEqual(reduced.fill, 'rgba(0, 0, 0, 0)', 'Stopped animation must keep text readable');
+    await page.emulateMedia({ reducedMotion: 'no-preference' });
+    await target.evaluate(el => el.removeAttribute('data-running'));
+    assert.equal(await target.evaluate(el => el.getAnimations().length), 0, 'Settled tools must not shimmer');
+    results.push({ theme, width, loopPixelsContinuous: true, ...runningStyle, motionOff: true, reducedMotion: true, settled: true });
+    await page.close();
+  }
+  await writeFile(join(out, 'result.json'), JSON.stringify({ bundle, results }, null, 2));
+  console.log(JSON.stringify({ passed: true, results }));
+} finally { await browser.close(); }

package/src/client/ChoreographedFlow.tsx

@@ -70,6 +70,11 @@ function FlowCell({ hidden, instant, motion, rowKey, children, summary = false }
     const settle = () => {
       if (settled) return;
       settled = true;
+      // Expanding retires nothing: the fill only pins the measured height. Drop it
+      // now — if the cell's content later shrinks, the stale fill would hold the
+      // empty space open. Collapsing still keeps the fill until React commits
+      // the removal (see the comment above), then the cleanup cancels it.
+      if (!hidden) animation.cancel();
       setPresent(!hidden);
       release();
     };

package/src/client/Reader.module.css

@@ -250,13 +250,16 @@
     currentColor 0%, currentColor 35%,
     color-mix(in srgb, currentColor 35%, transparent) 50%,
     currentColor 65%, currentColor 100%);
-  background-size: 220% 100%;
+  /* Keep the travelling band outside the text at both loop endpoints. A single
+     tile covers the row throughout, so wrapping cannot start a second sweep. */
+  background-size: 300% 100%;
+  background-repeat: no-repeat;
   background-position: 100% 0;
   -webkit-background-clip: text; background-clip: text;
   -webkit-text-fill-color: transparent;
   animation: readerStepShimmer 1.6s linear infinite;
 }
-@keyframes readerStepShimmer { to { background-position: -120% 0; } }
+@keyframes readerStepShimmer { to { background-position: 0% 0; } }
 /* The duration stays on a step that ran long, so a slow command keeps its number;
    a fast one shows nothing once it returns. */
 .toolElapsed[data-slow] { opacity: 1; font-weight: 500;

package/src/client/Reader.tsx

@@ -815,7 +815,7 @@ export function Reader(props: ReaderProps) {
 
   // ChatView publishes data-chat-flow="" on its column. Skins treat a
   // scrollport without that hook as inspect-only and hide [data-composer-seat].
-  return <StreamMotionContext.Provider value={streamMotion}><div ref={root} className={css.root} data-reader-build="0.3.1" data-dsh-better-display="0.3.1" data-reader-wait-clock-version="input-v1" data-reader-wait-start={waitAnchor.time ?? undefined} data-motion={motion ? 'on' : 'off'} data-reader-glass={frostedGlass || undefined} data-reader-auto-fold={autoFold ? 'on' : 'off'}>
+  return <StreamMotionContext.Provider value={streamMotion}><div ref={root} className={css.root} data-reader-build="0.3.4" data-dsh-better-display="0.3.4" data-reader-wait-clock-version="input-v1" data-reader-wait-start={waitAnchor.time ?? undefined} data-motion={motion ? 'on' : 'off'} data-reader-glass={frostedGlass || undefined} data-reader-auto-fold={autoFold ? 'on' : 'off'}>
     <TimelineRail items={timelineItems} activeTurn={activeTurn} busyTurn={busyTurn} onNavigate={onNavigateTurn} />
     <div className={css.column} data-chat-flow="">
       <StickyLane kind="toolbar" className={css.toolbar}>

package/src/client/index.tsx

@@ -1,5 +1,7 @@
 import type { Context } from '@deepseek-ai/cordis';
+import type {} from '@deepseek-ai/dsh-api-remotes/client';
 import type {} from '@deepseek-ai/dsh-api-session-controller/client';
+import type {} from '@deepseek-ai/dsh-client-connection/client';
 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';

package/src/client/markdown/render.tsx

@@ -524,7 +524,8 @@ function renderImage(url: string, alt: string, key: Key, context: MarkdownRender
   let imageSrc = remote
   if (rewritten !== undefined) {
     try {
-      if (['http:', 'https:', 'blob:', 'data:'].includes(new URL(rewritten).protocol)) imageSrc = rewritten
+      const parsed = new URL(rewritten)
+      if (['http:', 'https:', 'blob:', 'data:'].includes(parsed.protocol) || rewritten.startsWith('dsh-app://app/api/file?')) imageSrc = rewritten
     } catch { /* A vocabulary result must be an absolute URL. */ }
   }
   if (imageSrc === undefined) {

package/src/client/native/ContextInjectionRow.module.css

@@ -60,3 +60,7 @@
   /* Figma 10:2482 code text: the form bodies inherit it from the scrollport. */
   font: 400 11px/16px var(--ds-font-family-code);
 }
+
+.toolChanges {
+  white-space: nowrap;
+}

package/src/client/native/ContextInjectionRow.tsx

@@ -4,6 +4,7 @@ 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. */
@@ -46,16 +47,32 @@ export function ContextInjectionRow({ content, source, provenance, producer, for
   // 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'
+      icon={view.role === 'recall' && tools === null
         ? <span data-context-recall-icon><ReferenceIcon kind="session" /></span>
         : <IconBrowseOutlineRegular size={14} />}
       chevronClassName={css.chevron}
-      title={t(view.role === 'recall' ? 'message.contextRecall' : 'message.contextInjection')}
-      collapsedContent={view.label === null ? undefined : (
+      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. */
@@ -71,13 +88,18 @@ export function ContextInjectionRow({ content, source, provenance, producer, for
         </>
       )}
       keepContentWhenOpen
-      open={open}
-      expandable
+      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}>
-        {body}
+        {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/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/platform-media.ts

@@ -1,8 +1,14 @@
-/** RC2 Chat's same-origin local media contract. Authorization stays Host-side. */
+/** Web or Desktop file route. Authorization stays Host-side. */
 export function localPathMediaUrl(protocol: string, origin: string, value: string): string | undefined {
-  if (protocol !== 'http:' && protocol !== 'https:') return undefined;
   if (!value.startsWith('/') || value.startsWith('//')) return undefined;
-  return `${origin}/api/file?path=${encodeURIComponent(value)}`;
+  if (protocol === 'http:' || protocol === 'https:') {
+    return `${origin}/api/file?path=${encodeURIComponent(value)}`;
+  }
+  // Official fileMediaUrl accepts the Desktop application base dsh-app://app/.
+  if (protocol === 'dsh-app:' && origin === 'dsh-app://app') {
+    return `dsh-app://app/api/file?path=${encodeURIComponent(value)}`;
+  }
+  return undefined;
 }
 
 export const readerPathImages = {

package/tests/context-tool-update.test.ts

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { toolUpdateRows } from '../src/client/native/tool-update.js';
+
+test('a single tool addition is its own closed row', () => {
+  assert.deepEqual(toolUpdateRows([{ type: 'tool-addition', toolName: 'search' }]), {
+    added: ['search'],
+    removed: [],
+    single: { type: 'tool-addition', toolName: 'search' },
+  });
+});
+
+test('mixed tool changes stay one expandable update', () => {
+  assert.deepEqual(toolUpdateRows([
+    { type: 'tool-addition', toolName: 'search' },
+    { type: 'tool-addition', toolName: 'read_file' },
+    { type: 'tool-removal', toolName: 'old_search' },
+  ]), {
+    added: ['search', 'read_file'],
+    removed: ['old_search'],
+    single: null,
+  });
+});
+
+test('text or a missing tool name stays a generic context row', () => {
+  assert.equal(toolUpdateRows([{ type: 'text', toolName: 'search' }]), null);
+  assert.equal(toolUpdateRows([{ type: 'tool-addition' }]), null);
+  assert.equal(toolUpdateRows([]), null);
+  assert.equal(toolUpdateRows([
+    { type: 'tool-addition', toolName: 'search' },
+    { type: 'text' },
+  ]), null);
+});

package/tests/platform-media.test.ts

@@ -14,4 +14,10 @@ test('relative, protocol-relative and non-HTTP page paths are not sent to the Ho
     assert.equal(localPathMediaUrl('http:', 'http://local', path), undefined);
   }
   assert.equal(localPathMediaUrl('file:', 'null', '/tmp/image.png'), undefined);
+  assert.equal(localPathMediaUrl('dsh-app:', 'dsh-app://other', '/tmp/image.png'), undefined);
+});
+test('Desktop file routes use the application file API', () => {
+  const url = localPathMediaUrl('dsh-app:', 'dsh-app://app', '/tmp/a.png')!;
+  assert.equal(url.startsWith('dsh-app://app/api/file?'), true);
+  assert.equal(new URL(url).searchParams.get('path'), '/tmp/a.png');
 });

package/tests/stock-install.test.ts

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { test } from 'node:test';
 import { fileURLToPath } from 'node:url';
+import semver from 'semver';
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const pkg = JSON.parse(readFileSync(resolve(root, 'package.json'), 'utf8')) as {
@@ -11,8 +12,24 @@ const pkg = JSON.parse(readFileSync(resolve(root, 'package.json'), 'utf8')) as {
   exports: Record<string, { default?: string } | string>;
   files: string[];
   dsh: { bundle?: { patch?: string } };
+  peerDependencies: Record<string, string>;
 };
 
+const HARNESS_PEER = '>=0.2.0-rc.1 <0.2.1';
+
+test('Harness 0.2.0 peer range accepts the rc.1 and stable releases', () => {
+  const peers = Object.entries(pkg.peerDependencies).filter(([name]) => name.startsWith('@deepseek-ai/dsh-'));
+  assert.ok(peers.length >= 12);
+  for (const [name, range] of peers) {
+    assert.equal(range, HARNESS_PEER, name);
+    assert.equal(semver.satisfies('0.2.0-rc.2', range), true, name);
+    assert.equal(semver.satisfies('0.2.0', range), true, name);
+    assert.equal(semver.satisfies('0.2.0-alpha.1', range), false, name);
+    assert.equal(semver.satisfies('0.2.0-alpha', range), false, name);
+    assert.equal(semver.satisfies('0.1.7-rc.2', range), false, name);
+  }
+});
+
 test('declares dsh.bundle.patch so official add joins the profile layer stack', () => {
   assert.equal(pkg.dsh.bundle?.patch, './cordis.patch.yml');
   assert.equal(existsSync(resolve(root, 'cordis.patch.yml')), true);

package/tsdown.config.ts

@@ -1,21 +1,23 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { pathToFileURL, fileURLToPath } from 'node:url';
 import type { TsdownPlugin, UserConfig } from 'tsdown';
 
-function resolveHarness(): string {
+const vendored = fileURLToPath(new URL('./tools/client-build.js', import.meta.url));
+
+function resolveHarnessAdapter(): string {
   const configured = process.env.DSHX_HARNESS?.trim();
-  if (configured) return resolve(configured);
+  if (configured) return join(resolve(configured), 'tools/dshx/src/client-build.js');
   const configPath = join(homedir(), '.config/dshx/harness');
   const recorded = existsSync(configPath) ? readFileSync(configPath, 'utf8').trim() : undefined;
   if (!recorded) {
     throw new Error('client rebuild requires a Harness root from DSHX_HARNESS or ~/.config/dshx/harness');
   }
-  return resolve(recorded);
+  return join(resolve(recorded), 'tools/dshx/src/client-build.js');
 }
 
-const adapter = join(resolveHarness(), 'tools/dshx/src/client-build.js');
+const adapter = existsSync(vendored) ? vendored : resolveHarnessAdapter();
 if (!existsSync(adapter)) throw new Error('externalClientBundle adapter is missing.');
 const { externalClientBundle } = await import(pathToFileURL(adapter).href);