Merge remote-tracking branch 'origin/master' into claude/unified-environment-credentials-c8841a

# Conflicts: # examples/headless-agent/tests/headless.snapshot.ts # examples/headless-agent/tests/snapshots/missing-credential/stream-json.expected.jsonl # packages/llm/llm-deepseek/tests/adapter.spec.ts
2026-08-06 10:52:32 +08:00
parent d8d487236f e88bace07e
commit a358d9d68a
833 changed files with 19039 additions and 14776 deletions
--- a/apps/web/tests/chat-long-interactions.e2e.ts
+++ b/apps/web/tests/chat-long-interactions.e2e.ts
@@ -260,7 +260,9 @@ describe('web e2e: long Chat interaction contract', () => {
    expect(await composer.inputValue()).toBe('')
    expect(await composer.isEnabled()).toBe(true)
    expect(source.session.events.some(event => carries(event, CONTINUE_PROMPT))).toBe(false)
-    expect(child.session.events.filter(event => carries(event, CONTINUE_PROMPT))).toHaveLength(1)
+    expect(child.session.events.filter(event => (
+      event.type === 'user/message' && carries(event, CONTINUE_PROMPT)
+    ))).toHaveLength(1)
    const lastTurnEnd = child.session.events.findLast((event): event is SessionEvent<'turn/end'> => (
      event.type === 'turn/end'
    ))
--- a/apps/web/tests/chat-scroll-fixture.ts
+++ b/apps/web/tests/chat-scroll-fixture.ts
@@ -1,7 +1,7 @@
 // Synthetic long-chat history for browser behavior contracts. The fixture is
 // generated through Session so pagination exercises the same event shapes as
-// persisted conversations, while unique markers let tests identify semantic
-// rows without depending on CSS-module names or the eventual virtualizer DOM.
+// persisted conversations, while unique markers identify semantic rows
+// without depending on CSS-module names or virtualizer DOM positions.
 import {
  CallId,
  createAssistantMessage,
@@ -184,7 +184,6 @@ export function createChatScrollFixture(options: ChatScrollFixtureOptions): Chat
  for (let turn = 1; turn <= turns; turn += 1) {
    session.append('turn/start', {
      turn,
-      trigger: { kind: 'message', source: { kind: 'user' } },
    })
    const user = session.append('user/message', createUserMessage({
      content: text(
--- a/apps/web/tests/complex-history.perf.ts
+++ b/apps/web/tests/complex-history.perf.ts
@@ -322,7 +322,6 @@ function smallSidebarFixture(): string {
  const session = Session.create(SessionId('perf-small-template'))
  session.append('turn/start', {
    turn: 1,
-    trigger: { kind: 'message', source: { kind: 'user' } },
  })
  const user = session.append('user/message', createUserMessage({
    content: text('Inspect this compact synthetic session.'),
@@ -346,7 +345,6 @@ function longHistoryFixture(): string {
  for (let turn = 1; turn <= LONG_HISTORY_TURNS; turn += 1) {
    session.append('turn/start', {
      turn,
-      trigger: { kind: 'message', source: { kind: 'user' } },
    })
    const user = session.append('user/message', createUserMessage({
      content: text(
--- a/apps/web/tests/composer-tab-geometry.e2e.ts
+++ b/apps/web/tests/composer-tab-geometry.e2e.ts
@@ -0,0 +1,420 @@
+// Web e2e scenario: the input card holds one horizontal position across the
+// Chat and Trajectory tabs.
+//
+// The composer seat is the same node in both tabs, but it measures itself
+// against a different edge in each (see
+// packages/client/ui-conversation/src/client/skeleton/ConversationRoot.module.css).
+// In Chat it is a sticky CHILD of the column's scroller, so it rides that
+// scroller's content box — the box a space-consuming scrollbar shortens. A view
+// that opts into a composer overlay (`data-conversation-composer-overlay`, which
+// Trajectory declares and which moves the column's own scrolling into the view)
+// gets an absolutely positioned seat instead, laid out against the padding box,
+// which the scrollbar never reduces.
+//
+// So the two tabs disagreed by exactly the bar's width for as long as the
+// transcript overflowed: the card jumped sideways on every tab switch, and
+// inside Chat alone at the moment a growing transcript started to scroll. The
+// column now reserves the gutter unconditionally (`scrollbar-gutter: stable`)
+// and states the overlay branch as a scroll container on the same axes, so both
+// edges are the same edge.
+//
+// Only a real engine can show this. The seat's geometry is layout: jsdom gives
+// every element a zero-sized box and reports no scrollbar at all, so a unit spec
+// can assert the declarations exist but not that the two states land in the same
+// place. What is asserted here is the user-visible fact — the card does not move
+// — measured as the distance between the two tabs' card rectangles.
+//
+// The browser is launched WITHOUT Playwright's default `--hide-scrollbars`,
+// which is load-bearing rather than incidental. Under that argument a scroll
+// container's bar consumes no layout width at all, so the two tabs agree before
+// this change as much as after it and every comparison below holds vacuously —
+// measured: the pre-fix cascade leaves both tabs' bands at 0 there, against 8
+// and 0 with the argument dropped. Dropping it is also the faithful
+// configuration: ui-theme's scrollbar.css gives `::-webkit-scrollbar` a width,
+// and a bar that occupies layout space is what the product actually draws.
+//
+// The scenario runs that pre-fix cascade in the page — `scrollbar-gutter: auto`
+// on the scroller, `overflow: hidden` on the overlay branch — and measures the
+// same two tabs through it, which is what keeps the equal rectangles above from
+// being explained by a tab switch that never reached the layout. It is the
+// reported symptom as a number: the card moves 4px, half the 8px band, on each
+// edge.
+//
+// Zero model calls: a seeded cold session renders from its log, and switching
+// tabs asks the host for nothing. A stray stream would fail loud with NO_ADAPTER.
+import { fileURLToPath } from 'node:url'
+import { join } from 'node:path'
+import type { Browser, Page } from 'playwright'
+import { chromium } from 'playwright'
+import { afterAll, beforeAll, describe, expect, it, onTestFailed } from 'vitest'
+import { createChatScrollFixture } from './chat-scroll-fixture.ts'
+import {
+  assertFixtureInventory, compareOrRefreshGolden, launchWebScaffold, seedSession, watchConsole,
+  webSnapshotMode, type WebScaffold,
+} from './scaffold.ts'
+import { newEnglishPage, saveFailureShot } from './support.ts'
+
+const SNAPSHOT_DIR = fileURLToPath(new URL('./snapshots/composer-tab-geometry', import.meta.url))
+/**
+ * Committed golden of where the input card sits in each tab, at a wide viewport
+ * (card at its width cap) and a narrow one (card shrinking with the column).
+ *
+ * Absolute coordinates are deliberately absent: they depend on the sidebar's
+ * laid-out width and on font metrics, so committing them would produce a fixture
+ * that has to be re-recorded per platform. What is recorded is the distance
+ * between the two tabs' rectangles, which is zero when the reservation holds and
+ * the bar's width when it does not — including under the control, so the golden
+ * carries the difference the fix removes rather than only its absence.
+ */
+const GEOMETRY_EXPECTED = join(SNAPSHOT_DIR, 'geometry.expected.md')
+const MODE = webSnapshotMode()
+
+/** Long enough that the transcript overflows the lane's 1000px viewport; the scenario asserts the overflow rather than trusting it. */
+const FIXTURE = createChatScrollFixture({
+  markerPrefix: 'TAB_GEOMETRY',
+  title: 'COMPOSER_TAB_GEOMETRY long session',
+  turns: 24,
+})
+const SEED_ID = 'composer-tab-geometry-web-e2e'
+
+/** Viewport widths the scenario measures at: the card capped, and the card shrinking with the column. */
+const WIDE_VIEWPORT = { width: 1680, height: 1000 }
+const NARROW_VIEWPORT = { width: 800, height: 1000 }
+
+/**
+ * Resize to one measurement viewport after the responsive sidebar and center
+ * column finish their track transition.
+ * @param page - the page under test.
+ * @param viewport - the viewport dimensions to apply.
+ * @param sidebarCollapsed - the sidebar state expected at this width.
+ */
+async function setMeasuredViewport(
+  page: Page,
+  viewport: { width: number; height: number },
+  sidebarCollapsed: boolean,
+): Promise<void> {
+  await page.setViewportSize(viewport)
+  await page.locator('[data-sidebar-collapsed="true"]').waitFor({
+    state: sidebarCollapsed ? 'attached' : 'detached',
+    timeout: 10_000,
+  })
+  await page.locator('[data-conversation-scroll]').evaluate(async (host) => {
+    const deadline = performance.now() + 5_000
+    let previous = host.getBoundingClientRect().width
+    let stableFrames = 0
+    while (performance.now() < deadline) {
+      await new Promise<void>((resolve) => { requestAnimationFrame(() => { resolve() }) })
+      const current = host.getBoundingClientRect().width
+      stableFrames = Math.abs(current - previous) < 0.01 ? stableFrames + 1 : 0
+      if (stableFrames >= 3) return
+      previous = current
+    }
+    throw new Error('conversation width did not settle after the viewport changed')
+  })
+}
+
+/**
+ * The pre-fix cascade, injected into the page: the reservation dropped and the
+ * overlay branch back to a hidden box. `!important` beats the module rules
+ * without a rebuild, and the id lets the control be lifted again in the same
+ * session.
+ */
+const CONTROL_STYLE_ID = 'composer-tab-geometry-control'
+const CONTROL_CSS = `
+[data-conversation-scroll] { scrollbar-gutter: auto !important; }
+[data-conversation-scroll]:has([data-conversation-composer-overlay]) { overflow: hidden !important; }
+`
+
+/** The column scroller and the input card as the browser lays them out, in one tab. */
+interface TabMetrics {
+  /** Resolved `scrollbar-gutter` on the column's scroller. */
+  gutter: string
+  /** Resolved `overflow-x`: `hidden` in both states, so neither grows a horizontal bar. */
+  overflowX: string
+  /** Resolved `overflow-y`: `auto` in both states, which is the form WebKit honours the gutter on. */
+  overflowY: string
+  /** Border-box width minus client width: the space the scrollbar takes out of the content area. */
+  band: number
+  /** True when the column's scroller actually scrolls — only Chat does. */
+  scrolls: boolean
+  /** Left edge of the input card in viewport coordinates. */
+  cardLeft: number
+  /** Right edge of the input card. */
+  cardRight: number
+  /** Width of the input card, capped at the composer card max width. */
+  cardWidth: number
+}
+
+/** One tab's metrics beside the other's, plus the distances between them. */
+interface TabComparison {
+  chat: TabMetrics
+  trajectory: TabMetrics
+  /** Distance between the two tabs' card left edges: 0 when the card holds its position. */
+  leftShift: number
+  /** Distance between the two tabs' card right edges. */
+  rightShift: number
+  /** Difference between the two tabs' card widths. */
+  widthShift: number
+}
+
+/**
+ * Measure the column scroller and the input card in the tab currently shown.
+ * @param page - the page under test.
+ * @returns the scroller's resolved overflow style and the card's rectangle.
+ */
+function measureTab(page: Page): Promise<TabMetrics> {
+  return page.evaluate(() => {
+    const host = document.querySelector<HTMLElement>('[data-conversation-scroll]')
+    if (host === null) throw new Error('conversation column scroller not in the DOM')
+    const card = host.querySelector<HTMLElement>('[data-composer-seat] [data-composer-card]')
+    if (card === null) throw new Error('no input card inside the composer seat')
+    const style = getComputedStyle(host)
+    const hostRect = host.getBoundingClientRect()
+    const cardRect = card.getBoundingClientRect()
+    return {
+      gutter: style.scrollbarGutter,
+      overflowX: style.overflowX,
+      overflowY: style.overflowY,
+      band: hostRect.width - host.clientWidth,
+      scrolls: host.scrollHeight > host.clientHeight,
+      cardLeft: cardRect.left,
+      cardRight: cardRect.right,
+      cardWidth: cardRect.width,
+    }
+  })
+}
+
+/**
+ * Show one tab and wait for the view that owns it to be laid out.
+ * @param page - the page under test.
+ * @param tab - the tab to show.
+ */
+async function showTab(page: Page, tab: 'Chat' | 'Trajectory'): Promise<void> {
+  await page.getByRole('tab', { name: tab, exact: true }).click()
+  if (tab === 'Trajectory') await page.getByLabel('Trajectory timeline').waitFor({ timeout: 30_000 })
+  else await page.locator('[data-conversation-scroll] [data-chat-anchor-key]').first().waitFor({ timeout: 30_000 })
+  // Both measurements are taken after a paint, so a rectangle read mid-transition
+  // cannot be reported as a shift the cascade did not cause.
+  await page.evaluate(() => new Promise<void>((settle) => {
+    requestAnimationFrame(() => { requestAnimationFrame(() => { settle() }) })
+  }))
+}
+
+/**
+ * Measure both tabs and the distances between them, leaving Chat shown.
+ * @param page - the page under test.
+ * @returns each tab's metrics and the card's displacement between them.
+ */
+async function compareTabs(page: Page): Promise<TabComparison> {
+  await showTab(page, 'Chat')
+  const chat = await measureTab(page)
+  await showTab(page, 'Trajectory')
+  const trajectory = await measureTab(page)
+  await showTab(page, 'Chat')
+  return {
+    chat,
+    trajectory,
+    leftShift: Math.abs(trajectory.cardLeft - chat.cardLeft),
+    rightShift: Math.abs(trajectory.cardRight - chat.cardRight),
+    widthShift: Math.abs(trajectory.cardWidth - chat.cardWidth),
+  }
+}
+
+/**
+ * Run the pre-fix cascade in the page for one measurement, then lift it.
+ * @param page - the page under test.
+ * @returns the comparison as the column laid out before this change.
+ */
+async function compareTabsWithoutReservation(page: Page): Promise<TabComparison> {
+  await page.evaluate(({ id, css }) => {
+    const style = document.createElement('style')
+    style.id = id
+    style.textContent = css
+    document.head.append(style)
+  }, { id: CONTROL_STYLE_ID, css: CONTROL_CSS })
+  try {
+    return await compareTabs(page)
+  } finally {
+    await page.evaluate((id) => { document.getElementById(id)?.remove() }, CONTROL_STYLE_ID)
+  }
+}
+
+/**
+ * Open the seeded session from the sidebar search.
+ *
+ * Cold summaries carry the temp workspace's basename, so the persisted first
+ * message is the stable identity to search for, and the query itself drives the
+ * lazy content-index reconciliation. Hand-rolled polling because `expect.poll`
+ * is test-scoped and this runs in `beforeAll`.
+ * @param page - the page under test.
+ */
+async function openSeededSession(page: Page): Promise<void> {
+  const search = page.getByRole('textbox', { name: 'Search name, keywords...', exact: true })
+  await search.fill(FIXTURE.markers.user(1))
+  const results = page.getByRole('tree', { name: 'Search results' }).getByRole('treeitem')
+  const deadline = Date.now() + 60_000
+  for (;;) {
+    if (await results.count() === 1) break
+    if (Date.now() > deadline) throw new Error('seeded session never appeared in the sidebar search results')
+    await page.waitForTimeout(200)
+  }
+  await results.click()
+}
+
+/**
+ * Render the golden body.
+ * @param wide - comparison at the viewport where the card sits at its width cap.
+ * @param narrow - comparison at the viewport where the card shrinks with the column.
+ * @param control - comparison at the wide viewport with the reservation removed.
+ * @returns the golden body, without a trailing newline.
+ */
+function renderGeometry(wide: TabComparison, narrow: TabComparison, control: TabComparison): string {
+  const section = (name: string, comparison: TabComparison): string[] => [
+    `## ${name}`,
+    '',
+    `- Chat: scrollbar-gutter ${comparison.chat.gutter}, overflow ${comparison.chat.overflowX}/${comparison.chat.overflowY}`,
+    `- Chat scroller scrolls: ${String(comparison.chat.scrolls)}`,
+    `- Chat reserved band: ${String(comparison.chat.band)}px`,
+    `- Trajectory: scrollbar-gutter ${comparison.trajectory.gutter}, overflow ${comparison.trajectory.overflowX}/${comparison.trajectory.overflowY}`,
+    `- Trajectory scroller scrolls: ${String(comparison.trajectory.scrolls)}`,
+    `- Trajectory reserved band: ${String(comparison.trajectory.band)}px`,
+    `- input card left edge moves between tabs: ${String(comparison.leftShift)}px`,
+    `- input card right edge moves between tabs: ${String(comparison.rightShift)}px`,
+    `- input card width changes between tabs: ${String(comparison.widthShift)}px`,
+    '',
+  ]
+  return [
+    '# Input card position across the Chat and Trajectory tabs',
+    '',
+    ...section(`Wide viewport (${String(WIDE_VIEWPORT.width)}px, card at its cap)`, wide),
+    ...section(`Narrow viewport (${String(NARROW_VIEWPORT.width)}px, card shrinking with the column)`, narrow),
+    ...section('Wide viewport, reservation removed in the page (control)', control),
+  ].join('\n').trimEnd()
+}
+
+describe('web e2e: input card position across view tabs', () => {
+  let scaffold: WebScaffold
+  let browser: Browser
+  let page: Page
+  let tripwire: ReturnType<typeof watchConsole>
+
+  beforeAll(async () => {
+    scaffold = await launchWebScaffold({})
+    await seedSession(scaffold, FIXTURE.log, SEED_ID)
+    // Scrollbars must take layout space here or the scenario proves nothing;
+    // see the file header for the measurement behind dropping this argument.
+    browser = await chromium.launch({ ignoreDefaultArgs: ['--hide-scrollbars'] })
+    page = await newEnglishPage(browser, WIDE_VIEWPORT.height)
+    tripwire = watchConsole(page)
+    await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
+    await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    await openSeededSession(page)
+    await page.getByRole('tab', { name: 'Chat', exact: true }).waitFor({ timeout: 30_000 })
+    await page.getByText(FIXTURE.markers.assistant(FIXTURE.turns), { exact: false }).last()
+      .waitFor({ timeout: 30_000 })
+  }, 180_000)
+
+  afterAll(async () => {
+    await browser?.close()
+    await scaffold?.close()
+  })
+
+  it('reserves the same gutter in both tabs while the transcript scrolls', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-composer-tab-geometry-band'))
+    await setMeasuredViewport(page, WIDE_VIEWPORT, false)
+    // Vacuity guard, in two parts. A transcript that does not overflow gives
+    // Chat no scrollbar, and a hidden or overlaid bar gives it no width; either
+    // would make the tabs agree without the reservation doing anything.
+    await expect.poll(async () => (await measureTab(page)).scrolls, { timeout: 10_000 }).toBe(true)
+    const comparison = await compareTabs(page)
+    expect(comparison.chat.band).toBeGreaterThan(0)
+    // The reservation reaches both states, which is the whole change: the same
+    // band, on a box that scrolls and on one that only holds a view.
+    expect(comparison.chat.gutter).toBe('stable')
+    expect(comparison.trajectory.gutter).toBe('stable')
+    expect(comparison.trajectory.band).toBe(comparison.chat.band)
+    // Declared as a scroll container on both axes rather than left to compute:
+    // `overflow: hidden` would drop the reservation in WebKit, and a `visible`
+    // horizontal axis computes to `auto` beside a scrolling one.
+    expect(comparison.trajectory.overflowY).toBe('auto')
+    expect(comparison.trajectory.overflowX).toBe('hidden')
+    // Only Chat scrolls this box; the Trajectory view owns its own scrollers.
+    expect(comparison.trajectory.scrolls).toBe(false)
+    expect(tripwire.pageErrors).toEqual([])
+  }, 60_000)
+
+  it('holds the input card in place when the tab changes', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-composer-tab-geometry-wide'))
+    await setMeasuredViewport(page, WIDE_VIEWPORT, false)
+    const comparison = await compareTabs(page)
+    // The reported symptom as a number. At this viewport the card sits at its
+    // width cap, so the pre-fix shift showed up as a centring difference — half
+    // the band on each edge — rather than as a width change.
+    expect(comparison.leftShift).toBe(0)
+    expect(comparison.rightShift).toBe(0)
+    expect(comparison.widthShift).toBe(0)
+    expect(tripwire.pageErrors).toEqual([])
+  }, 60_000)
+
+  it('holds the input card in place at a viewport where it shrinks with the column', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-composer-tab-geometry-narrow'))
+    await setMeasuredViewport(page, WIDE_VIEWPORT, false)
+    const capped = await measureTab(page)
+    await setMeasuredViewport(page, NARROW_VIEWPORT, true)
+    const comparison = await compareTabs(page)
+    // The other geometry, and a different failure: below the cap the card takes
+    // the column's width, so an unreserved gutter changed its WIDTH by the whole
+    // band instead of shifting it by half. Asserted against the capped
+    // measurement rather than against the cap's pixel value, which belongs to
+    // the stylesheet.
+    expect(comparison.chat.cardWidth).toBeLessThan(capped.cardWidth)
+    expect(comparison.leftShift).toBe(0)
+    expect(comparison.rightShift).toBe(0)
+    expect(comparison.widthShift).toBe(0)
+    await setMeasuredViewport(page, WIDE_VIEWPORT, false)
+    expect(tripwire.pageErrors).toEqual([])
+  }, 60_000)
+
+  it('moves the card again once the reservation is removed in the page', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-composer-tab-geometry-control'))
+    await setMeasuredViewport(page, WIDE_VIEWPORT, false)
+    // The control: without it, equal rectangles could also mean the tab switch
+    // never reached the layout. Under the pre-fix cascade the Chat scroller keeps
+    // its bar and the Trajectory branch goes back to a hidden box with none, and
+    // the card moves by half the band on each edge.
+    const comparison = await compareTabsWithoutReservation(page)
+    expect(comparison.chat.gutter).toBe('auto')
+    expect(comparison.chat.band).toBeGreaterThan(0)
+    expect(comparison.trajectory.band).toBe(0)
+    expect(comparison.leftShift).toBe(comparison.chat.band / 2)
+    expect(comparison.rightShift).toBe(comparison.chat.band / 2)
+    // Restoring the sheet restores the fix, so the control cannot leak into the
+    // remaining measurements.
+    const restored = await compareTabs(page)
+    expect(restored.leftShift).toBe(0)
+    expect(tripwire.pageErrors).toEqual([])
+  }, 60_000)
+
+  it('matches the committed tab geometry golden', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-composer-tab-geometry-golden'))
+    await setMeasuredViewport(page, WIDE_VIEWPORT, false)
+    const wide = await compareTabs(page)
+    await setMeasuredViewport(page, NARROW_VIEWPORT, true)
+    const narrow = await compareTabs(page)
+    await setMeasuredViewport(page, WIDE_VIEWPORT, false)
+    const control = await compareTabsWithoutReservation(page)
+    await compareOrRefreshGolden(GEOMETRY_EXPECTED, renderGeometry(wide, narrow, control), MODE)
+    expect(tripwire.pageErrors).toEqual([])
+  }, 60_000)
+
+  it('commits exactly the fixtures it reads', async () => {
+    // The seeded session is generated in-process, so the geometry golden is the
+    // whole inventory.
+    await assertFixtureInventory(SNAPSHOT_DIR, ['geometry.expected.md'])
+  })
+
+  it.skipIf(MODE === 'record')('issued zero model calls and stayed clean', () => {
+    expect(tripwire.warnings).toEqual([])
+    expect(tripwire.pageErrors).toEqual([])
+  })
+})
--- a/apps/web/tests/cordis-tool-round.e2e.ts
+++ b/apps/web/tests/cordis-tool-round.e2e.ts
@@ -29,9 +29,7 @@ function assertCompleteCordisLifecycle(events: readonly SessionEvent[]): void {
    (event): event is Extract<SessionEvent, { type: 'turn/end' }> => event.type === 'turn/end',
  )
  const reason = turnEnd?.data.reason
-  const reasonSummary = reason?.kind === 'error'
-    ? { kind: reason.kind, code: reason.failure?.code, status: reason.failure?.status }
-    : { kind: reason?.kind }
+  const reasonSummary = { kind: reason?.kind }
  expect(reasonSummary).toEqual({ kind: 'completed' })

  const calls = events.filter(
--- a/apps/web/tests/live-interactions.e2e.ts
+++ b/apps/web/tests/live-interactions.e2e.ts
@@ -192,9 +192,12 @@ describe('web e2e: live-turn interactions (cancel / error / retry)', () => {
    const { settled } = await sendPrompt()
    await settled
    await page.getByRole('tab', { name: 'Trajectory' }).click()
+    // The boundary marker row itself is a 0-height hairline except at the
+    // table tail; the marker button is absolutely positioned and stays
+    // visible, so wait on it directly.
    const tailRequest = page.locator('tr[data-request-only="true"]').last()
-    await tailRequest.waitFor({ timeout: 10_000 })
    const requestMarker = tailRequest.getByRole('button', { name: /Request #/ })
+    await requestMarker.waitFor({ timeout: 10_000 })

    const markerWithinTable = await requestMarker.evaluate((element) => {
      const marker = element.getBoundingClientRect()
--- a/apps/web/tests/markdown-images.e2e.ts
+++ b/apps/web/tests/markdown-images.e2e.ts
@@ -83,10 +83,7 @@ async function stopServer(server: Server): Promise<void> {
 /** Build one closed, invariant-checked session fixture with remote and local image Markdown. */
 function markdownImageFixture(remoteUrl: string): string {
  const session = Session.create(SessionId('markdown-image-source'))
-  session.append('turn/start', {
-    turn: 1,
-    trigger: { kind: 'message', source: { kind: 'user' } },
-  })
+  session.append('turn/start', { turn: 1 })
  const user = session.append('user/message', createUserMessage({
    content: [{ type: 'text', text: 'Show the Markdown image policy.' }],
    source: { kind: 'user' },
--- a/apps/web/tests/math-rendering.e2e.ts
+++ b/apps/web/tests/math-rendering.e2e.ts
@@ -0,0 +1,126 @@
+import { fileURLToPath } from 'node:url'
+import type { Browser, Page } from 'playwright'
+import { chromium } from 'playwright'
+import { afterAll, beforeAll, describe, expect, it, onTestFailed } from 'vitest'
+import { createMessage, createUserMessage } from '@deepseek-ai/dsh-llm'
+import { SESSION_FORMAT_VERSION, Session, SessionId } from '@deepseek-ai/dsh-session'
+import type {} from '@deepseek-ai/dsh-session-title'
+import {
+  assertFixtureInventory,
+  captureStableAria,
+  compareOrRefreshGolden,
+  launchWebScaffold,
+  seedSession,
+  watchConsole,
+  webSnapshotMode,
+  type WebScaffold,
+} from './scaffold.ts'
+import { newEnglishPage, saveFailureShot } from './support.ts'
+
+const SNAPSHOT_DIR = fileURLToPath(new URL('./snapshots/math-rendering', import.meta.url))
+const UI_EXPECTED = fileURLToPath(new URL('./snapshots/math-rendering/ui.expected.md', import.meta.url))
+const MODE = webSnapshotMode()
+const SEED_ID = 'math-rendering-web-e2e'
+const DONE = 'MATH_RENDERING_DONE'
+
+/** Build a settled assistant reply that exercises every supported math delimiter. */
+function mathFixture(): string {
+  const session = Session.create(SessionId('math-rendering-source'))
+  session.append('turn/start', {
+    turn: 1,
+  })
+  const user = session.append('user/message', createUserMessage({
+    content: [{ type: 'text', text: 'Render this mathematical proof.' }],
+    source: { kind: 'user' },
+  }), { surfaceOp: 'append' })
+  session.append('session/title', {
+    title: 'Math rendering',
+    messageSeqs: [user.seq],
+    source: { kind: 'fallback' },
+  })
+  session.append('step/start', { turn: 1, step: 1 })
+  session.append('assistant/message', {
+    turn: 1,
+    step: 1,
+    message: createMessage({
+      role: 'assistant',
+      content: [{
+        type: 'text',
+        text: [
+          '## Math rendering',
+          '',
+          'Inline dollar $\\theta$ and backslash \\(\\frac{1}{5}\\).',
+          '',
+          '\\[\\frac{\\pi}{4} < \\theta < \\frac{\\pi}{2}\\]',
+          '',
+          '$$\\theta \\in \\left(\\frac{\\pi}{4}, \\frac{\\pi}{2}\\right). \\tag{1}$$',
+          '',
+          '| Symbol | Value |',
+          '| --- | --- |',
+          '| $\\theta$ | \\(\\frac{1}{5}\\) |',
+          '',
+          DONE,
+        ].join('\n'),
+      }],
+      source: { kind: 'model', provider: 'fixture', model: 'fixture' },
+    }),
+  }, { surfaceOp: 'append' })
+  session.append('step/end', { turn: 1, step: 1 })
+  session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
+
+  return [
+    JSON.stringify({
+      type: 'session',
+      version: SESSION_FORMAT_VERSION,
+      id: '{{sessionId}}',
+      createdAt: 0,
+      cwd: '{{cwd}}',
+    }),
+    ...session.events.map(event => JSON.stringify(event)),
+    '',
+  ].join('\n')
+}
+
+describe('web e2e: settled Markdown math rendering', () => {
+  let scaffold: WebScaffold
+  let browser: Browser
+  let page: Page
+  let tripwire: ReturnType<typeof watchConsole>
+
+  beforeAll(async () => {
+    scaffold = await launchWebScaffold({})
+    await seedSession(scaffold, mathFixture(), SEED_ID)
+    browser = await chromium.launch()
+    page = await newEnglishPage(browser)
+    tripwire = watchConsole(page)
+    await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
+    await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+  }, 120_000)
+
+  afterAll(async () => {
+    await browser?.close()
+    await scaffold?.close()
+  })
+
+  it.skipIf(MODE === 'record')('renders the settled reply without KaTeX errors', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-math-rendering'))
+    const groupRow = page.locator('[role="treeitem"]').first()
+    await groupRow.waitFor({ timeout: 15_000 })
+    await groupRow.click()
+    const sessionRow = page.locator('[role="treeitem"]').nth(1)
+    await sessionRow.waitFor({ timeout: 10_000 })
+    await sessionRow.click()
+    await expect.poll(() => page.getByText(DONE, { exact: true }).count(), { timeout: 15_000 }).toBe(1)
+
+    await expect.poll(() => page.locator('.katex').count(), { timeout: 10_000 }).toBe(6)
+    await expect.poll(() => page.locator('.katex-display').count(), { timeout: 10_000 }).toBe(2)
+    expect(await page.locator('.katex-error').count()).toBe(0)
+
+    const snapshot = (await captureStableAria(page, '[class*="centerCol"]', scaffold.workspaceCwd))
+      .split(SEED_ID).join('{{seededId}}')
+    await compareOrRefreshGolden(UI_EXPECTED, snapshot, MODE)
+    expect(tripwire.pageErrors).toEqual([])
+    expect(tripwire.warnings).toEqual([])
+    await assertFixtureInventory(SNAPSHOT_DIR, ['ui.expected.md'])
+  }, 60_000)
+})
--- a/apps/web/tests/pwsh-terminal.e2e.ts
+++ b/apps/web/tests/pwsh-terminal.e2e.ts
@@ -0,0 +1,103 @@
+// Keyless browser regression for pwsh UI parity with bash: a seeded session
+// whose pwsh call/result is presented by the REAL tool-pwsh on replay (the
+// api-proxy recomputes presentation views from logged args/result content)
+// must render as a bash-shaped terminal card with the parsed exit-status
+// pill — not the generic console-fenced card the pwsh presenter used to
+// emit. The seed is authored, not recorded: its header line carries no `cwd`
+// field (seedSession writes the session cwd itself, and a Windows temp path
+// substituted into the header would not round-trip through its JSON parse),
+// and no event references the workspace, so the lane replays on any host
+// with a usable `pwsh` — the lane mounts the pwsh stack through an overlay
+// (the shipped tree keeps the bash stack).
+import { spawnSync } from 'node:child_process'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { Browser, Page } from 'playwright'
+import { chromium } from 'playwright'
+import { afterAll, beforeAll, describe, expect, it, onTestFailed } from 'vitest'
+import { resolvePwshPath } from '@deepseek-ai/dsh-pwsh-local'
+import {
+  assertFixtureInventory, captureStableAria, compareOrRefreshGolden,
+  fixtureUserPrompts, launchWebScaffold, seedSession, webSnapshotMode,
+  type WebScaffold,
+} from './scaffold.ts'
+import { connectFreshWorkspace, newEnglishPage, saveFailureShot } from './support.ts'
+
+const SNAPSHOT_DIR = fileURLToPath(new URL('./snapshots/pwsh-terminal', import.meta.url))
+const SEED = join(SNAPSHOT_DIR, 'seed.jsonl')
+const TERMINAL_EXPECTED = join(SNAPSHOT_DIR, 'terminal-card.expected.md')
+const OVERLAY = fileURLToPath(new URL('./pwsh-terminal.overlay.yml', import.meta.url))
+const PROMPT = 'Run a PowerShell command that fails, then stop.'
+const SEED_ID = 'pwsh-terminal-web-e2e'
+const MODE = webSnapshotMode()
+
+// The overlay swaps the shipped bash executor for @deepseek-ai/dsh-pwsh-local;
+// a host without a usable `pwsh` cannot boot it, so the lane self-skips,
+// mirroring the pwshOnly ACP scenarios. The probe follows the executor's own
+// resolution (Program Files installs on Windows are found even when bare
+// `pwsh` is not on PATH), the same judgment the tool-pwsh tests reuse; record
+// mode skips the lane anyway, so the probe stays inert there.
+const HAS_PWSH = MODE === 'record' ? false : spawnSync(
+  resolvePwshPath(), ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', '$true'],
+  { encoding: 'utf8' },
+).status === 0
+
+describe.skipIf(MODE === 'record' || !HAS_PWSH)('web e2e: pwsh calls render as bash-shaped terminal cards', () => {
+  let scaffold: WebScaffold
+  let browser: Browser
+  let page: Page
+
+  beforeAll(async () => {
+    const fixture = await readFile(SEED, 'utf8')
+    expect(fixtureUserPrompts(fixture), 'seed fixture must carry the single drive prompt').toEqual([PROMPT])
+    scaffold = await launchWebScaffold({ extraOverlayPath: OVERLAY })
+    await seedSession(scaffold, fixture, SEED_ID)
+    browser = await chromium.launch()
+    page = await newEnglishPage(browser)
+    await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
+    await connectFreshWorkspace(page, scaffold.workspaceCwd)
+  }, 120_000)
+
+  afterAll(async () => {
+    await browser?.close()
+    await scaffold?.close()
+  })
+
+  it('renders the seeded pwsh call as a terminal card with the parsed exit pill', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-pwsh-terminal'))
+    // Open the seeded session through content search: the sidebar groups
+    // sessions by workspace and its row order is world-dependent, while the
+    // search index covers the seeded log deterministically.
+    const search = page.getByPlaceholder('Search name, keywords', { exact: false })
+    await search.fill('Run a PowerShell command')
+    const result = page.getByRole('tree', { name: 'Search results' }).getByRole('treeitem')
+    await expect.poll(() => result.count(), { timeout: 15_000 }).toBe(1)
+    await result.click()
+    await page.getByRole('tab', { name: 'Chat', exact: true }).waitFor({ timeout: 15_000 })
+    // The tool row is expand-gated: the settled bash-shaped row carries the
+    // shell-family variant, and the terminal card lives in the expanded body.
+    const row = page.locator('[data-tool="pwsh"]').first()
+    await row.waitFor({ timeout: 15_000 })
+    if (await row.getAttribute('aria-expanded') !== 'true') await row.click()
+    const card = page.locator('[data-terminal]').first()
+    await card.waitFor({ timeout: 15_000 })
+    // The parsed exit pill replaces the `[exit code: 1]` marker in the output
+    // body — the bash tool's terminal presentation, not the generic fence.
+    const text = await card.textContent()
+    expect(text).toContain('exit code 1')
+    expect(text).toContain('Get-Item : Cannot find path')
+    expect(text).not.toContain('[exit code: 1]')
+    const snapshot = (await captureStableAria(page, '[data-terminal]', scaffold.workspaceCwd))
+      // normalizeAria collapses the workspace basename with a '/' split, which
+      // misses Windows temp paths; collapse it here too (a no-op on POSIX) so
+      // the golden is platform-independent.
+      .split(scaffold.workspaceCwd.split(/[\\/]/).pop()!).join('{{workspace}}')
+      .split(SEED_ID).join('{{seededId}}')
+    await compareOrRefreshGolden(TERMINAL_EXPECTED, snapshot, MODE)
+  }, 60_000)
+
+  it('guards the lane fixture inventory', async () => {
+    await assertFixtureInventory(SNAPSHOT_DIR, ['seed.jsonl', 'terminal-card.expected.md'])
+  })
+})
--- a/apps/web/tests/pwsh-terminal.overlay.yml
+++ b/apps/web/tests/pwsh-terminal.overlay.yml
@@ -0,0 +1,20 @@
+# The pwsh terminal-card lane swaps the shipped bash stack for the PowerShell
+# twin: the bash executor row is disabled (patches cannot rename a row — `name`
+# is a guard) and the pwsh executor + tool are inserted. The permission service
+# refuses an unconfined executor by design (presets bundle a sandbox mode), so
+# its row is disabled too — this lane renders a seeded session, never a
+# permission decision. The seeded scenario renders the logged pwsh call/result
+# through the real tools on replay; no command executes, but the composition
+# must boot the pwsh executor, so the lane skips on hosts without a usable
+# `pwsh`.
+- id: bash-sandbox
+  name: '@deepseek-ai/dsh-bash-sandbox'
+  disabled: true
+- id: permission
+  name: '@deepseek-ai/dsh-permission'
+  disabled: true
+- insert:
+    - id: pwsh-local
+      name: '@deepseek-ai/dsh-pwsh-local'
+    - id: tool-pwsh
+      name: '@deepseek-ai/dsh-tool-pwsh'
--- a/apps/web/tests/queue-actions.e2e.ts
+++ b/apps/web/tests/queue-actions.e2e.ts
@@ -32,6 +32,7 @@ const REMOVE = 'Queue item to remove'
 const EDIT = 'Queue item to edit'
 const EDITED = 'Edited queue item'
 const TAIL = 'Queue item preserved after stop'
+const WAKE = 'Wake the preserved queue'

 /** Durable turn-end classifications observed by the scenario. */
 function turnEndReasons(events: readonly SessionEvent[]): string[] {
@@ -63,13 +64,13 @@ describe('web e2e: queue row actions', () => {
  it.skipIf(MODE === 'record')('edits and removes exact occurrences and preserves Queue across stop', async () => {
    overrideDir = await mkdtemp(join(tmpdir(), 'dsh-web-queue-actions-'))
    const readyFile = join(overrideDir, '.hang-ready')
-    const nextReadyFile = join(overrideDir, '.next-hang-ready')
    const overridePath = join(overrideDir, 'replay.override.json')
    const recorded = deriveReplayScript(parseSessionLog(await readFile(FIXTURE, 'utf8')))
    expect(recorded).toHaveLength(1)
    const replay: ReplayEntry[] = [
      { kind: 'hang', readyFile },
-      { kind: 'hang', readyFile: nextReadyFile },
+      recorded[0]!,
+      recorded[0]!,
      recorded[0]!,
    ]
    await writeFile(overridePath, JSON.stringify(replay))
@@ -86,7 +87,7 @@ describe('web e2e: queue row actions', () => {
    onTestFailed(() => saveFailureShot(page, 'web-e2e-queue-actions'))

    const input = page.locator('textarea').first()
-    const settled = scaffold.whenTurnSettled()
+    const firstSettled = scaffold.whenTurnSettled()
    await input.fill(ACTIVE_PROMPT)
    await input.press('Enter')
    await expect.poll(() => existsSync(readyFile), { timeout: 15_000 }).toBe(true)
@@ -157,19 +158,24 @@ describe('web e2e: queue row actions', () => {
    ).toBe(2)

    await page.getByRole('button', { name: 'Stop generating' }).click()
-    await expect.poll(() => existsSync(nextReadyFile), { timeout: 15_000 }).toBe(true)
-    await page.getByText(TAIL, { exact: true }).waitFor()
+    await firstSettled
+    await expect.poll(() => page.getByRole('button', { name: 'Stop generating' }).count())
+      .toBe(0)
    await expect.poll(() => page.getByRole('button', { name: 'Remove queued message' }).count())
-      .toBe(1)
+      .toBe(2)

    const preservedSnapshot = await captureStableAria(page, '[class*="centerCol"]', scaffold.workspaceCwd)
    await compareOrRefreshGolden(PRESERVED_EXPECTED, preservedSnapshot, MODE)

-    await page.getByRole('button', { name: 'Stop generating' }).click()
+    const settled = scaffold.whenTurnSettled()
+    await input.fill(WAKE)
+    await input.press('Enter')
    await settled
-    expect(turnEndReasons(sessionEvents)).toEqual(['aborted', 'aborted', 'completed'])
-    expect(sessionEvents.filter(event => event.type === 'user/message' && event.data.source.kind === 'user'))
-      .toHaveLength(3)
+    await expect.poll(() => turnEndReasons(sessionEvents), { timeout: 15_000 })
+      .toEqual(['aborted', 'completed', 'completed', 'completed'])
+    expect(sessionEvents.flatMap(event => event.type === 'user/message' && event.data.source.kind === 'user'
+      ? event.data.content.flatMap(block => block.type === 'text' ? [block.text] : [])
+      : [])).toEqual([ACTIVE_PROMPT, EDITED, TAIL, WAKE])
    await expect.poll(() => page.locator('[data-queue-dock]').count()).toBe(0)
  }, 120_000)

--- a/apps/web/tests/scaffold.ts
+++ b/apps/web/tests/scaffold.ts
@@ -379,26 +379,21 @@ export async function launchWebScaffold(options: LaunchOptions = {}): Promise<We
    ctx,
    workspaceCwd,
    persistenceRoot,
-    // Barrier stack: the in-process turn/end identifies the session, then
-    // agent.whenIdle() covers the persistence flush (the idle flip follows
-    // the flush), and the caller's browser settled-poll comes last because
-    // host completion strictly precedes render.
+    // Barrier stack: the in-process turn/end identifies the session, its
+    // explicit flush makes the transcript durable, and the caller's browser
+    // settled-poll comes last because host completion strictly precedes render.
    whenTurnSettled(timeoutMs = mode === 'record' ? 180_000 : 30_000): Promise<SessionId> {
      return new Promise<SessionId>((resolveSettled, reject) => {
        const timer = setTimeout(() => {
          off()
          reject(new Error(`no turn/end within ${timeoutMs}ms`))
        }, timeoutMs)
-        const off = ctx.on('session/event', (session: { id: SessionId }, event: SessionEvent) => {
+        const off = ctx.on('session/event', (session: Session, event: SessionEvent) => {
          if (event.type !== 'turn/end') return
          clearTimeout(timer)
          off()
-          const agent = ctx.agents.get(session.id)
-          if (agent === undefined) {
-            reject(new Error(`turn/end for ${session.id} but no live agent`))
-            return
-          }
-          agent.whenIdle().then(() => { resolveSettled(session.id) }, reject)
+          ctx.sessions.flush(session)
+            .then(() => { resolveSettled(session.id) }, reject)
        })
      })
    },
--- a/apps/web/tests/seeded-history.e2e.ts
+++ b/apps/web/tests/seeded-history.e2e.ts
@@ -57,8 +57,7 @@ function withCompaction(raw: string): string {
    .filter(event => event.surfaceOp === 'append'
      && (event.type === 'user/message'
        || event.type === 'assistant/message'
-        || event.type === 'tool/result'
-        || event.type === 'steering/message'))
+        || event.type === 'tool/result'))
    .map(event => event.seq)
  const first = surfaceSeqs[0]
  const last = surfaceSeqs.at(-1)
@@ -86,7 +85,7 @@ function withCompaction(raw: string): string {
    lines.push(JSON.stringify({ ...event, seq: taken, time: time++ }))
    return taken
  }
-  at({ type: 'turn/start', data: { turn, trigger: { kind: 'injection', source: { kind: 'plugin', plugin: 'compact' } } } })
+  at({ type: 'turn/start', data: { turn } })
  const startSeq = at({ type: 'compact/start', data: { turn } })
  const summarySeq = at({
    type: 'compact/summary',
@@ -216,7 +215,7 @@ describe('web e2e: seeded history renders through cold resume', () => {

    const agent = scaffold.ctx.agents.get(SessionId(SEED_ID))
    if (agent === undefined) throw new Error('seeded session did not attach an agent')
-    agent.inject(createUserMessage({
+    agent.session.append('user/message', createUserMessage({
      content: [{
        type: 'text',
        text: '<system-reminder>\n'
@@ -235,7 +234,7 @@ describe('web e2e: seeded history renders through cold resume', () => {
          digest: 'context-injection-browser-snapshot',
        }],
      },
-    }))
+    }), { surfaceOp: 'append' })
    await page.getByRole('button', { name: 'Context injection' }).waitFor({ timeout: 10_000 })
  }, 60_000)

@@ -356,13 +355,13 @@ describe('web e2e: seeded history renders through cold resume', () => {
    await compareOrRefreshGolden(COMMAND_ROW_EXPECTED, snapshot, MODE)
  }, 60_000)

-  it.skipIf(MODE === 'record')('fits short injected context without a scrollport', async () => {
+  it.skipIf(MODE === 'record')('fits short logged context without a scrollport', async () => {
    const agent = scaffold.ctx.agents.get(SessionId(SEED_ID))
    if (agent === undefined) throw new Error('seeded session did not attach an agent')
-    agent.inject(createUserMessage({
+    agent.session.append('user/message', createUserMessage({
      content: [{ type: 'text', text: 'Short injected context.' }],
      source: { kind: 'plugin', plugin: 'fixture' },
-    }))
+    }), { surfaceOp: 'append' })

    const disclosures = page.getByRole('button', { name: 'Context injection' })
    await expect.poll(() => disclosures.count(), { timeout: 10_000 }).toBe(2)
--- a/apps/web/tests/smoke-real.e2e.ts
+++ b/apps/web/tests/smoke-real.e2e.ts
@@ -196,16 +196,19 @@ describe('dsh web keyless CLI smoke', () => {
      messages?: { role?: string; content?: string }[]
      tools?: { function?: { name?: string } }[]
    }
-    let resolveProviderRequest!: (request: NativeProviderRequest) => void
-    const providerRequest = new Promise<NativeProviderRequest>((resolve) => {
-      resolveProviderRequest = resolve
+    let resolveProviderRequests!: (requests: NativeProviderRequest[]) => void
+    const requests: NativeProviderRequest[] = []
+    const providerRequests = new Promise<NativeProviderRequest[]>((resolve) => {
+      resolveProviderRequests = resolve
    })
    const provider = createServer((request, response) => {
      let body = ''
      request.setEncoding('utf8')
      request.on('data', (chunk: string) => { body += chunk })
      request.on('end', () => {
-        resolveProviderRequest(JSON.parse(body) as NativeProviderRequest)
+        const parsed = JSON.parse(body) as NativeProviderRequest
+        if ((parsed.tools?.length ?? 0) > 0) requests.push(parsed)
+        if (requests.length === 1) resolveProviderRequests(requests)
        response.writeHead(200, { 'content-type': 'text/event-stream' })
        response.end([
          'data: {"choices":[{"delta":{"role":"assistant","content":null,"reasoning_content":""}}]}',
@@ -244,14 +247,16 @@ describe('dsh web keyless CLI smoke', () => {
        mode: 'queue',
        content: [{ type: 'text', text: 'go' }],
      })
-      const captured = await Promise.race([
-        providerRequest,
+      const capturedRequests = await Promise.race([
+        providerRequests,
        new Promise<never>((_resolve, reject) => {
          setTimeout(() => { reject(new Error('provider request not received in 10s')) }, 10_000).unref()
        }),
      ])
-      expect(captured.messages?.some(message =>
-        message.role === 'user' && message.content?.includes('<available_skills>'))).toBe(false)
+      const captured = capturedRequests[0]
+      if (captured === undefined) {
+        throw new Error('provider did not receive the workspace projection request')
+      }
      const workspaceMessage = captured.messages?.find(message =>
        message.role === 'user' && message.content?.includes('web-workspace-context-probe'))
      const systemMessage = captured.messages?.find(message => message.role === 'system')
--- a/apps/web/tests/snapshots/composer-tab-geometry/geometry.expected.md
+++ b/apps/web/tests/snapshots/composer-tab-geometry/geometry.expected.md
@@ -0,0 +1,37 @@
+# Input card position across the Chat and Trajectory tabs
+
+## Wide viewport (1680px, card at its cap)
+
+- Chat: scrollbar-gutter stable, overflow auto/auto
+- Chat scroller scrolls: true
+- Chat reserved band: 8px
+- Trajectory: scrollbar-gutter stable, overflow hidden/auto
+- Trajectory scroller scrolls: false
+- Trajectory reserved band: 8px
+- input card left edge moves between tabs: 0px
+- input card right edge moves between tabs: 0px
+- input card width changes between tabs: 0px
+
+## Narrow viewport (800px, card shrinking with the column)
+
+- Chat: scrollbar-gutter stable, overflow auto/auto
+- Chat scroller scrolls: true
+- Chat reserved band: 8px
+- Trajectory: scrollbar-gutter stable, overflow hidden/auto
+- Trajectory scroller scrolls: false
+- Trajectory reserved band: 8px
+- input card left edge moves between tabs: 0px
+- input card right edge moves between tabs: 0px
+- input card width changes between tabs: 0px
+
+## Wide viewport, reservation removed in the page (control)
+
+- Chat: scrollbar-gutter auto, overflow auto/auto
+- Chat scroller scrolls: true
+- Chat reserved band: 8px
+- Trajectory: scrollbar-gutter auto, overflow hidden/hidden
+- Trajectory scroller scrolls: false
+- Trajectory reserved band: 0px
+- input card left edge moves between tabs: 4px
+- input card right edge moves between tabs: 4px
+- input card width changes between tabs: 0px
--- a/apps/web/tests/snapshots/math-rendering/ui.expected.md
+++ b/apps/web/tests/snapshots/math-rendering/ui.expected.md
@@ -0,0 +1,47 @@
+- banner:
+  - navigation "Session hierarchy":
+    - button "Math rendering" [disabled]
+  - tablist:
+    - tab "Chat" [selected]
+    - tab "Trajectory"
+- text: Render this mathematical proof. {{clock}}
+- button "Copy":
+  - img
+- button "Branch into a new conversation" [disabled]:
+  - img
+- text: Available only on the last message of a completed turn
+- heading "Math rendering" [level=2]
+- paragraph:
+  - text: Inline dollar
+  - math: θ
+  - text: and backslash
+  - math: 1 5
+  - text: .
+- math: π 4 < θ < π 2
+- math: θ ∈ ( π 4 , π 2 ) . (1)
+- table:
+  - rowgroup:
+    - row "Symbol Value":
+      - columnheader "Symbol"
+      - columnheader "Value"
+  - rowgroup:
+    - row:
+      - cell:
+        - math: θ
+      - cell:
+        - math: 1 5
+- paragraph: MATH_RENDERING_DONE
+- button "Copy":
+  - img
+- button "Branch into a new conversation":
+  - img
+- text: {{clock}}Ran for {{duration}}
+- textbox "Message the agent"
+- button "Commands":
+  - img
+- 'button "Access mode, current: Workspace Write"': Workspace Write
+- button "Select model":
+  - text: Select model
+  - img
+- button "Send message" [disabled]
+- text: 1 turns · 1 steps Input 0 tok · Output 0 tok
--- a/apps/web/tests/snapshots/navigation-panes/trajectory.expected.md
+++ b/apps/web/tests/snapshots/navigation-panes/trajectory.expected.md
@@ -5,7 +5,7 @@
  - img
  - searchbox "Search trajectory"
 - region "Trajectory timeline":
-  - tooltip "ASSISTANT {{clock}} → {{clock}} Total 1.5 s · TTFT 368 ms · Decoding 1.2 s"
+  - tooltip "ASSISTANT {{clock}} → {{clock}} Total 1,542 ms · TTFT 368 ms · Decoding 1,174 ms"
 - table:
  - rowgroup:
    - row "SYSTEM, Initial System Prompt":
--- a/apps/web/tests/snapshots/pwsh-terminal/seed.jsonl
+++ b/apps/web/tests/snapshots/pwsh-terminal/seed.jsonl
@@ -0,0 +1,19 @@
+{"type":"session","version":0,"id":"{{sessionId}}","createdAt":1784974100747}
+{"type":"turn/start","seq":0,"time":1784974200000,"data":{"turn":1,"trigger":{"kind":"message","source":{"kind":"user","rpcId":"{{rpcId}}"}}}}
+{"type":"user/message","seq":1,"time":1784974200001,"data":{"content":[{"type":"text","text":"Run a PowerShell command that fails, then stop."}],"source":{"kind":"user","rpcId":"{{rpcId}}"}},"surfaceOp":"append"}
+{"type":"session/title","seq":2,"time":1784974200002,"data":{"title":"Run a PowerShell command","messageSeqs":[1],"source":{"kind":"fallback"}}}
+{"type":"step/start","seq":3,"time":1784974200010,"data":{"turn":1,"step":1}}
+{"type":"request/header","seq":4,"time":1784974200011,"data":{"header":{"config":{"provider":"deepseek-official","model":"deepseek-v4-flash"},"system":"{{system}}","tools":"{{tools}}","messagePrefix":["{{messagePrefix}}"]},"reason":"initial"}}
+{"type":"assistant/chunk","seq":5,"time":1784974200200,"data":{"turn":1,"step":1,"chunk":{"type":"block-start","index":0,"blockType":"reasoning"}}}
+{"type":"assistant/chunk","seq":6,"time":1784974200201,"data":{"turn":1,"step":1,"chunk":{"type":"reasoning-delta","index":0,"text":"Run the failing pwsh command."}}}
+{"type":"assistant/chunk","seq":7,"time":1784974200201,"data":{"turn":1,"step":1,"chunk":{"type":"block-end","index":0,"block":{"type":"reasoning","text":"Run the failing pwsh command."}}}}
+{"type":"assistant/chunk","seq":8,"time":1784974200300,"data":{"turn":1,"step":1,"chunk":{"type":"block-start","index":1,"blockType":"tool-call"}}}
+{"type":"assistant/chunk","seq":9,"time":1784974200301,"data":{"turn":1,"step":1,"chunk":{"type":"tool-call-delta","index":1,"id":"call_pwsh_fail_0001","name":"pwsh","argumentsDelta":"{\"command\": \"Get-Item missing.txt\", \"description\": \"Fail deliberately\"}"}}}
+{"type":"assistant/chunk","seq":10,"time":1784974200301,"data":{"turn":1,"step":1,"chunk":{"type":"block-end","index":1,"block":{"type":"tool-call","id":"call_pwsh_fail_0001","name":"pwsh","arguments":"{\"command\": \"Get-Item missing.txt\", \"description\": \"Fail deliberately\"}"}}}}
+{"type":"assistant/chunk","seq":11,"time":1784974200302,"data":{"turn":1,"step":1,"chunk":{"type":"usage","usage":{"inputTokens":96,"outputTokens":64,"cacheReadTokens":0,"reasoningTokens":10}}}}
+{"type":"assistant/chunk","seq":12,"time":1784974200302,"data":{"turn":1,"step":1,"chunk":{"type":"finish","reason":{"kind":"tool-calls"}}}}
+{"type":"assistant/message","seq":13,"time":1784974200310,"data":{"turn":1,"step":1,"content":[{"type":"reasoning","text":"Run the failing pwsh command."},{"type":"tool-call","id":"call_pwsh_fail_0001","name":"pwsh","arguments":"{\"command\": \"Get-Item missing.txt\", \"description\": \"Fail deliberately\"}"}],"provenance":{"provider":"deepseek-official","model":"deepseek-v4-flash"},"usage":{"inputTokens":96,"outputTokens":64,"cacheReadTokens":0,"reasoningTokens":10}},"sourceEventSeqs":[5,6,7,8,9,10,11,12],"surfaceOp":"append"}
+{"type":"tool/call","seq":14,"time":1784974200311,"data":{"turn":1,"step":1,"callId":"call_pwsh_fail_0001","name":"pwsh","arguments":"{\"command\": \"Get-Item missing.txt\", \"description\": \"Fail deliberately\"}"}}
+{"type":"tool/result","seq":15,"time":1784974200500,"data":{"turn":1,"step":1,"callId":"call_pwsh_fail_0001","content":[{"type":"text","text":"[stderr]\nGet-Item : Cannot find path 'missing.txt' because it does not exist.\n[exit code: 1]"}],"isError":false},"sourceEventSeqs":[14],"surfaceOp":"append"}
+{"type":"step/end","seq":16,"time":1784974200501,"data":{"turn":1,"step":1}}
+{"type":"turn/end","seq":17,"time":1784974200501,"data":{"turn":1,"reason":{"kind":"completed"}}}
--- a/apps/web/tests/snapshots/pwsh-terminal/terminal-card.expected.md
+++ b/apps/web/tests/snapshots/pwsh-terminal/terminal-card.expected.md
@@ -0,0 +1,3 @@
+- text: Failed {{workspace}} Get-Item missing.txt exit code 1
+- button "Copy"
+- text: "[stderr] Get-Item : Cannot find path 'missing.txt' because it does not exist."
--- a/apps/web/tests/snapshots/queue-actions/layout.expected.md
+++ b/apps/web/tests/snapshots/queue-actions/layout.expected.md
@@ -16,10 +16,6 @@
  - img
  - img
  - text: Context injection
- button "Context injection":
-  - img
-  - img
-  - text: Context injection
 - paragraph: partial
 - status: Deep diving...
 - region "To-dos":
--- a/apps/web/tests/snapshots/queue-actions/preserved.expected.md
+++ b/apps/web/tests/snapshots/queue-actions/preserved.expected.md
@@ -20,22 +20,25 @@
  - img
 - button "Branch into a new conversation":
  - img
- text: {{clock}}Ran for {{duration}} Edited queue item {{clock}}
- button "Copy":
-  - img
- button "Branch into a new conversation" [disabled]:
-  - img
- text: Available only on the last message of a completed turn
- paragraph: partial
- status: Deep diving...
+- text: {{clock}}Ran for {{duration}}
+- button "2 queued messages" [expanded]
 - list:
+  - listitem:
+    - text: Edited queue item
+    - button "Edit queued message":
+      - img
+    - tooltip "Edit queued message"
+    - button "Remove queued message":
+      - img
+    - button "Steer queued message" [disabled]:
+      - img
  - listitem:
    - text: Queue item preserved after stop
    - button "Edit queued message":
      - img
    - button "Remove queued message":
      - img
-    - button "Steer queued message":
+    - button "Steer queued message" [disabled]:
      - img
 - textbox "Message the agent"
 - button "Commands":
@@ -44,5 +47,5 @@
 - button "Select model, current DeepSeek-V4-Flash":
  - text: DeepSeek-V4-Flash
  - img
- button "Stop generating"
+- button "Send message" [disabled]
 - text: 1 turns · 1 steps Input 0 tok · Output 0 tok
--- a/apps/web/tests/snapshots/steering/session.jsonl
+++ b/apps/web/tests/snapshots/steering/session.jsonl
@@ -15,7 +15,7 @@
 {"type":"assistant/message","seq":88,"time":1785004181406,"data":{"turn":1,"step":1,"content":[{"type":"reasoning","text":"The user wants me to use the ask_user_question tool to ask them a specific question with the given parameters. Let me do exactly that."},{"type":"tool-call","id":"call_00_sAvjivLShvnWVk0sPQPV7661","name":"ask_user_question","arguments":"{\"questions\": [{\"id\": \"checkpoint\", \"question\": \"Ready to continue?\", \"header\": \"Checkpoint\", \"options\": [{\"label\": \"Yes\"}, {\"label\": \"No\"}]}]}"}],"provenance":{"provider":"deepseek-official","model":"deepseek-v4-flash"},"usage":{"inputTokens":151,"outputTokens":115,"cacheReadTokens":7680,"reasoningTokens":29}},"sourceEventSeqs":[5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87],"surfaceOp":"append"}
 {"type":"tool/call","seq":89,"time":1785004181407,"data":{"turn":1,"step":1,"callId":"call_00_sAvjivLShvnWVk0sPQPV7661","name":"ask_user_question","arguments":"{\"questions\": [{\"id\": \"checkpoint\", \"question\": \"Ready to continue?\", \"header\": \"Checkpoint\", \"options\": [{\"label\": \"Yes\"}, {\"label\": \"No\"}]}]}"}}
 {"type":"tool/result","seq":90,"time":1785004181867,"data":{"turn":1,"step":1,"callId":"call_00_sAvjivLShvnWVk0sPQPV7661","content":[{"type":"text","text":"{\"answers\":[{\"id\":\"checkpoint\",\"selected\":[\"Yes\"]}]}"}],"isError":false},"sourceEventSeqs":[89],"surfaceOp":"append"}
-{"type":"steering/message","seq":91,"time":1785004181867,"data":{"turn":1,"content":[{"type":"text","text":"Interjection: include the word BANANA in your final reply."}],"source":{"kind":"user","rpcId":"{{rpcId}}"}},"surfaceOp":"append"}
+{"type":"user/message","seq":91,"time":1785004181867,"data":{"content":[{"type":"text","text":"Interjection: include the word BANANA in your final reply."}],"source":{"kind":"user","rpcId":"{{rpcId}}"}},"surfaceOp":"append"}
 {"type":"step/end","seq":92,"time":1785004181870,"data":{"turn":1,"step":1}}
 {"type":"step/start","seq":93,"time":1785004181870,"data":{"turn":1,"step":2}}
 {"type":"assistant/chunk","seq":94,"time":1785004182322,"data":{"turn":1,"step":2,"chunk":{"type":"block-start","index":0,"blockType":"reasoning"}}}
--- a/apps/web/tests/steering.e2e.ts
+++ b/apps/web/tests/steering.e2e.ts
@@ -21,7 +21,7 @@ const FIXTURE = join(SNAPSHOT_DIR, 'session.jsonl')
 // Two goldens pin the transient Host projection and its durable handoff: the
 // mid-turn state renders accepted steering from session/queue while the
 // question blocks admission, then the settled state renders the same message
-// from steering/message beside the reply that obeys it.
+// from user/message beside the reply that obeys it.
 const MID_EXPECTED = join(SNAPSHOT_DIR, 'mid-steer.expected.md')
 const SETTLED_EXPECTED = join(SNAPSHOT_DIR, 'settled.expected.md')
 const MODE = webSnapshotMode()
@@ -45,6 +45,12 @@ function assistantText(events: SessionEvent[]): string {
    .join('')
 }

+/** Claimed user messages whose payload contains the exact scenario text. */
+function claimedMessages(events: readonly SessionEvent[], text: string): SessionEvent<'user/message'>[] {
+  return events.filter((event): event is SessionEvent<'user/message'> =>
+    event.type === 'user/message' && JSON.stringify(event.data.content).includes(text))
+}
+
 describe('web e2e: mid-turn steering lands durably and visibly', () => {
  let scaffold: WebScaffold
  let browser: Browser
@@ -74,8 +80,9 @@ describe('web e2e: mid-turn steering lands durably and visibly', () => {
  it('strictly steers one queued row; the interjection is logged, rendered, and obeyed', async () => {
    onTestFailed(() => saveFailureShot(page, 'web-e2e-steering'))
    if (MODE !== 'record') {
-      // The steer must NOT be a user/message — it lands as steering/message.
-      expect(fixtureUserPrompts(await readFile(FIXTURE, 'utf8'))).toEqual([PROMPT])
+      // The steer lands as a durable user/message, so the inventory holds
+      // both the opening prompt and the later same-turn steer.
+      expect(fixtureUserPrompts(await readFile(FIXTURE, 'utf8'))).toEqual([PROMPT, STEER])
    }
    const input = page.locator('textarea').first()
    await input.waitFor({ timeout: 10_000 })
@@ -112,7 +119,7 @@ describe('web e2e: mid-turn steering lands durably and visibly', () => {
    }

    // Answer the composer; the tool result closes the step, the loop drains
-    // the steer as steering/message, and the steered continuation runs the
+    // the steer as user/message, and the steered continuation runs the
    // final model call.
    await composer.getByRole('radio', { name: 'Yes' }).click()
    await composer.getByRole('radio', { name: 'Yes' }).press('Enter')
@@ -124,15 +131,14 @@ describe('web e2e: mid-turn steering lands durably and visibly', () => {
      // Fixture honesty: a recording where the live model ignored the steer
      // would replay as a vacuous scenario — reject it and re-record instead.
      const recorded = parseSessionLog(await readFile(FIXTURE, 'utf8'))
-      expect(recorded.filter(e => e.type === 'steering/message')).toHaveLength(1)
+      expect(claimedMessages(recorded, STEER)).toHaveLength(1)
      expect(assistantText(recorded)).toContain('BANANA')
      return
    }

-    // Durable: exactly one steering/message, inside turn 1, carrying the text.
-    const steerEvents = sessionEvents.filter(e => e.type === 'steering/message')
+    // Durable: exactly one claimed user/message carrying the steering text.
+    const steerEvents = claimedMessages(sessionEvents, STEER)
    expect(steerEvents).toHaveLength(1)
-    expect((steerEvents[0] as SessionEvent & { data: { turn: number } }).data.turn).toBe(1)
    expect(JSON.stringify(steerEvents[0])).toContain('BANANA')
    const turnEnds = sessionEvents.filter(e => e.type === 'turn/end')
    expect(turnEnds).toHaveLength(1)
@@ -182,7 +188,7 @@ describe('web e2e: composer shortcut steers directly', () => {

  it.skipIf(MODE === 'record')('uses Cmd+Enter without creating a Queue row', async () => {
    onTestFailed(() => saveFailureShot(page, 'web-e2e-composer-steering'))
-    expect(fixtureUserPrompts(await readFile(FIXTURE, 'utf8'))).toEqual([PROMPT])
+    expect(fixtureUserPrompts(await readFile(FIXTURE, 'utf8'))).toEqual([PROMPT, STEER])
    const input = page.locator('textarea').first()
    await input.waitFor({ timeout: 10_000 })
    const settled = scaffold.whenTurnSettled(30_000)
@@ -203,9 +209,8 @@ describe('web e2e: composer shortcut steers directly', () => {
    await composer.getByRole('radio', { name: 'Yes' }).press('Enter')
    await settled

-    const steerEvents = sessionEvents.filter(event => event.type === 'steering/message')
+    const steerEvents = claimedMessages(sessionEvents, STEER)
    expect(steerEvents).toHaveLength(1)
-    expect((steerEvents[0] as SessionEvent & { data: { turn: number } }).data.turn).toBe(1)
    await expect.poll(() => page.getByText(STEER, { exact: true }).count(), { timeout: 15_000 }).toBe(1)
    expect(await pendingSteering.count()).toBe(0)
    await expect.poll(() => page.getByText('BANANA', { exact: false }).count(), { timeout: 10_000 })
@@ -259,7 +264,7 @@ describe('web e2e: composer shortcut follows the swapped busy behavior', () => {
    const queuedRow = page.locator('[data-queue-dock]').getByRole('listitem').filter({ hasText: queuedText })
    await queuedRow.getByText(queuedText, { exact: true }).waitFor({ timeout: 10_000 })
    expect(await page.locator('[data-pending-steering]').filter({ hasText: queuedText }).count()).toBe(0)
-    expect(sessionEvents.filter(event => event.type === 'steering/message')).toHaveLength(0)
+    expect(claimedMessages(sessionEvents, queuedText)).toHaveLength(0)

    // Remove the asserted Queue row, then finish the recorded question turn
    // so replay teardown still proves that every fixture call was consumed.
--- a/apps/web/tests/trajectory-virtualization.e2e.ts
+++ b/apps/web/tests/trajectory-virtualization.e2e.ts
@@ -0,0 +1,309 @@
+// Browser contract for the tail-paged, virtualized Trajectory ledger. The
+// scenario proves that semantic row identity survives an older-page prepend,
+// DOM mounting stays bounded, and every scroll range remains reachable.
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import type { Browser, Page } from 'playwright'
+import { chromium } from 'playwright'
+import { afterAll, beforeAll, describe, expect, it, onTestFailed } from 'vitest'
+import type { StreamChunk } from '@deepseek-ai/dsh-llm'
+import type { ReplayEntry } from '@deepseek-ai/dsh-llm-replay'
+import { createChatScrollFixture } from './chat-scroll-fixture.ts'
+import {
+  launchWebScaffold,
+  seedSession,
+  watchConsole,
+  webSnapshotMode,
+  type WebScaffold,
+} from './scaffold.ts'
+import { newEnglishPage, saveFailureShot } from './support.ts'
+
+const MODE = webSnapshotMode()
+const SESSION_ID = 'trajectory-virtualization-e2e'
+const FIXTURE = createChatScrollFixture({
+  markerPrefix: 'TRAJECTORY_VIRTUAL',
+  title: 'TRAJECTORY_VIRTUAL long ledger',
+  turns: 88,
+})
+const MAX_MOUNTED_ROWS = 160
+const GEOMETRY_TOLERANCE = 2
+const STREAM_MARKER = 'TRAJECTORY_VIRTUAL_STREAM_FINISHED'
+const STREAM_TEXT = Array.from(
+  { length: 80 },
+  (_, index) => `stream fragment ${String(index + 1).padStart(2, '0')} `,
+).join('') + STREAM_MARKER
+
+const STREAM_CHUNKS: StreamChunk[] = [
+  { type: 'block-start', index: 0, blockType: 'text' },
+  ...Array.from({ length: 80 }, (_, index): StreamChunk => ({
+    type: 'text-delta',
+    index: 0,
+    text: `stream fragment ${String(index + 1).padStart(2, '0')} `,
+  })),
+  { type: 'text-delta', index: 0, text: STREAM_MARKER },
+  { type: 'block-end', index: 0, block: { type: 'text', text: STREAM_TEXT } },
+  { type: 'usage', usage: { inputTokens: 2_700, outputTokens: 240 } },
+  { type: 'finish', reason: { kind: 'stop' } },
+]
+
+interface ScrollGeometry {
+  readonly clientHeight: number
+  readonly scrollHeight: number
+  readonly scrollTop: number
+}
+
+interface RowAnchor {
+  readonly key: string
+  readonly top: number
+}
+
+async function openSeed(page: Page): Promise<void> {
+  const search = page.getByRole('textbox', { name: 'Search name, keywords...', exact: true })
+  await search.fill(FIXTURE.markers.user(1))
+  const result = page.getByRole('tree', { name: 'Search results' }).getByRole('treeitem')
+  await expect.poll(() => result.count(), { timeout: 60_000 }).toBe(1)
+  await result.click()
+  await page.getByRole('tab', { name: 'Trajectory', exact: true }).waitFor({ timeout: 30_000 })
+  await page.getByText(FIXTURE.markers.assistant(FIXTURE.turns), { exact: false })
+    .last()
+    .waitFor({ timeout: 30_000 })
+}
+
+async function openTrajectory(page: Page): Promise<void> {
+  await page.getByRole('tab', { name: 'Trajectory', exact: true }).click()
+  const pane = page.locator('[data-trajectory-scroll]')
+  await pane.waitFor({ timeout: 30_000 })
+  await page.locator('[data-trajectory-scroll] table[data-scroll-ready="true"]')
+    .waitFor({ timeout: 30_000 })
+}
+
+async function logicalRows(page: Page): Promise<number> {
+  const raw = await page.locator('[data-trajectory-scroll] table').getAttribute('aria-rowcount')
+  if (raw === null || !/^\d+$/.test(raw)) {
+    throw new Error(`trajectory table has invalid aria-rowcount ${JSON.stringify(raw)}`)
+  }
+  return Number(raw)
+}
+
+async function mountedRows(page: Page): Promise<number> {
+  return page.locator('[data-trajectory-scroll] tr[data-trajectory-row-key]').count()
+}
+
+async function geometry(page: Page): Promise<ScrollGeometry> {
+  return page.locator('[data-trajectory-scroll]').evaluate(host => ({
+    clientHeight: host.clientHeight,
+    scrollHeight: host.scrollHeight,
+    scrollTop: host.scrollTop,
+  }))
+}
+
+async function nextPaint(page: Page): Promise<void> {
+  await page.evaluate(() => new Promise<void>((resolve) => {
+    requestAnimationFrame(() => requestAnimationFrame(() => { resolve() }))
+  }))
+}
+
+async function scrollToRatio(page: Page, ratio: number): Promise<void> {
+  await page.locator('[data-trajectory-scroll]').evaluate((host, value) => {
+    const maximum = Math.max(0, host.scrollHeight - host.clientHeight)
+    host.scrollTop = Math.round(maximum * value)
+    host.dispatchEvent(new Event('scroll'))
+  }, ratio)
+  await nextPaint(page)
+}
+
+async function firstVisibleRow(page: Page): Promise<RowAnchor> {
+  return page.locator('[data-trajectory-scroll]').evaluate((host) => {
+    const hostBox = host.getBoundingClientRect()
+    const rows = [...host.querySelectorAll<HTMLElement>('tr[data-trajectory-row-key]')]
+    const row = rows.find((candidate) => {
+      const box = candidate.getBoundingClientRect()
+      return candidate.dataset.requestOnly !== 'true'
+        && box.bottom > hostBox.top
+        && box.top < hostBox.bottom
+    })
+    const key = row?.dataset.trajectoryRowKey
+    if (row === undefined || key === undefined) {
+      throw new Error('trajectory scrollport has no visible semantic row')
+    }
+    return { key, top: row.getBoundingClientRect().top - hostBox.top }
+  })
+}
+
+async function rowTop(page: Page, key: string): Promise<number | null> {
+  return page.locator('[data-trajectory-scroll]').evaluate((host, targetKey) => {
+    const rows = [...host.querySelectorAll<HTMLElement>('tr[data-trajectory-row-key]')]
+    const row = rows.find(candidate => candidate.dataset.trajectoryRowKey === targetKey)
+    return row === undefined
+      ? null
+      : row.getBoundingClientRect().top - host.getBoundingClientRect().top
+  }, key)
+}
+
+async function loadToFirstTurn(page: Page): Promise<void> {
+  const marker = FIXTURE.markers.user(1)
+  for (let attempt = 0; attempt < 12; attempt += 1) {
+    await scrollToRatio(page, 0)
+    if (await page.getByText(marker, { exact: false }).count() > 0) return
+    const before = await logicalRows(page)
+    await expect.poll(async () => ({
+      marker: await page.getByText(marker, { exact: false }).count() > 0,
+      rows: await logicalRows(page),
+    }), { timeout: 30_000 }).not.toEqual({ marker: false, rows: before })
+  }
+  throw new Error('trajectory did not reach the first turn after twelve older-page requests')
+}
+
+describe('web e2e: Trajectory virtualization over tail-paged history', () => {
+  let scaffold: WebScaffold
+  let browser: Browser
+  let page: Page
+  let tripwire: ReturnType<typeof watchConsole>
+  let replayDir: string
+
+  beforeAll(async () => {
+    replayDir = await mkdtemp(join(tmpdir(), 'dsh-trajectory-virtualization-'))
+    const replayFixture = join(replayDir, 'session.jsonl')
+    const replayOverride = join(replayDir, 'replay.override.json')
+    await writeFile(replayFixture, FIXTURE.log)
+    await writeFile(replayOverride, JSON.stringify([{
+      kind: 'chunks',
+      chunks: STREAM_CHUNKS,
+    } satisfies ReplayEntry]))
+    scaffold = await launchWebScaffold({
+      paceMs: 10,
+      replayFixture,
+      replayOverride,
+    })
+    await seedSession(scaffold, FIXTURE.log, SESSION_ID)
+    browser = await chromium.launch()
+    page = await newEnglishPage(browser, 900)
+    tripwire = watchConsole(page)
+    await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
+    await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    await page.getByText('1 session', { exact: true }).waitFor({ timeout: 30_000 })
+  }, 120_000)
+
+  afterAll(async () => {
+    await browser?.close()
+    await scaffold?.close()
+    await rm(replayDir, { recursive: true, force: true })
+  })
+
+  it.skipIf(MODE === 'record')('retains identity on prepend and reaches the bounded virtual range', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-trajectory-virtualization'))
+    await openSeed(page)
+
+    let held = false
+    let releaseHistory: () => void = () => {}
+    let finishHeldRequest: () => void = () => {}
+    const gate = new Promise<void>((resolve) => { releaseHistory = resolve })
+    const heldRequestFinished = new Promise<void>((resolve) => { finishHeldRequest = resolve })
+    await page.route('**/api/session.history', async (route) => {
+      const request = route.request().postDataJSON() as {
+        method?: string
+        payload?: { beforeSeq?: number }
+      }
+      if (!held && request.method === 'session.history' && request.payload?.beforeSeq !== undefined) {
+        held = true
+        await gate
+        try {
+          await route.continue()
+        } finally {
+          finishHeldRequest()
+        }
+        return
+      }
+      await route.continue()
+    })
+
+    try {
+      await openTrajectory(page)
+      const initialRows = await logicalRows(page)
+      expect(initialRows).toBeGreaterThan(0)
+      expect(await page.getByText('Initial System Prompt', { exact: true }).count()).toBe(0)
+      expect(await mountedRows(page)).toBeLessThanOrEqual(MAX_MOUNTED_ROWS)
+
+      await scrollToRatio(page, 0)
+      await expect.poll(() => held, { timeout: 15_000 }).toBe(true)
+      const anchor = await firstVisibleRow(page)
+      const selectedRow = page.locator(
+        `[data-trajectory-scroll] tr[data-trajectory-row-key=${JSON.stringify(anchor.key)}]`,
+      )
+      await selectedRow.click()
+      await expect.poll(() => selectedRow.getAttribute('aria-selected'), { timeout: 10_000 })
+        .toBe('true')
+
+      releaseHistory()
+      await expect.poll(() => logicalRows(page), { timeout: 60_000 }).toBeGreaterThan(initialRows)
+      await nextPaint(page)
+      await expect.poll(async () => {
+        const top = await rowTop(page, anchor.key)
+        return top === null ? Number.POSITIVE_INFINITY : Math.abs(top - anchor.top)
+      }, { timeout: 15_000 }).toBeLessThanOrEqual(GEOMETRY_TOLERANCE)
+      await expect.poll(() => selectedRow.getAttribute('aria-selected'), { timeout: 10_000 })
+        .toBe('true')
+      expect(await mountedRows(page)).toBeLessThanOrEqual(MAX_MOUNTED_ROWS)
+
+      await loadToFirstTurn(page)
+      await expect.poll(
+        () => page.getByText(FIXTURE.markers.user(1), { exact: false }).count(),
+        { timeout: 10_000 },
+      ).toBeGreaterThan(0)
+      const fullRows = await logicalRows(page)
+
+      await scrollToRatio(page, 0.5)
+      const middle = await geometry(page)
+      const maximum = middle.scrollHeight - middle.clientHeight
+      expect(middle.scrollTop).toBeGreaterThan(maximum * 0.25)
+      expect(middle.scrollTop).toBeLessThan(maximum * 0.75)
+      expect(await mountedRows(page)).toBeLessThanOrEqual(MAX_MOUNTED_ROWS)
+      expect(await mountedRows(page)).toBeLessThan(fullRows)
+
+      await scrollToRatio(page, 1)
+      await expect.poll(async () => {
+        const value = await geometry(page)
+        return value.scrollHeight - value.clientHeight - value.scrollTop
+      }, { timeout: 10_000 }).toBeLessThanOrEqual(GEOMETRY_TOLERANCE)
+      await expect.poll(
+        () => page.getByText(FIXTURE.markers.assistant(FIXTURE.turns), { exact: false }).count(),
+        { timeout: 10_000 },
+      ).toBeGreaterThan(0)
+      expect(await mountedRows(page)).toBeLessThanOrEqual(MAX_MOUNTED_ROWS)
+
+      const trajectoryScroll = page.locator('[data-trajectory-scroll]')
+      await trajectoryScroll.evaluate((host) => {
+        const measuredWindow = window as Window & { __trajectoryScrollCalls?: number }
+        measuredWindow.__trajectoryScrollCalls = 0
+        const original = host.scrollTo.bind(host)
+        const trackedScrollTo = (...args: [ScrollToOptions?] | [number, number]) => {
+          measuredWindow.__trajectoryScrollCalls = (measuredWindow.__trajectoryScrollCalls ?? 0) + 1
+          Reflect.apply(original, host, args)
+        }
+        host.scrollTo = trackedScrollTo as typeof host.scrollTo
+      })
+      const settled = scaffold.whenTurnSettled()
+      const input = page.locator('textarea').first()
+      await input.fill('Stream one deterministic response while Trajectory remains visible.')
+      await input.press('Enter')
+      await settled
+      await page.getByText('stream fragment 01', { exact: false }).waitFor({ timeout: 30_000 })
+      await nextPaint(page)
+      const streamingScrollCalls = await trajectoryScroll.evaluate(() => {
+        return (window as Window & { __trajectoryScrollCalls?: number })
+          .__trajectoryScrollCalls ?? 0
+      })
+      expect(streamingScrollCalls).toBeLessThanOrEqual(5)
+      expect(await mountedRows(page)).toBeLessThanOrEqual(MAX_MOUNTED_ROWS)
+      expect({
+        pageErrors: tripwire.pageErrors,
+        warnings: tripwire.warnings,
+      }).toEqual({ pageErrors: [], warnings: [] })
+    } finally {
+      releaseHistory()
+      if (held) await heldRequestFinished
+      await page.unroute('**/api/session.history')
+    }
+  }, 180_000)
+})
--- a/apps/web/tests/workspace-management.e2e.ts
+++ b/apps/web/tests/workspace-management.e2e.ts
@@ -90,9 +90,9 @@ describe('web e2e: workspace management (create / rename / flat view / hover aff
      { timeout: 10_000 },
    ).not.toBeUndefined()
    // First adoption births a blank Session+Agent whose workspace attach must
-    // settle before a test may delete the registration; the reuse path (same
-    // canonical cwd already has a blank session) creates no agent, so callers
-    // opt in only where a fresh attach is possible.
+    // settle before a test may delete the registration; re-registration after
+    // a delete mints a fresh blank Session+Agent too (the old cwd-only reuse
+    // path is gone), so callers opt in only where a fresh attach is possible.
    if (options.waitForAgent === true) {
      await expect.poll(() => scaffold.ctx.agents.list().length, { timeout: 10_000 })
        .toBeGreaterThan(agentsBefore)
@@ -251,8 +251,10 @@ describe('web e2e: workspace management (create / rename / flat view / hover aff
    expect((await scaffold.ctx.sessionPersistence.inspect(SessionId(SEED_ID))).events.length).toBeGreaterThan(0)

    // Re-registering the exact deleted path immediately, without a reload, is
-    // a supported reversible flow. It creates a fresh Workspace id without
-    // re-adopting the retained Session.
+    // a supported reversible flow. It creates a fresh Workspace id and does
+    // NOT re-adopt the retained (non-blank) Session; the New Session flow
+    // mints a fresh blank session and attaches it to the new registration
+    // (the old cwd-only blank reuse is gone, so the account is never empty).
    await adoptDirectory(scaffold.workspaceCwd)
    await expect.poll(
      () => scaffold.ctx.workspace.resolveByPath(scaffold.workspaceCwd),
@@ -261,7 +263,11 @@ describe('web e2e: workspace management (create / rename / flat view / hover aff
    const reregistered = await scaffold.ctx.workspace.resolveByPath(scaffold.workspaceCwd)
    expect(reregistered?.id).toBeDefined()
    expect(reregistered?.id).not.toBe(workspace.id)
-    expect(reregistered?.sessionIds).toEqual([])
+    await expect.poll(
+      () => reregistered?.sessionIds ?? [],
+      { timeout: 10_000 },
+    ).not.toEqual([])
+    expect(reregistered?.sessionIds).not.toContain(SEED_ID)
    await expect.poll(() => page.getByText('Ungrouped', { exact: true }).count(), { timeout: 10_000 })
      .toBeGreaterThanOrEqual(1)
    expect(await readFile(join(scaffold.workspaceCwd, 'workspace', 'a.txt'), 'utf8')).toBe('alpha\n')