dsh-better-display 0.3.7 → 0.3.9

package/tests/live-turn.test.ts

@@ -1,10 +1,10 @@
-import { test } from 'node:test';
+import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import type { AssistantChatData, ChatConversationViewNode } from '@deepseek-ai/dsh-client-ui-chat/client';
 import type { AssistantBlock, TurnLocation } from '@deepseek-ai/dsh-client-ui-conversation/client';
 import { assistantSegments, processExpanded } from '../src/client/projection.ts';
 import type { TurnBoundary } from '../src/client/projection.ts';
-import { foldSummary, presentLiveTurn, segmentLiveTurn, splitChain } from '../src/client/live-turn.ts';
+import { planProcessSeams, presentLiveTurn, segmentLiveTurn } from '../src/client/live-turn.ts';
 import type { LiveStep } from '../src/client/live-turn.ts';
 import { readerFlow } from '../src/client/tool-activity.ts';
 
@@ -31,69 +31,96 @@ function kinds(items: ReturnType<typeof presentLiveTurn>) {
   return items.map(item => item.kind === 'fold' ? ['fold', item.summary, item.steps.map(step => step.key)] : [item.kind, item.key]);
 }
 
-test('body or tool alone never folds, including after the first reasoning', () => {
-  assert.equal(splitChain([reasoning('1')]).fold, null);
-  assert.equal(splitChain([reasoning('1'), body('2')]).fold, null);
-  assert.equal(splitChain([reasoning('1'), body('2'), tool('3')]).fold, null);
-  assert.equal(splitChain([body('2'), tool('3')]).fold, null);
-  assert.equal(splitChain([other('ctx'), reasoning('1'), body('2')]).fold, null);
+test('narration is never folded; earlier process runs collapse even across narration', () => {
+  const beforeSecondReasoning = presentLiveTurn([reasoning('1'), body('2')], open);
+  assert.deepEqual(kinds(beforeSecondReasoning), [['open', '1'], ['open', '2']]);
+
+  // The first reasoning run folds in place before the narration; the narration
+  // itself stays open, and the latest reasoning stays open.
+  const afterSecondReasoning = presentLiveTurn([reasoning('1'), body('2'), reasoning('3')], open);
+  assert.deepEqual(kinds(afterSecondReasoning), [
+    ['fold', '思考×1', ['1']],
+    ['open', '2'],
+    ['open', '3'],
+  ]);
+
+  const mixed = presentLiveTurn([reasoning('1'), tool('2'), body('3'), reasoning('4'), tool('5'), reasoning('6')], open);
+  assert.deepEqual(kinds(mixed), [
+    ['fold', '思考×1 · 工具×1', ['1', '2']],
+    ['open', '3'],
+    ['fold', '思考×1 · 工具×1', ['4', '5']],
+    ['open', '6'],
+  ]);
+  assert.equal(mixed.some(item => item.kind === 'fold' && item.steps.some(step => step.kind === 'body')), false);
+  for (const item of mixed) {
+    if (item.kind === 'fold') assert.equal(item.summary.includes('输出'), false);
+  }
 });
 
-test('a second reasoning folds every prior step into one box, then a third folds everything before it', () => {
-  const first = splitChain([reasoning('1'), body('2'), tool('3')]);
-  assert.equal(first.fold, null);
-  assert.deepEqual(first.open.map(step => step.key), ['1', '2', '3']);
-
-  const second = splitChain([reasoning('1'), body('2'), tool('3'), reasoning('4')]);
-  assert.deepEqual(second.fold?.map(step => step.key), ['1', '2', '3']);
-  assert.deepEqual(second.open.map(step => step.key), ['4']);
-  assert.equal(foldSummary(second.fold!), '思考×1 · 输出×1 · 工具×1');
-  if (second.fold?.[0]?.kind !== 'reasoning') throw new Error('folded reasoning missing');
-  assert.equal(second.fold[0].blocks[0]?.kind === 'reasoning' && second.fold[0].blocks[0].text, '思考 1');
-  assert.equal(foldSummary(second.fold).includes('思考 1'), false);
-
-  const withTool = splitChain([reasoning('1'), body('2'), tool('3'), reasoning('4'), tool('5')]);
-  assert.deepEqual(withTool.fold?.map(step => step.key), ['1', '2', '3']);
-  assert.deepEqual(withTool.open.map(step => step.key), ['4', '5']);
-
-  const third = splitChain([reasoning('1'), body('2'), tool('3'), reasoning('4'), tool('5'), reasoning('6')]);
-  assert.deepEqual(third.fold?.map(step => step.key), ['1', '2', '3', '4', '5']);
-  assert.deepEqual(third.open.map(step => step.key), ['6']);
-  assert.equal(foldSummary(third.fold!), '思考×2 · 输出×1 · 工具×2');
-
-  const latest = splitChain([reasoning('1'), body('2'), tool('3'), reasoning('4'), tool('5'), reasoning('6'), body('7')]);
-  assert.deepEqual(latest.fold?.map(step => step.key), ['1', '2', '3', '4', '5']);
-  assert.deepEqual(latest.open.map(step => step.key), ['6', '7']);
+test('a second reasoning folds the foldable run before it, never narration', () => {
+  const first = presentLiveTurn([reasoning('1'), tool('2')], open);
+  assert.deepEqual(kinds(first), [['open', '1'], ['open', '2']]);
+
+  const second = presentLiveTurn([reasoning('1'), tool('2'), reasoning('3')], open);
+  assert.deepEqual(kinds(second), [['fold', '思考×1 · 工具×1', ['1', '2']], ['open', '3']]);
+  if (second[0]?.kind !== 'fold') throw new Error('missing fold');
+  if (second[0].steps[0]?.kind !== 'reasoning') throw new Error('folded reasoning missing');
+  assert.equal(second[0].steps[0].blocks[0]?.kind === 'reasoning' && second[0].steps[0].blocks[0].text, '思考 1');
+  assert.equal(second[0].summary.includes('思考 1'), false);
+
+  const grown = presentLiveTurn([reasoning('1'), tool('2'), reasoning('3'), tool('4'), reasoning('5')], open);
+  if (grown[0]?.kind !== 'fold') throw new Error('missing grown fold');
+  assert.deepEqual(grown[0].steps.map(step => step.key), ['1', '2', '3', '4']);
+  assert.deepEqual(grown.filter(item => item.kind === 'open').map(item => item.key), ['5']);
+  assert.equal(grown[0].summary, '思考×2 · 工具×2');
+
+  const narrationBetween = presentLiveTurn([reasoning('1'), body('2'), reasoning('3'), tool('4'), reasoning('5')], open);
+  assert.deepEqual(kinds(narrationBetween), [
+    ['fold', '思考×1', ['1']],
+    ['open', '2'],
+    ['fold', '思考×1 · 工具×1', ['3', '4']],
+    ['open', '5'],
+  ]);
 });
 
 test('fold presentation keeps prior step keys so the reader can collapse the same process fragments in place', () => {
-  const chain = [reasoning('1'), body('2'), tool('3')];
+  const chain = [reasoning('1'), tool('2')];
   const before = presentLiveTurn(chain, open);
-  assert.deepEqual(before.map(item => item.key), ['1', '2', '3']);
+  assert.deepEqual(before.map(item => item.key), ['1', '2']);
 
-  const second = presentLiveTurn([...chain, reasoning('4')], open);
+  const second = presentLiveTurn([...chain, reasoning('3')], open);
   assert.equal(second[0]?.kind, 'fold');
   if (second[0]?.kind !== 'fold') throw new Error('missing fold');
   assert.equal(second[0].key, 'live-fold:1');
   assert.deepEqual(second[0].steps.map(step => step.key), before.map(item => item.key));
-  assert.deepEqual(second.filter(item => item.kind === 'open').map(item => item.key), ['4']);
+  assert.deepEqual(second.filter(item => item.kind === 'open').map(item => item.key), ['3']);
 
-  const third = presentLiveTurn([...chain, reasoning('4'), tool('5'), reasoning('6')], open);
+  const third = presentLiveTurn([...chain, reasoning('3'), tool('4'), reasoning('5')], open);
   if (third[0]?.kind !== 'fold') throw new Error('missing grown fold');
   assert.equal(third[0].key, 'live-fold:1');
-  assert.deepEqual(third[0].steps.map(step => step.key), ['1', '2', '3', '4', '5']);
+  assert.deepEqual(third[0].steps.map(step => step.key), ['1', '2', '3', '4']);
 });
 
-test('presentLiveTurn keeps a single prior box rather than one fold per step', () => {
-  const items = presentLiveTurn([reasoning('1'), body('2'), tool('3'), reasoning('4'), tool('5'), reasoning('6'), body('7')], open);
+test('presentLiveTurn keeps one fold box per foldable run and never hides narration', () => {
+  const items = presentLiveTurn([reasoning('1'), tool('2'), reasoning('3'), tool('4'), reasoning('5')], open);
   const folds = items.filter(item => item.kind === 'fold');
   assert.equal(folds.length, 1);
   if (folds[0]?.kind !== 'fold') throw new Error('missing fold');
-  assert.equal(folds[0].steps.length, 5);
-  assert.deepEqual(items.filter(item => item.kind === 'open').map(item => item.key), ['6', '7']);
+  assert.equal(folds[0].steps.length, 4);
+  assert.deepEqual(items.filter(item => item.kind === 'open').map(item => item.key), ['5']);
+
+  const withNarration = presentLiveTurn([reasoning('1'), tool('2'), body('3'), reasoning('4'), tool('5'), reasoning('6')], open);
+  const narratedFolds = withNarration.filter(item => item.kind === 'fold');
+  assert.equal(narratedFolds.length, 2);
+  assert.deepEqual(withNarration.filter(item => item.kind === 'open').map(item => item.key), ['3', '6']);
+  assert.deepEqual(narratedFolds.map(fold => fold.kind === 'fold' ? fold.steps.map(step => step.key) : []), [['1', '2'], ['4', '5']]);
+  for (const fold of narratedFolds) {
+    if (fold.kind !== 'fold') continue;
+    assert.equal(fold.steps.some(step => step.kind === 'body'), false);
+  }
 });
 
-test('mid-turn user insert resets the chain; only the next reasoning folds post-insert priors', () => {
+test('mid-turn user insert resets the chain; narration stays open across the reset', () => {
   const before = presentLiveTurn([reasoning('1'), body('2'), tool('3'), user('insert'), body('4'), tool('5')], open);
   assert.deepEqual(kinds(before), [
     ['open', '1'], ['open', '2'], ['open', '3'],
@@ -105,28 +132,30 @@ test('mid-turn user insert resets the chain; only the next reasoning folds post-
   assert.deepEqual(kinds(after), [
     ['open', '1'], ['open', '2'], ['open', '3'],
     ['user', 'insert'],
-    ['fold', '输出×1 · 工具×1', ['4', '5']],
+    ['open', '4'],
+    ['fold', '工具×1', ['5']],
     ['open', '6'],
   ]);
   const folds = after.filter(item => item.kind === 'fold');
   assert.equal(folds.length, 1);
   if (folds[0]?.kind !== 'fold') throw new Error('missing insert fold');
-  assert.ok(!folds[0].steps.some(step => ['1', '2', '3', 'insert'].includes(step.key)));
+  assert.ok(!folds[0].steps.some(step => ['1', '2', '3', '4', 'insert'].includes(step.key)));
 });
 
-test('each chain has at most one fold box; a later chain does not split priors into per-step folds', () => {
+test('every prior process run folds in its own place; narration stays open between runs', () => {
   const items = presentLiveTurn([
-    reasoning('1'), body('2'), tool('3'), reasoning('4'),
-    user('insert'),
-    body('5'), tool('6'), reasoning('7'),
+    reasoning('1'), tool('2'), reasoning('3'),
+    body('4'),
+    tool('5'), reasoning('6'), tool('7'), reasoning('8'),
   ], open);
   const folds = items.filter(item => item.kind === 'fold');
   assert.equal(folds.length, 2);
-  if (folds[0]?.kind !== 'fold' || folds[1]?.kind !== 'fold') throw new Error('expected one box per chain');
+  if (folds[0]?.kind !== 'fold' || folds[1]?.kind !== 'fold') throw new Error('expected one box per run');
   assert.deepEqual(folds[0].steps.map(step => step.key), ['1', '2', '3']);
-  assert.deepEqual(folds[1].steps.map(step => step.key), ['5', '6']);
-  assert.equal(folds[0].summary, '思考×1 · 输出×1 · 工具×1');
-  assert.equal(folds[1].summary, '输出×1 · 工具×1');
+  assert.deepEqual(folds[1].steps.map(step => step.key), ['5', '6', '7']);
+  assert.equal(folds[0].summary, '思考×2 · 工具×1');
+  assert.equal(folds[1].summary, '思考×1 · 工具×2');
+  assert.deepEqual(items.filter(item => item.kind === 'open').map(item => item.key), ['4', '8']);
 });
 
 test('successful turn close disables live fold so the existing final-answer rules still apply', () => {
@@ -216,3 +245,45 @@ test('disabling auto-fold keeps all steps open as plain streaming steps', () =>
   assert.deepEqual(items.map(item => item.key), ['1', '2', '3', '4', '5', '6']);
   assert.deepEqual(items.map(item => item.kind), ['open', 'open', 'open', 'open', 'open', 'open']);
 });
+
+/** Issue #73: body, then a process run, then another body, then a later reasoning. */
+function issue73Steps(): LiveStep[] {
+  return [
+    body('body1'),
+    reasoning('r1'), reasoning('r2'),
+    tool('t1'), tool('t2'), tool('t3'),
+    other('rec1'),
+    body('body2'),
+    reasoning('rLatest'),
+  ];
+}
+
+test('open turn does not seam a run the live fold already summarises (#73)', () => {
+  const steps = issue73Steps();
+  const live = presentLiveTurn(steps, open, true);
+  const folds = live.filter(item => item.kind === 'fold');
+  assert.equal(folds.length, 1);
+  if (folds[0]?.kind !== 'fold') throw new Error('missing live fold');
+  assert.equal(folds[0].summary, '思考×2 · 工具×3 · 记录×1');
+  assert.deepEqual(folds[0].steps.map(step => step.key), ['r1', 'r2', 't1', 't2', 't3', 'rec1']);
+
+  const seams = planProcessSeams(steps, live, false);
+  assert.equal(seams.before.has('body2'), false);
+  assert.equal(seams.after.has('body1'), false);
+  assert.equal(seams.before.size, 0);
+  assert.equal(seams.after.size, 0);
+});
+
+test('closed turn keeps the seam between narration blocks and the previous body spacing (#73)', () => {
+  const steps = issue73Steps();
+  const live = presentLiveTurn(steps, completed, true);
+  assert.equal(live.some(item => item.kind === 'fold'), false);
+
+  const seams = planProcessSeams(steps, live, false);
+  assert.equal(seams.before.get('body2'), '思考×2 · 工具×3 · 记录×1');
+  assert.equal(seams.after.has('body1'), true);
+
+  const expanded = planProcessSeams(steps, live, true);
+  assert.equal(expanded.before.size, 0);
+  assert.equal(expanded.after.size, 0);
+});

package/tests/log.test.ts

@@ -0,0 +1,99 @@
+import assert from 'node:assert/strict';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Socket } from 'node:net';
+import { test } from 'vitest';
+import { createLogger, redact, REDACTED, requestIdOf } from '../src/log.js';
+import { apply } from '../src/dsh-better-display.js';
+import { ROUTE_REVEAL } from '../src/metrics.js';
+
+const SECRET = 's3cr3t-token-value';
+
+test('logger redacts authorization headers, tokens, and secret-looking query values', () => {
+  const lines: string[] = [];
+  const logger = createLogger({ write: line => lines.push(line), clock: () => new Date('2026-10-20T00:00:00.000Z') });
+  logger.info('http request', {
+    headers: {
+      authorization: `Bearer ${SECRET}`,
+      'x-api-key': SECRET,
+      'x-request-id': 'req-1',
+      accept: 'application/json',
+    },
+    url: `/better-display/skill-status?cwd=/work&token=${SECRET}&api_key=${SECRET}&password=${SECRET}`,
+    token: SECRET,
+    access_token: SECRET,
+  });
+  const record = JSON.parse(lines[0] ?? '{}') as {
+    level: string;
+    msg: string;
+    time: string;
+    headers: { authorization: string; 'x-api-key': string; 'x-request-id': string; accept: string };
+    url: string;
+    token: string;
+    access_token: string;
+  };
+  const text = lines.join('\n');
+  assert.equal(record.level, 'info');
+  assert.equal(record.msg, 'http request');
+  assert.equal(record.time, '2026-10-20T00:00:00.000Z');
+  assert.equal(record.headers.authorization, REDACTED);
+  assert.equal(record.headers['x-api-key'], REDACTED);
+  assert.equal(record.token, REDACTED);
+  assert.equal(record.access_token, REDACTED);
+  assert.equal(record.headers['x-request-id'], 'req-1');
+  assert.equal(record.headers.accept, 'application/json');
+  assert.match(record.url, /cwd=\/work/);
+  assert.match(record.url, /token=\[REDACTED\]/);
+  assert.match(record.url, /api_key=\[REDACTED\]/);
+  assert.match(record.url, /password=\[REDACTED\]/);
+  assert.equal(text.includes(SECRET), false);
+  assert.deepEqual(redact({ authorization: `Bearer ${SECRET}`, accept: 'application/json' }), {
+    authorization: REDACTED,
+    accept: 'application/json',
+  });
+});
+
+test('request ids keep a safe X-Request-ID and replace anything else', () => {
+  const kept = requestIdOf({ headers: { 'x-request-id': 'req.trace_1:part-a' } } as IncomingMessage);
+  assert.equal(kept, 'req.trace_1:part-a');
+  const firstOfMany = requestIdOf({ headers: { 'x-request-id': ['batch-7', 'batch-8'] } } as IncomingMessage);
+  assert.equal(firstOfMany, 'batch-7');
+  const generated = requestIdOf({ headers: { 'x-request-id': 'bad id\ninjected' } } as IncomingMessage);
+  assert.notEqual(generated, 'bad id\ninjected');
+  assert.match(generated, /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+  assert.match(requestIdOf({ headers: {} } as IncomingMessage), /^[0-9a-f-]{36}$/);
+});
+
+test('reveal handler logs the request id and does not log the secret query', () => {
+  const lines: string[] = [];
+  const original = console.log;
+  console.log = (line?: unknown) => { lines.push(String(line)); };
+  try {
+    const routes: { path: string; handler: (req: IncomingMessage, res: ServerResponse) => void }[] = [];
+    apply({
+      webServer: {
+        register(route: { path: string; handler: (req: IncomingMessage, res: ServerResponse) => void }) {
+          routes.push(route);
+          return () => undefined;
+        },
+      },
+      effect(run: () => void) { run(); },
+    } as never, { flags: { readerEnabled: true } });
+    const reveal = routes.find(route => route.path === ROUTE_REVEAL);
+    assert.ok(reveal);
+    const req = new IncomingMessage(new Socket());
+    req.method = 'GET';
+    req.url = `${ROUTE_REVEAL}?cwd=/work&token=${SECRET}`;
+    req.headers = { authorization: `Bearer ${SECRET}`, 'x-request-id': 'req-reveal-1' };
+    const res = new ServerResponse(req);
+    res.end = (() => res) as ServerResponse['end'];
+    reveal.handler(req, res);
+    assert.equal(res.statusCode, 405);
+    assert.equal(res.getHeader('X-Request-ID'), 'req-reveal-1');
+    const text = lines.join('\n');
+    assert.match(text, /\[my-plugins\/dsh-better-display\] loaded/);
+    assert.match(text, /req-reveal-1/);
+    assert.equal(text.includes(SECRET), false);
+  } finally {
+    console.log = original;
+  }
+});

package/tests/mcp-apps.test.ts

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { test } from 'node:test';
+import { test } from 'vitest';
 import type { Code } from 'mdast';
 import {
   isMcpAppCodeBlock,

package/tests/message-chrome.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'node:test';
+import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import { formatMessageClock, formatRanFor, formatRunDuration } from '../src/client/message-chrome.ts';
 

package/tests/metrics.test.ts

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Socket } from 'node:net';
+import { test } from 'vitest';
+import { apply } from '../src/dsh-better-display.js';
+import { metricsPayload, recordRouteDuration, recordRouteHit, ROUTE_METRICS, ROUTE_REVEAL, ROUTE_SKILL_STATUS } from '../src/metrics.js';
+
+test('route hit counter increments', () => {
+  const before = metricsPayload();
+  const hitsBefore = before.counters.dsh_better_display_route_hits_total[ROUTE_REVEAL] ?? 0;
+  const totalBefore = before.timingsMs[ROUTE_REVEAL]?.totalMs ?? 0;
+  const next = recordRouteHit(ROUTE_REVEAL);
+  recordRouteDuration(ROUTE_REVEAL, 12.4);
+  const after = metricsPayload();
+  assert.equal(next, hitsBefore + 1);
+  assert.equal(after.counters.dsh_better_display_route_hits_total[ROUTE_REVEAL], hitsBefore + 1);
+  assert.equal(after.timingsMs[ROUTE_REVEAL]?.totalMs, totalBefore + 12);
+  assert.ok((after.timingsMs[ROUTE_REVEAL]?.maxMs ?? 0) >= 12);
+});
+
+test('GET /better-display/metrics returns the incremented route counter', () => {
+  const routes: { path: string; handler: (req: IncomingMessage, res: ServerResponse) => void }[] = [];
+  apply({
+    webServer: {
+      register(route: { path: string; handler: (req: IncomingMessage, res: ServerResponse) => void }) {
+        routes.push(route);
+        return () => undefined;
+      },
+    },
+    effect(run: () => void) { run(); },
+  } as never, { flags: { readerEnabled: true } });
+  assert.deepEqual(routes.map(route => route.path).sort(), [ROUTE_METRICS, ROUTE_REVEAL, ROUTE_SKILL_STATUS].sort());
+  const metrics = routes.find(route => route.path === ROUTE_METRICS);
+  assert.ok(metrics);
+  const before = metricsPayload().counters.dsh_better_display_route_hits_total[ROUTE_METRICS] ?? 0;
+  const req = new IncomingMessage(new Socket());
+  req.method = 'GET';
+  req.url = ROUTE_METRICS;
+  req.headers = { 'x-request-id': 'req-metrics-1' };
+  const res = new ServerResponse(req);
+  let body = '';
+  res.end = ((chunk?: string) => {
+    body = chunk ?? '';
+    return res;
+  }) as ServerResponse['end'];
+  metrics.handler(req, res);
+  assert.equal(res.statusCode, 200);
+  assert.equal(res.getHeader('content-type'), 'application/json');
+  assert.equal(res.getHeader('X-Request-ID'), 'req-metrics-1');
+  const parsed = JSON.parse(body) as { counters: { dsh_better_display_route_hits_total: Record<string, number> } };
+  assert.equal(parsed.counters.dsh_better_display_route_hits_total[ROUTE_METRICS], before + 1);
+});

package/tests/official-slots.test.ts

@@ -1,8 +1,8 @@
 import assert from 'node:assert/strict';
-import test from 'node:test';
+import { test } from 'vitest';
 import { memo } from 'react';
 import { SlotCore } from '@deepseek-ai/dsh-client-ui-slots';
-import { mirrorOfficialSlot, readerTailMatch, type CompositionRegistry } from '../src/client/official-slots.js';
+import { acceptMirroredChatNode, mirrorOfficialSlot, readerTailMatch, type CompositionRegistry } from '../src/client/official-slots.js';
 
 function registry(kind: 'keyed' | 'chain' | 'list' = 'keyed') {
   const core = new SlotCore();
@@ -96,6 +96,45 @@ test('new registrations do not remount existing cards; winner changes and unload
   assert.equal(core.entriesOfSlot('reader').length, 0);
 });
 
+test('a lower-priority assistant-step replacement is mirrored and the official renderer is not', () => {
+  const { core, slots, register } = registry();
+  const official = memo(() => null);
+  const foreign = memo(() => null);
+  const tool = memo(() => null);
+  const user = memo(() => null);
+  register({ name: 'source', key: 'assistant-step' }, official);
+  register({ name: 'source', key: 'assistant-step', priority: -10 }, foreign);
+  register({ name: 'source', key: 'tool-call', priority: -10 }, tool);
+  register({ name: 'source', key: 'turn-process' }, memo(() => null));
+  register({ name: 'source', key: 'user' }, user);
+  const winner = core.entriesOfSlot('source').find(entry => entry.options.key === 'assistant-step');
+  assert.ok(winner);
+  assert.equal(acceptMirroredChatNode(winner), true);
+  assert.equal(winner.component, foreign);
+  const stop = mirrorOfficialSlot(slots, 'source', 'reader', 'reader.children', acceptMirroredChatNode);
+  const mirrored = core.entriesOfSlot('reader');
+  assert.deepEqual(mirrored.map(entry => entry.options.key).sort(), ['assistant-step', 'user']);
+  assert.equal(mirrored.find(entry => entry.options.key === 'assistant-step')?.component, foreign);
+  assert.equal(mirrored.find(entry => entry.options.key === 'assistant-step')?.options.priority, -10);
+  assert.equal(mirrored.some(entry => entry.component === official || entry.component === tool), false);
+  stop();
+  assert.equal(core.entriesOfSlot('reader').length, 0);
+  assert.equal(core.entriesOfSlot('source').find(entry => entry.options.key === 'assistant-step')?.component, foreign);
+});
+
+test('the official assistant-step priority stays on the source slot', () => {
+  const { core, slots, register } = registry();
+  const official = memo(() => null);
+  register({ name: 'source', key: 'assistant-step', priority: 0 }, official);
+  const entry = core.entriesOfSlot('source')[0];
+  assert.ok(entry);
+  assert.equal(acceptMirroredChatNode(entry), false);
+  const stop = mirrorOfficialSlot(slots, 'source', 'reader', 'reader.children', acceptMirroredChatNode);
+  assert.equal(core.entriesOfSlot('reader').length, 0);
+  assert.equal(core.entriesOfSlot('source')[0]?.component, official);
+  stop();
+});
+
 test('partial setup rolls back its own registrations on a nested contract failure', () => {
   const { core, slots, register } = registry();
   register({ name: 'source', key: 'nested', children: { detail: { kind: 'single', scope: 'session' } } }, () => null);

package/tests/open-file.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'node:test';
+import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';

package/tests/pending-submission.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'node:test';
+import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
@@ -35,6 +35,17 @@ test('pendingSubmissions that is not an array is treated as empty', () => {
   assert.deepEqual(asReadonlyArray([{ requestId: 'a' }]), [{ requestId: 'a' }]);
 });
 
+test('pending submission bubble keeps the host font metrics', () => {
+  const source = readFileSync(resolve(root, 'src/client/Reader.tsx'), 'utf8');
+  const css = readFileSync(resolve(root, 'src/client/Reader.module.css'), 'utf8');
+  assert.match(source, /data-reader-pending-submission[\s\S]*className=\{css\.user\}/);
+  const user = css.match(/\.user\s*\{[^}]*\}/)?.[0] ?? '';
+  assert.match(user, /font-size:\s*var\(--dsh-content-font-size,\s*14px\)/);
+  assert.match(user, /line-height:\s*calc\(22px \+ var\(--dsh-content-font-delta,\s*0px\)\)/);
+  assert.match(user, /font-weight:\s*400/);
+  assert.match(user, /white-space:\s*pre-wrap/);
+});
+
 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/);

package/tests/pinned-selection.test.ts

@@ -0,0 +1,16 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+const read = (path: string) => readFileSync(new URL(path, import.meta.url), 'utf8');
+
+describe('pinned selection', () => {
+  it('covers every Reader body marker, so final formatting keeps a live selection', () => {
+    const reader = [read('../src/client/Reader.tsx'), read('../src/client/AssistantNode.tsx')].join('\n');
+    const motion = read('../src/client/motion.tsx');
+    const selector = /usePinnedSelection\([^)]*selector = '([^']+)'/.exec(motion)?.[1] ?? '';
+    const markers = ['data-reader-answer', 'data-reader-body'].filter(marker => new RegExp(`<article[^>]*\\b${marker}\\b`).test(reader));
+    expect(markers.length).toBeGreaterThan(0);
+    for (const marker of markers) expect(selector).toContain(`[${marker}]`);
+    expect(selector).toContain('[data-reader-process]');
+  });
+});

package/tests/platform-media.test.ts

@@ -1,4 +1,4 @@
-import test from 'node:test';
+import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import { localPathMediaUrl } from '../src/client/platform-media.js';
 

package/tests/projection.test.ts

@@ -1,8 +1,9 @@
-import { test } from 'node:test';
+import { test } from 'vitest';
 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 { visibleChatKeys } from '../src/client/rewind-cut.ts';
 import type { TurnBoundary } from '../src/client/projection.ts';
 import { activityPhase, activitySummary, inputFields, readerFlow } from '../src/client/tool-activity.ts';
 
@@ -70,14 +71,15 @@ test('reading during a run does not keep the completed process open; reopening a
   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', () => {
+test('body-only steps never advertise process content, even when they are earlier narration', () => {
   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);
+  // Earlier narration stays visible, so it is not a thinking/process disclosure.
+  assert.equal(hasProcessContent(node(assistant({ step: 1 })), completed), false);
   assert.equal(hasProcessContent({ ...closing, visibility: 'hidden' }, completed), false);
 });
 
@@ -175,6 +177,67 @@ test('a nonzero terminal exit is a failure even when the tool transport is non-e
   assert.equal(activityPhase({}, true), 'interrupted');
 });
 
+test('a supplementary rewind does not restore a tool draft from a cut step', () => {
+  const liveDraft = { kind: 'tool-call' as const, callId: 'live-tool', name: 'bash', argsRaw: '{"command":"pwd"}' };
+  const earlyCutDraft = { kind: 'tool-call' as const, callId: 'early-cut', name: 'bash', argsRaw: '{"command":"echo EARLY"}' };
+  const cutDraft = { kind: 'tool-call' as const, callId: 'cut-tool', name: 'bash', argsRaw: '{"command":"echo WITHDRAWN_TOOL"}' };
+  const orphanDraft = { kind: 'tool-call' as const, callId: 'orphan-cut', name: 'bash', argsRaw: '{"command":"echo ORPHAN"}' };
+  const turn = {
+    turn: 1,
+    steps: [
+      { step: 0, start: { seq: 2 }, data: new Map([['assistant-step', { blocks: [liveDraft, earlyCutDraft] }]]) },
+      { step: 1, start: { seq: 4 }, data: new Map([['assistant-step', { blocks: [cutDraft, orphanDraft] }]]) },
+    ],
+  } as unknown as TurnLocation;
+  const rows = [
+    { key: 'user', kind: 'user', anchorSeq: 1, visibility: 'visible', location: { kind: 'turn', turn }, data: {} },
+    { key: 'supplement', kind: 'steering', anchorSeq: 3, visibility: 'visible', location: { kind: 'turn', turn }, data: {} },
+    { key: 'early-tool', kind: 'tool-call', anchorSeq: 4, visibility: 'visible', location: { kind: 'turn', turn }, data: { root: { callId: 'early-cut', name: 'bash', argsRaw: '{}' } } },
+    { key: 'tool', kind: 'tool-call', anchorSeq: 5, visibility: 'visible', location: { kind: 'turn', turn }, data: { root: { callId: 'cut-tool', name: 'bash', argsRaw: '{}' } } },
+    { key: 'cmd', kind: 'command', anchorSeq: 6, visibility: 'visible', location: { kind: 'none' }, data: { name: 'rewind-plugin', args: '@3 chat', outcome: { kind: 'success', sourceEventSeq: 7 } } },
+  ] as unknown as ChatConversationViewNode[];
+  const byKey = new Map(rows.map(node => [node.key, node]));
+  const order = rows.map(node => node.key);
+  const visible = visibleChatKeys({ order, nodes: byKey });
+  assert.deepEqual([...visible], ['user']);
+  const group = groupNodes(visible, key => byKey.get(key))[0];
+  if (!group) throw new Error('missing turn group');
+  const mainKeys = byKey.get(group.keys[0] ?? '')?.kind === 'user' ? group.keys.slice(1) : group.keys;
+  const flow = readerFlow({ ...group, keys: mainKeys }, turn, key => byKey.get(key), order);
+  const toolKeys = flow.filter(entry => entry.kind === 'tool').map(entry => entry.key);
+  assert.deepEqual(toolKeys, ['reader-tool:live-tool']);
+
+  const hiddenDraft = { kind: 'tool-call' as const, callId: 'hidden-call', name: 'write', argsRaw: '{"file_path":"/work/view.html"}' };
+  const hiddenTurn = {
+    turn: 2,
+    steps: [{ step: 0, start: { seq: 1 }, data: new Map([['assistant-step', { blocks: [hiddenDraft] }]]) }],
+  } as unknown as TurnLocation;
+  const hiddenNode = {
+    key: 'hidden-tool', kind: 'tool-call', anchorSeq: 2, visibility: 'hidden',
+    location: { kind: 'turn', turn: hiddenTurn },
+    data: { root: { callId: 'hidden-call', name: 'write', argsRaw: '{}' } },
+  } as unknown as ChatConversationViewNode;
+  const hiddenOrder = ['hidden-tool'];
+  const hiddenFlow = readerFlow(
+    { key: 'turn:2', turn: 2, keys: [] },
+    hiddenTurn,
+    key => key === hiddenNode.key ? hiddenNode : undefined,
+    hiddenOrder,
+  );
+  assert.equal(hiddenFlow[0]?.kind === 'tool' && hiddenFlow[0].key, 'reader-tool:hidden-call');
+
+  const previewRows = [
+    { key: 'user', kind: 'user', anchorSeq: 1, visibility: 'visible', location: { kind: 'turn', turn }, data: {} },
+    { key: 'preview', kind: 'command', anchorSeq: 8, visibility: 'visible', location: { kind: 'none' }, data: { name: 'rewind-plugin', args: 'preview @3 both', outcome: { kind: 'success', sourceEventSeq: 9 } } },
+  ] as unknown as ChatConversationViewNode[];
+  const previewByKey = new Map(previewRows.map(node => [node.key, node]));
+  const previewOrder = previewRows.map(node => node.key);
+  const previewFlow = readerFlow({ ...group, keys: mainKeys }, turn, key => previewByKey.get(key) ?? byKey.get(key), previewOrder);
+  const previewTools = previewFlow.filter(entry => entry.kind === 'tool').map(entry => entry.key);
+  assert.ok(previewTools.includes('reader-tool:cut-tool'));
+  assert.ok(previewTools.includes('reader-tool:live-tool'));
+});
+
 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);