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

package/tests/pending-submission.test.ts

@@ -0,0 +1,45 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { asReadonlyArray, pendingSubmissionImages } from '../src/client/pending-submission.ts';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+test('text-only pending submission does not throw on missing images', () => {
+  const echo = { requestId: 'r1', text: 'hello', time: 1 };
+  assert.doesNotThrow(() => pendingSubmissionImages(echo).length);
+  assert.deepEqual(pendingSubmissionImages(echo), []);
+  assert.deepEqual(pendingSubmissionImages({ images: undefined }), []);
+  assert.deepEqual(pendingSubmissionImages({ attachments: undefined }), []);
+  assert.deepEqual(pendingSubmissionImages(undefined), []);
+  assert.deepEqual(pendingSubmissionImages(null), []);
+});
+
+test('official images and legacy attachments both resolve', () => {
+  assert.deepEqual(
+    pendingSubmissionImages({ images: [{ previewUrl: 'blob:a', width: 4, height: 3, name: 'a.png' }] }),
+    [{ previewUrl: 'blob:a', width: 4, height: 3, name: 'a.png' }],
+  );
+  assert.deepEqual(
+    pendingSubmissionImages({ attachments: [{ type: 'image', value: { previewUrl: 'blob:b' } }, { type: 'file' }] }),
+    [{ previewUrl: 'blob:b' }],
+  );
+});
+
+test('pendingSubmissions that is not an array is treated as empty', () => {
+  assert.deepEqual(asReadonlyArray(undefined), []);
+  assert.deepEqual(asReadonlyArray(null), []);
+  assert.deepEqual(asReadonlyArray({ length: 2 }), []);
+  assert.deepEqual(asReadonlyArray([{ requestId: 'a' }]), [{ requestId: 'a' }]);
+});
+
+test('Reader and committed client bundle do not read unguarded submission.images.length', () => {
+  const source = readFileSync(resolve(root, 'src/client/Reader.tsx'), 'utf8');
+  assert.match(source, /pendingSubmissionImages/);
+  assert.doesNotMatch(source, /submission\.images\.length/);
+  const client = readFileSync(resolve(root, 'lib/client.js'), 'utf8');
+  assert.doesNotMatch(client, /submission\.images\.length/);
+  assert.match(client, /pendingSubmissionImages|function pendingSubmissionImages/);
+});

package/tests/platform-media.test.ts

@@ -0,0 +1,23 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { localPathMediaUrl } from '../src/client/platform-media.js';
+
+test('absolute local image paths use the authenticated Host file API without losing authored bytes', () => {
+  for (const path of ['/tmp/a.png', '/tmp/中文 图 #1.png', '/tmp/a%20b.png', '/tmp/a?x=1&y=2.png']) {
+    const url = localPathMediaUrl('http:', 'http://127.0.0.1:43127', path)!;
+    assert.equal(new URL(url).pathname, '/api/file');
+    assert.equal(new URL(url).searchParams.get('path'), path);
+  }
+});
+test('relative, protocol-relative and non-HTTP page paths are not sent to the Host file API', () => {
+  for (const path of ['', 'relative.png', '//host/image.png', 'https://host/image.png', 'data:image/png,x', 'javascript:alert(1)']) {
+    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/projection.test.ts

@@ -0,0 +1,184 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import type { AssistantBlock, ToolCallBlock, TurnLocation } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type { AssistantChatData, ChatConversationViewNode } from '@deepseek-ai/dsh-client-ui-chat/client';
+import { assistantSegments, boundaryOf, forkAnchorSeq, groupNodes, hasProcessContent, hasVisibleBody, isEarlierNarration, processChoiceKey, processExpanded, terminalLabel, toolFailed } from '../src/client/projection.ts';
+import type { TurnBoundary } from '../src/client/projection.ts';
+import { activityPhase, activitySummary, inputFields, readerFlow } from '../src/client/tool-activity.ts';
+
+const text: AssistantBlock = { kind: 'text', text: '前序说明或回答：不能靠关键词判断。' };
+function assistant(values: Partial<AssistantChatData> = {}): AssistantChatData {
+  return { status: 'settled', turn: 1, step: 0, blocks: [text], time: 1, ...values };
+}
+const active: TurnBoundary = { status: 'open', reason: null, latestStep: 2, closingStep: null };
+const completed: TurnBoundary = { ...active, status: 'closed', reason: 'completed', closingStep: 2 };
+
+test('RC1 system prompts belong to process details', () => {
+  assert.equal(hasProcessContent({ kind: 'system-prompt', visibility: 'visible', data: { text: 'system' } } as ChatConversationViewNode, completed), true);
+});
+
+test('canonical cancellation is interrupted while genuine failures stay failed', () => {
+  const cancelled = { kind: 'tool-result', isError: true, error: { code: 'ABORTED', name: 'AbortError' }, content: [{ type: 'text', text: 'Error: tool call aborted' }], subCalls: [] } as unknown as ToolCallBlock;
+  assert.equal(activityPhase({ block: cancelled }), 'interrupted');
+  assert.equal(toolFailed(cancelled), false);
+  const failure = { ...cancelled, error: { code: 'OTHER' }, content: [{ type: 'text', text: 'failure' }], meta: { exitCode: 7 } } as ToolCallBlock;
+  assert.equal(activityPhase({ block: failure }, true), 'failed');
+  assert.equal(toolFailed(failure), true);
+});
+
+test('reasoning and body retain original order, content and identities across streaming appends', () => {
+  const first: AssistantBlock = { kind: 'reasoning', text: '**原始标点**\n  原始空格\n' };
+  const later: AssistantBlock = { kind: 'reasoning', text: '正文之后的思考' };
+  const segments = assistantSegments([first, text, later]);
+  assert.deepEqual(segments.map(part => [part.kind, part.start]), [['reasoning', 0], ['body', 1], ['reasoning', 2]]);
+  assert.deepEqual(segments.flatMap(part => part.blocks), [first, text, later]);
+  assert.equal(segments[0].blocks[0], first);
+  const append = assistantSegments([first, text, later, { kind: 'text', text: '最终正文' }]);
+  assert.deepEqual(append.slice(0, 3), segments);
+});
+
+test('a settled step alone never means final or disposable', () => {
+  assert.equal(isEarlierNarration(assistant(), { ...active, latestStep: 0 }), false);
+  assert.equal(isEarlierNarration(assistant(), { ...active, status: 'unknown' }), false);
+  assert.equal(isEarlierNarration(assistant({ status: 'running' }), active), false);
+  assert.equal(isEarlierNarration(assistant(), active), false);
+});
+
+test('process stays open through body output and later steps until successful turn completion', () => {
+  assert.equal(processExpanded(undefined, active), true);
+  assert.equal(processExpanded(undefined, { ...active, latestStep: 7 }), true);
+  assert.equal(processExpanded(undefined, completed), false);
+  assert.equal(processExpanded(undefined, { ...active, status: 'unknown' }), true);
+  for (const reason of ['error', 'aborted', 'interrupted', 'blocked', 'max-tokens', 'future-terminal']) {
+    assert.equal(processExpanded(undefined, { ...completed, reason }), true, reason);
+  }
+});
+
+test('deliberate process expansion or collapse overrides the automatic lifecycle', () => {
+  assert.equal(processExpanded(true, completed), true);
+  assert.equal(processExpanded(false, active), false);
+  assert.equal(processExpanded(false, { ...completed, reason: 'error' }), false);
+});
+
+test('reading during a run does not keep the completed process open; reopening after completion is deliberate', () => {
+  const choices: Record<string, boolean> = {};
+  choices[processChoiceKey('turn:1', active)] = true;
+  assert.equal(processExpanded(choices[processChoiceKey('turn:1', completed)], completed), false);
+  assert.equal(processChoiceKey('turn:1', active), processChoiceKey('turn:1', { ...active, latestStep: 9 }));
+  choices[processChoiceKey('turn:1', completed)] = true;
+  assert.equal(processExpanded(choices[processChoiceKey('turn:1', completed)], completed), true);
+  assert.equal(processExpanded(choices[processChoiceKey('turn:2', completed)], completed), false);
+});
+
+test('body-only steps do not advertise empty thinking, while real reasoning and earlier progress remain accessible', () => {
+  const node = (data: AssistantChatData) => ({ kind: 'assistant-step', visibility: 'visible', data }) as ChatConversationViewNode;
+  const closing = node(assistant({ step: 2 }));
+  assert.equal(hasProcessContent(closing, active), false);
+  assert.equal(hasProcessContent(closing, completed), false);
+  assert.equal(hasProcessContent(node(assistant({ step: 2, blocks: [{ kind: 'reasoning', text: '' }, text] })), completed), false);
+  assert.equal(hasProcessContent(node(assistant({ step: 2, blocks: [{ kind: 'reasoning', text: '真实思考' }, text] })), active), true);
+  assert.equal(hasProcessContent(node(assistant({ step: 1 })), completed), true);
+  assert.equal(hasProcessContent({ ...closing, visibility: 'hidden' }, completed), false);
+});
+
+test('completed turns preserve the public closing message, even with a later nontext step', () => {
+  assert.equal(isEarlierNarration(assistant({ step: 2 }), completed), false);
+  assert.equal(isEarlierNarration(assistant({ step: 1 }), { ...completed, closingStep: 1 }), false);
+  assert.equal(isEarlierNarration(assistant({ step: 0 }), { ...completed, closingStep: 1 }), true);
+  assert.equal(isEarlierNarration(assistant(), { ...completed, closingStep: null }), false);
+});
+
+test('all abnormal and unknown terminal states preserve generated prefixes', () => {
+  for (const reason of ['error', 'aborted', 'interrupted', 'blocked', 'max-tokens', 'future-terminal']) {
+    assert.equal(isEarlierNarration(assistant(), { ...completed, reason }), false, reason);
+    assert.ok(terminalLabel(reason), reason);
+  }
+  assert.equal(isEarlierNarration(assistant({ status: 'interrupted' }), completed), false);
+  assert.equal(terminalLabel('completed'), null);
+});
+
+test('images, future modalities, and mixed body blocks never disappear into process', () => {
+  const unknown: AssistantBlock = { kind: 'other', block: { type: 'mcp-app', html: '<script>window.bad=true</script>' } };
+  const image: AssistantBlock = { kind: 'image', attachment: { attachmentId: 'test-attachment' as never, width: 100, height: 100, mediaType: 'image/png', bytes: 10 } };
+  for (const blocks of [[unknown], [text, unknown], [image], [text, image]]) {
+    assert.equal(isEarlierNarration(assistant({ blocks }), completed), false);
+    assert.equal(hasVisibleBody(blocks), true);
+  }
+  assert.equal(hasVisibleBody([{ kind: 'reasoning', text: 'private display trace' }]), false);
+});
+
+test('classification never inspects wording', () => {
+  for (const value of ['Final answer:', '正在处理', '请你确认再继续', 'All done', 'Think']) {
+    assert.equal(isEarlierNarration(assistant({ step: 2, blocks: [{ kind: 'text', text: value }] }), completed), false);
+  }
+});
+
+test('structural grouping retains keys and source order and excludes host-hidden rows', () => {
+  const turn = { turn: 1, status: 'open', steps: [] } as unknown as TurnLocation;
+  const node = (key: string, kind: string, location: ChatConversationViewNode['location'], visibility: 'visible' | 'hidden' = 'visible'): ChatConversationViewNode => ({ key, id: key, kind, target: 'chat', data: {}, anchorSeq: Number(key), visibility, location });
+  const nodes = [node('1', 'user', { kind: 'unresolved' }), node('2', 'assistant-step', { kind: 'turn', turn }), node('3', 'tool-call', { kind: 'turn', turn }), node('4', 'context', { kind: 'turn', turn }, 'hidden'), node('5', 'custom', { kind: 'unresolved' })];
+  const byKey = new Map(nodes.map(row => [row.key, row]));
+  const result = groupNodes(nodes.map(row => row.key), key => byKey.get(key));
+  assert.deepEqual(result.map(group => group.keys), [['1'], ['2', '3'], ['5']]);
+  assert.deepEqual(result.flatMap(group => group.keys), ['1', '2', '3', '5']);
+  assert.equal(result[1]?.key, groupNodes([...nodes.map(row => row.key), 'missing'], key => byKey.get(key))[1]?.key);
+});
+
+test('missing historical boundaries remain explicit uncertainty', () => {
+  const boundary = boundaryOf(undefined);
+  assert.deepEqual(boundary, { status: 'unknown', reason: null, latestStep: -1, closingStep: null });
+  assert.equal(isEarlierNarration(assistant(), boundary), false);
+});
+
+test('a failed child tool is not hidden by a successful parent summary', () => {
+  const failed = { kind: 'tool-result', isError: true, content: [], subCalls: [] } as unknown as ToolCallBlock;
+  const parent = { kind: 'tool-result', isError: false, content: [], subCalls: [failed] } as unknown as ToolCallBlock;
+  assert.equal(toolFailed(parent), true);
+});
+
+test('tool input is visible before execution, including native-hidden tool-only steps', () => {
+  const draft = { kind: 'tool-call' as const, callId: 'draft-call', name: 'write', argsRaw: '{"file_path":"/work/view.html","content":"<html>\\n' };
+  const data = assistant({ status: 'running', blocks: [draft] });
+  const turn = { turn: 1, steps: [{ step: 0, start: { seq: 1 }, data: { get: () => data } }] } as unknown as TurnLocation;
+  const group = { key: 'turn:1', turn: 1, keys: [] };
+  const pending = readerFlow(group, turn, () => undefined);
+  assert.equal(pending.length, 1);
+  assert.equal(pending[0]?.kind, 'tool');
+  if (pending[0]?.kind !== 'tool') throw new Error('missing tool');
+  assert.equal(activityPhase(pending[0]), 'preparing');
+  assert.equal(activitySummary(pending[0]).title, '写入 view.html');
+  assert.equal(activitySummary(pending[0]).content, '<html>\n');
+  const block = { callId: draft.callId, name: 'write', argsRaw: draft.argsRaw, subCalls: [] } as unknown as ToolCallBlock;
+  const node = { key: 'tool-native', kind: 'tool-call', visibility: 'visible', anchorSeq: 10, data: { root: block }, location: { kind: 'step', step: { step: 0 } } } as unknown as ChatConversationViewNode;
+  const running = readerFlow({ ...group, keys: [node.key] }, turn, () => node);
+  assert.equal(running.length, 1);
+  assert.equal(running[0]?.key, pending[0].key, 'one call keeps the same React key at execution');
+});
+
+test('partial argument parsing respects JSON nesting, escapes and unfinished unicode', () => {
+  const source = JSON.stringify({ file_path: '/work/真实.html', content: '"file_path":"fake"\n你好😀', nested: { file_path: 'also fake' } });
+  for (let cut = source.indexOf('content') + 10; cut <= source.length; cut++) {
+    const fields = inputFields(source.slice(0, cut));
+    assert.equal(fields.file_path, '/work/真实.html');
+    if (typeof fields.content === 'string') assert.ok('"file_path":"fake"\n你好😀'.startsWith(fields.content));
+  }
+  assert.equal(inputFields('{"content":"start\\u4f').content, 'start');
+  assert.equal(inputFields('{"content":"slash\\\\').content, 'slash\\');
+  assert.equal(inputFields('{"nested":{"file_path":"fake"},"file_path":"real').file_path, 'real');
+});
+
+test('a nonzero terminal exit is a failure even when the tool transport is non-error', () => {
+  const block = { kind: 'tool-result', isError: false, content: [], meta: { exitCode: 7 }, subCalls: [] } as unknown as ToolCallBlock;
+  assert.equal(toolFailed(block), true);
+  assert.equal(activityPhase({ block }), 'failed');
+  assert.equal(activityPhase({ block: { ...block, meta: null } as ToolCallBlock }), 'returned');
+  assert.equal(activityPhase({}, true), 'interrupted');
+});
+
+test('fork anchor prefers the durable closing seq and never yields a missing anchor', () => {
+  assert.equal(forkAnchorSeq([{ seq: 42 }]), 42);
+  assert.equal(forkAnchorSeq([null, undefined, {}, { seq: '42' as unknown as number }, { seq: 7 }]), 7);
+  assert.equal(forkAnchorSeq([{ seq: NaN }, { seq: Infinity }, { seq: 100.5 }]), 100.5);
+  assert.equal(forkAnchorSeq([]), undefined);
+  assert.equal(forkAnchorSeq([null, {}, { seq: undefined }]), undefined);
+});

package/tests/reasoning-follow.test.ts

@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { reasoningTarget } from '../src/client/reasoning-follow.js';
+
+test('reasoning follows ordinary growth in two-line steps without passing the tail', () => {
+  assert.equal(reasoningTarget(0, 284, 224, 24), 48);
+  assert.equal(reasoningTarget(48, 284, 224, 24), 60);
+  assert.equal(reasoningTarget(0, 100, 224, 24), 0);
+  assert.equal(reasoningTarget(999, 284, 224, 24), 60);
+});
+
+test('a large reasoning burst still advances exactly two lines without skipping the middle', () => {
+  let top = 0;
+  for (const content of [400, 1200, 1500, 1500]) {
+    const target = reasoningTarget(top, content, 224, 24);
+    assert.equal(target - top, 48, 'a transport burst must not change the reference step distance');
+    assert.ok(target <= content - 224);
+    top = target;
+  }
+  while (top < 1500 - 224) {
+    const target = reasoningTarget(top, 1500, 224, 24);
+    assert.ok(target > top && target - top <= 48);
+    top = target;
+  }
+  assert.equal(top, 1500 - 224);
+  assert.equal(reasoningTarget(top, 1500, 224, 24), top, 'reaching the end must not replay the transcript');
+});
+
+test('two-line movement follows actual typography and clamps a resized viewport', () => {
+  assert.equal(reasoningTarget(28, 900, 192, 30), 88);
+  assert.equal(reasoningTarget(-50, 900, 192, 30), 60);
+  assert.equal(reasoningTarget(708, 900, 400, 30), 500);
+  assert.equal(reasoningTarget(0, 900, 192, 0), 2);
+});

package/tests/settings-copy.test.ts

@@ -0,0 +1,63 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { en, zh } from '../src/client/settings-copy.ts';
+import { CONVENTIONAL_SKILL_ROOTS, GENERATIVE_MCPAPPS_SKILL } from '../src/skill-status.ts';
+import { shortestInstallCommand } from '../src/client/skill-status.ts';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+/** User-facing surfaces must never print home/profile absolutes. */
+const LEAKED_ABSOLUTE_PATH = /\/Users\/|[A-Za-z]:\\|(?:^|[\s"'`])\/home\/|\$HOME\b|\$DSH_HOME\b|~\//;
+
+function installGuidanceSurface(): string {
+  return [
+    ...Object.values(en),
+    ...Object.values(zh),
+    shortestInstallCommand({
+      packPath: '/Users/cola/plugin/skills/generative-mcpapps',
+      roots: [
+        { source: 'user-dsh', path: '/Users/cola/.dsh/skills' },
+        { source: 'user-agents', path: 'C:\\Users\\cola\\.agents\\skills' },
+      ],
+    }),
+    ...CONVENTIONAL_SKILL_ROOTS,
+  ].join('\n');
+}
+
+test('install guidance names only relative skill roots', () => {
+  const surface = installGuidanceSurface();
+  assert.match(surface, /\.dsh\/skills/);
+  assert.match(surface, /\.agents\/skills/);
+  assert.match(surface, new RegExp(GENERATIVE_MCPAPPS_SKILL));
+  assert.doesNotMatch(surface, LEAKED_ABSOLUTE_PATH);
+  assert.doesNotMatch(surface, /\/Users\//);
+  assert.doesNotMatch(surface, /C:\\/);
+});
+
+test('Settings dictionaries mention conventional roots and the skill folder', () => {
+  for (const copy of [en, zh]) {
+    const blob = `${copy.skillInstall}\n${copy.skillUnavailable}`;
+    assert.match(blob, /\.dsh\/skills/);
+    assert.match(blob, /\.agents\/skills/);
+    assert.match(blob, /generative-mcpapps/);
+    assert.doesNotMatch(blob, LEAKED_ABSOLUTE_PATH);
+  }
+});
+
+test('committed Settings UI copy and command stay relative', () => {
+  const client = readFileSync(resolve(root, 'lib/client.js'), 'utf8');
+  const section = readFileSync(resolve(root, 'src/client/SettingsSection.tsx'), 'utf8');
+  assert.match(section, /CONVENTIONAL_SKILL_ROOTS/);
+  assert.doesNotMatch(section, /root\.path/);
+  assert.doesNotMatch(section, /shortestInstallCommand\(skill\)/);
+  assert.match(client, /\.dsh\/skills/);
+  assert.match(client, /\.agents\/skills/);
+  assert.doesNotMatch(client, /mkdir -p "\$DSH_HOME\/skills"/);
+  assert.doesNotMatch(client, /status\.packPath \?\?/);
+  assert.doesNotMatch(client, /root\.source, ": ", root\.path/);
+  assert.doesNotMatch(client, /\/Users\//);
+  assert.doesNotMatch(client, /C:\\\\/);
+});

package/tests/skill-status.test.ts

@@ -0,0 +1,137 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  CONVENTIONAL_SKILL_ROOTS,
+  GENERATIVE_MCPAPPS_SKILL,
+  SKILL_PACK_RELATIVE,
+  skillListIncludes,
+  skillNameMatches,
+  skillRootEntryMatches,
+  skillsFromListResult,
+  toPublicSkillStatus,
+} from '../src/skill-status.ts';
+import {
+  projectSkillRoots,
+  rootHasGenerativeMcpapps,
+  scanGenerativeMcpappsStatus,
+  userSkillRoots,
+} from '../src/skill-roots.ts';
+import { detectGenerativeMcpappsSkill, firstSessionId, shortestInstallCommand } from '../src/client/skill-status.ts';
+
+test('only the kebab-case skill name counts as installed', () => {
+  assert.equal(skillNameMatches(GENERATIVE_MCPAPPS_SKILL), true);
+  assert.equal(skillNameMatches('other'), false);
+  assert.equal(skillRootEntryMatches('generative-mcpapps'), true);
+  assert.equal(skillRootEntryMatches('generative-mcpapps.md'), true);
+  assert.equal(skillRootEntryMatches('skills'), false);
+  assert.equal(skillListIncludes([{ name: 'generative-mcpapps' }]), true);
+  assert.equal(skillListIncludes(skillsFromListResult({ ok: true, value: { skills: [{ name: 'generative-mcpapps' }] } })), true);
+});
+
+test('plugin-tree skills/ is not a harness skill root', () => {
+  const roots = [
+    ...projectSkillRoots('/plugin/dsh-better-display'),
+    ...userSkillRoots({ DSH_HOME: '/home/me/.dsh', DSH_AGENTS_HOME: '/home/me/.agents' }, '/home/me'),
+  ];
+  assert.deepEqual(roots.map(root => root.path), [
+    '/plugin/dsh-better-display/.dsh/skills',
+    '/plugin/dsh-better-display/.agents/skills',
+    '/home/me/.dsh/skills',
+    '/home/me/.agents/skills',
+  ]);
+  assert.equal(roots.some(root => root.path.endsWith('/dsh-better-display/skills')), false);
+});
+
+test('a real user skill root with the pack is installed; the plugin pack path is not', async () => {
+  const emptyHome = await mkdtemp(join(tmpdir(), 'dsh-bd-empty-'));
+  const skillHome = await mkdtemp(join(tmpdir(), 'dsh-bd-skill-'));
+  const userRoot = join(skillHome, '.dsh', 'skills', 'generative-mcpapps');
+  await mkdir(userRoot, { recursive: true });
+  await writeFile(join(userRoot, 'SKILL.md'), '---\nname: generative-mcpapps\ndescription: x\n---\n');
+
+  const missing = await scanGenerativeMcpappsStatus({
+    home: emptyHome,
+    env: {},
+    packPath: '/plugin/dsh-better-display/skills/generative-mcpapps',
+  });
+  const found = await scanGenerativeMcpappsStatus({
+    home: skillHome,
+    env: { DSH_HOME: join(skillHome, '.dsh') },
+    packPath: '/plugin/dsh-better-display/skills/generative-mcpapps',
+  });
+
+  assert.equal(await rootHasGenerativeMcpapps('/plugin/dsh-better-display/skills'), false);
+  assert.equal(missing.installed, false);
+  assert.equal(found.installed, true);
+  assert.equal(found.via, 'skill-root');
+  assert.equal(found.packPath, '/plugin/dsh-better-display/skills/generative-mcpapps');
+});
+
+test('client detect snapshot never carries host packPath or home roots', async () => {
+  const status = await detectGenerativeMcpappsSkill({
+    fetchHostStatus: async () => ({
+      name: 'generative-mcpapps',
+      installed: false,
+      via: null,
+      packPath: '/Users/cola/plugin/skills/generative-mcpapps',
+      roots: [{ source: 'user-dsh', path: '/Users/cola/.dsh/skills', present: false }],
+    }),
+  });
+  assert.equal(status.packPath, undefined);
+  assert.deepEqual(status.roots.map(root => root.path), [...CONVENTIONAL_SKILL_ROOTS]);
+  assert.equal(status.roots.some(root => /\/Users\/|[A-Za-z]:\\/.test(root.path)), false);
+});
+
+test('skills/list wins when the registry can see the skill', async () => {
+  const status = await detectGenerativeMcpappsSkill({
+    fetchHostStatus: async () => ({
+      name: 'generative-mcpapps',
+      installed: false,
+      via: null,
+      roots: [{ source: 'user-dsh', path: '/tmp/.dsh/skills', present: false }],
+    }),
+    listRemoteSkills: async () => [{ name: 'generative-mcpapps' }],
+  });
+  assert.equal(status.installed, true);
+  assert.equal(status.via, 'skills.list');
+});
+
+test('public skill status strips packPath and host home absolutes', () => {
+  const published = toPublicSkillStatus({
+    name: 'generative-mcpapps',
+    installed: false,
+    via: null,
+    packPath: '/Users/cola/.dsh/plugins/skills/generative-mcpapps',
+    roots: [
+      { source: 'user-dsh', path: '/Users/cola/.dsh/skills', present: false },
+      { source: 'user-agents', path: 'C:\\Users\\cola\\.agents\\skills', present: false },
+    ],
+  });
+  assert.equal(published.packPath, undefined);
+  assert.deepEqual(published.roots.map(root => root.path), [...CONVENTIONAL_SKILL_ROOTS]);
+  assert.equal(published.roots.some(root => /\/Users\/|[A-Za-z]:\\/.test(root.path)), false);
+});
+
+test('install command uses conventional relative roots only', () => {
+  const command = shortestInstallCommand({
+    packPath: '/opt/plugin/skills/generative-mcpapps',
+    roots: [{ source: 'user-dsh', path: '/home/me/.dsh/skills' }],
+  });
+  assert.match(command, /mkdir -p \.dsh\/skills/);
+  assert.match(command, new RegExp(`cp -R ${SKILL_PACK_RELATIVE.replace('/', '\\/')}`));
+  assert.match(command, /generative-mcpapps/);
+  assert.doesNotMatch(command, /\/Users\//);
+  assert.doesNotMatch(command, /[A-Za-z]:\\/);
+  assert.doesNotMatch(command, /\/home\//);
+  assert.doesNotMatch(command, /\$HOME|\$DSH_HOME/);
+  assert.doesNotMatch(command, /\/opt\//);
+});
+
+test('firstSessionId reads ids or byId keys', () => {
+  assert.equal(firstSessionId({ ids: ['a', 'b'] }), 'a');
+  assert.equal(firstSessionId({ byId: { z: {} } }), 'z');
+  assert.equal(firstSessionId(undefined), undefined);
+});

package/tests/stock-install.test.ts

@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict';
+import { existsSync, 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)), '..');
+const pkg = JSON.parse(readFileSync(resolve(root, 'package.json'), 'utf8')) as {
+  main: string;
+  scripts?: { prepare?: string };
+  exports: Record<string, { default?: string } | string>;
+  files: string[];
+  dsh: { bundle?: { patch?: string } };
+};
+
+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);
+  const patch = readFileSync(resolve(root, 'cordis.patch.yml'), 'utf8');
+  assert.match(patch, /id: dsh-better-display/);
+  assert.match(patch, /name: dsh-better-display/);
+  assert.equal(pkg.files.includes('cordis.patch.yml'), true);
+});
+
+test('commits compiled lib entries and does not require a prepare script', () => {
+  assert.equal(pkg.scripts?.prepare, undefined);
+  assert.equal(pkg.main, 'lib/dsh-better-display.js');
+  const client = pkg.exports['./client'];
+  assert.equal(typeof client === 'object' && client !== null ? client.default : client, './lib/client.js');
+  assert.equal(existsSync(resolve(root, 'lib/dsh-better-display.js')), true);
+  assert.equal(existsSync(resolve(root, 'lib/client.js')), true);
+  const clientJs = readFileSync(resolve(root, 'lib/client.js'), 'utf8');
+  assert.match(clientJs, /window\.__ModuleLoader__\.load/);
+  assert.match(clientJs, /id:\s*"dsh-better-display"/);
+  assert.match(clientJs, /settings\.section/);
+  assert.match(clientJs, /deliverableOpenMode/);
+  assert.match(clientJs, /frostedGlass/);
+  assert.match(clientJs, /foldIntensity/);
+  assert.match(clientJs, /setFrostedGlass/);
+  assert.match(clientJs, /setFoldIntensity/);
+  assert.match(clientJs, /data-reader-glass/);
+  assert.match(clientJs, /modeFromSnapshot/);
+  assert.match(clientJs, /str_replace_editor/);
+  assert.doesNotMatch(clientJs, /只折叠过程/);
+  assert.match(clientJs, /\.dsh\/skills/);
+  assert.doesNotMatch(clientJs, /submission\.images\.length/);
+});
+
+test('README leads with the official stock one-liner and names pnpm', () => {
+  for (const name of ['README.md', 'README.en.md']) {
+    const text = readFileSync(resolve(root, name), 'utf8');
+    assert.match(text, /dsh plugin --profile web add github:aa2246740\/dsh-better-display/);
+    assert.match(text, /pnpm/);
+    assert.doesNotMatch(text, /activate-new-client/);
+    assert.doesNotMatch(text, /my-plugins/);
+    assert.doesNotMatch(text, /DSHX_HARNESS/);
+  }
+});

package/tests/stream-buffer.test.ts

@@ -0,0 +1,102 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { StreamBuffer, STREAM_TIMING } from '../src/client/stream-buffer.js';
+
+test('a transport burst becomes multiple bounded, monotonically growing frames', () => {
+  const buffer = new StreamBuffer();
+  const text = '让新到的文字柔和显现，已经读过的内容保持稳定。'.repeat(6);
+  buffer.update(text, 0);
+  const frames: string[] = [];
+  let firstFrameAt: number | null = null;
+  // The reveal is paced by STREAM_TIMING, so the test asserts the invariants
+  // (many bounded frames, monotonic growth, full convergence in bounded time)
+  // rather than pinning numbers that a pacing change is expected to move.
+  for (let time = 16; time <= STREAM_TIMING.catchUpMs * 2; time += 16) {
+    const previous = buffer.visible;
+    if (buffer.advance(time)) { frames.push(buffer.visible); firstFrameAt ??= time; }
+    assert.ok(buffer.visible.startsWith(previous));
+    assert.ok(text.startsWith(buffer.visible));
+  }
+  assert.ok(frames.length > 8, `expected many reveal frames, got ${frames.length}`);
+  assert.ok(frames[0]!.length < text.length / 4);
+  assert.ok(firstFrameAt !== null && firstFrameAt <= 32, 'the first characters must appear immediately');
+  assert.equal(buffer.visible, text);
+  assert.equal(buffer.pending, false);
+});
+
+test('each received batch has a hard queue-age ceiling during continuing input', () => {
+  const buffer = new StreamBuffer();
+  const deliveries: { at: number; end: number }[] = [];
+  let text = '';
+  for (let time = 0; time <= 1200; time += 16) {
+    if (time % 64 === 0) {
+      text += '中文 English 输出片段，'.repeat(3);
+      buffer.update(text, time);
+      deliveries.push({ at: time, end: text.length });
+    }
+    buffer.advance(time);
+    for (const item of deliveries) if (time - item.at >= STREAM_TIMING.maxQueuedMs) assert.ok(buffer.visible.length >= item.end);
+  }
+});
+
+test('grapheme-safe updates do not split combined emoji, flags or accents', () => {
+  const buffer = new StreamBuffer();
+  const text = '你好👩🏽‍💻e\u0301🇨🇳👨‍👩‍👧‍👦完整。'.repeat(4);
+  const boundaries = new Set([...new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(text)].map(part => part.index));
+  boundaries.add(text.length);
+  buffer.update(text, 0);
+  for (let time = 8; time <= 256; time += 8) {
+    buffer.advance(time);
+    assert.ok(boundaries.has(buffer.visible.length), `split at ${buffer.visible.length}`);
+  }
+  assert.equal(buffer.visible, text);
+});
+
+test('a surrogate pair split across transport deliveries is never exposed half-written', () => {
+  const buffer = new StreamBuffer();
+  buffer.update('你好\uD83D', 0);
+  buffer.advance(250);
+  assert.equal(buffer.visible, '你好');
+  buffer.update('你好\uD83D\uDE00继续', 260);
+  buffer.advance(520);
+  assert.equal(buffer.visible, '你好😀继续');
+});
+
+test('completion drains the last bytes within the short finish budget', () => {
+  const buffer = new StreamBuffer();
+  const text = '最终文本'.repeat(40);
+  buffer.update(text, 0);
+  buffer.advance(16);
+  buffer.update(text, 20, { finished: true });
+  buffer.advance(20 + STREAM_TIMING.finishMs);
+  assert.equal(buffer.visible, text);
+});
+
+test('cancel, reduced motion, selected text and hidden views share an immediate flush path', () => {
+  const buffer = new StreamBuffer();
+  buffer.update('所有已经收到的文字必须保留。'.repeat(20), 0);
+  buffer.advance(16);
+  buffer.update(buffer.target, 17, { immediate: true });
+  assert.equal(buffer.visible, buffer.target);
+  assert.equal(buffer.pending, false);
+});
+
+test('history is immediate and replacement/shrink does not replay an old answer', () => {
+  const buffer = new StreamBuffer('这是已完成的历史文本。');
+  assert.equal(buffer.visible, buffer.target);
+  buffer.update('修正后的权威文本。', 0);
+  assert.equal(buffer.visible, '修正后的权威文本。');
+  assert.equal(buffer.revision, 1);
+  buffer.update('修正。', 1);
+  assert.equal(buffer.visible, '修正。');
+});
+
+test('large payloads and delayed background frames do not create a typing backlog', () => {
+  const large = new StreamBuffer();
+  large.update('x'.repeat(12000), 0);
+  assert.equal(large.visible, large.target);
+  const delayed = new StreamBuffer();
+  delayed.update('一次长时间暂停后应立刻赶上全部已收到的内容。'.repeat(20), 0);
+  delayed.advance(10000);
+  assert.equal(delayed.visible, delayed.target);
+});